Recently, I saw different places where this was given as example code, and writing it in my editor, it seems to be valid code.

最近，我看到了不同的地方，这是作为示例代码给出的，在我的编辑器中编写它，它似乎是有效的代码。

trait Trait {}

impl<T> Trait for T {}

I can't seem to find any documentation explaining this; I'm sure it exists, but I don't really know what to google.

我似乎找不到任何解释这一点的文档；我确信它存在，但我真的不知道要用谷歌搜索什么。

How would you instantiate T to and then call any methods within the impl block?

如何将T实例化到Impl块中，然后调用其中的任何方法？

I'm sure there is a good reason for this, but I can't seem to wrap my head around it, would anyone be able to link the relevant documentation for this feature in rust?

我相信这是有很好的理由的，但我似乎不能理解它，有谁能够链接到Ruust中这个特性的相关文档？

I realise from the answers that I may have not been clear; I had copied the example from what I’ve seen.

我从答案中意识到我可能没有说清楚;我从我所看到的例子中复制了这个例子。

Though from the first answer, I realised that the below code is also valid, and perhaps a more clear representation of what I’m trying to ask, which is, what is the use for the generics syntax that allows this code to be valid:

虽然从第一个答案中，我意识到下面的代码也是有效的，并且可能更清楚地表达了我试图询问的问题，即允许此代码有效的泛型语法有什么用处：

trait Trait {
    fn test() -> String {
        "test".to_string()
    }
}

impl<T> Trait for T {}

Does this affect existing structs and enums in the file, or does it literally just do absolutely nothing, and can never be called or used?

这是否会影响文件中现有的结构和枚举，或者它实际上什么都不做，永远不能调用或使用？

This code is showing you two things: marker traits and blanket implementations.

这段代码向您展示了两件事：标记特征和全面实现。

trait Foo {} (with no trait members) declares a marker trait which serves only to tag certain types. The built-in traits Copy, Send, and Sync are good examples of marker traits.

特征foo{}(没有特征成员)声明了一个标记特征，该标记特征仅用于标记某些类型。内置特征Copy、Send和Sync就是标记特征的很好例子。

impl<T> Foo for T {} implements the trait Foo for all types, a so-called blanket implementation.

Iml Foo for T{}为所有类型实现了特征Foo，即所谓的一揽子实现。

Together, this is pretty much redundant, because there isn't a difference between "type that implements Foo" and "all types."

总而言之，这几乎是多余的，因为“实现foo的类型”和“所有类型”之间没有区别。

However, seemingly-useless blanket implementations can actually be useful in practice. In the Rust standard library, there is a blanket implementation impl<T> From<T> for T which tells Rust "you can convert any T to T." This is not useful on its own, but winds up being useful in generic code, such as fn foo(arg: impl Into<i32>) which lets you pass an argument of any type that can be infallibly converted to i32. Because of the blanket implementation, this includes i32 itself.

然而，看似毫无用处的全面实现实际上可能是有用的。在Rust标准库中，有一个全面的实现impl from for T，它告诉Rust“您可以将任何T转换为T”。这本身并不有用，但在泛型代码中很有用，比如fn foo(arg：impl into )，它允许您传递可以正确地转换为I32的任何类型的参数。由于全面实现，这包括I32本身。

How would you instantiate T to then call any methods within the impl block?

Well, the body of the impl block can't have anything in this case. The body of an impl ... for block is to implement trait members, but the trait being implemented has no members.

在这种情况下，Impl块的主体不能有任何东西。一辆汽车的车身...块是实现特征成员，但要实现的特征没有成员。

If we assume that the trait does have members, then the answer to your question would be that you would have to bound T in a way that lets you perform operations on it. For example, to create a T you could choose to add the bound T: Default which would let you call T::default() to create an instance of T with a (type-defined) default value.

如果我们假设特征确实有成员，那么您的问题的答案将是您必须以一种允许您对其执行操作的方式来绑定T。例如，要创建一个T，您可以选择添加绑定的T：Default，这将允许您调用T：：Default()来创建具有(类型定义的)缺省值的T的实例。

Note that adding bounds on T would change the scope of the implementation to only apply to types that satisfy the bounds. This is very common in practice. For example, the implementation of Clone on Vec<T> is bounded on T: Clone. (How would you clone a vector if you can't clone its elements, after all?)

请注意，在T上添加边界会将实现的范围更改为仅应用于满足边界的类型。这在实践中是很常见的。例如，在VEC 上实现Clone是在T：Clone上绑定的。(如果你毕竟不能克隆载体的元素，你怎么克隆它呢？)

Further reading:

进一步阅读：

• The Rust Programming Language - Traits: Defining Shared Behavior