在尝试编译以下代码时：
```rust
fn make<DomainType>(foo: fn(DomainType) -> ()) -> Box<dyn Fn(DomainType) -> ()> {
    let foo_clone = foo.clone();
    let bar = move |input: DomainType| {foo_clone(input)};
    Box::new(bar)
}
fn main() {}

error[E0310]: 参数类型 `DomainType` 可能无法存活足够长时间
 --> src/main.rs:4:5
  |
4 |     Box::new(bar)
  |     ^^^^^^^^^^^^^ ...以满足类型 `[closure@src/main.rs:3:15: 3:58]` 的必需生命周期边界
  |
帮助：考虑添加一个显式的生命周期边界...
  |
1 | fn make<DomainType: 'static>(foo: fn(DomainType) -> ()) -> Box<dyn Fn(DomainType) -> ()> {
  |                   +++++++++
要了解更多关于此错误的信息，请尝试运行 `rustc --explain E0310`。

<details>
<summary>英文:</summary>
In trying to compile the code

The compiler gives

I have been reading through similar questions
https://stackoverflow.com/questions/29740488/parameter-type-may-not-live-long-enough
and 
https://stackoverflow.com/questions/40053550/the-compiler-suggests-i-add-a-static-lifetime-because-the-parameter-type-may-no
But in both of those examples, the boxed trait is what needs the added lifetime.  In this case it's apparently just the DomainType of the closure trait.  I'm quite baffled what to make of this.  
My understanding of lifetime variables in function definitions is that they connect the lifetime of the returned type (which I can understand is implicitly static here, or at least the thing inside the box is) to those (perhaps elided) lifetimes of the function parameters.  But no function parameter here is a `DomainType`.
</details>
# 答案1
**得分**: 3
免责声明：这个问题涉及到 Rust 编译器的具体细节，我对我在这里说的一切都不是百分之百确定的。请谨慎对待所有内容。
问题在于，如果没有注释寿命（lifetime），`Box&lt;T&gt;` 表示 `T` 是 `&#39;static`。
然而，泛型不一定是这样的。泛型可以包含任何类型的寿命。为了匹配两者，你需要明确注释寿命。
## 解决方案 1
你**可以**为泛型添加 `&#39;static` 注释，如下所示：
```rust
fn make&lt;DomainType: &#39;static&gt;(foo: fn(DomainType)) -&gt; Box&lt;dyn Fn(DomainType)&gt; {
    Box::new(foo)
}

fn my_func(x: &str) {
    println!("my_func: {}", x);
}
fn main() {
    let x = "abc".to_string();
    let f = make(my_func);
    f(&x);
}

error[E0597]: `x` does not live long enough
  --> src/main.rs:13:7
   |
13 |     f(&x);
   |     --^^-
   |     | |
   |     | borrowed value does not live long enough
   |     argument requires that `x` is borrowed for `'static`
14 | }
   | - `x` dropped here while still borrowed

fn make<'a, DomainType: 'a>(foo: fn(DomainType)) -> Box<dyn Fn(DomainType) + 'a> {
    Box::new(foo)
}

fn my_func(x: &str) {
    println!("my_func: {}", x);
}
fn main() {
    let x = "abc".to_string();
    let f = make(my_func);
    f(&x);
}

my_func: abc

fn make<'a, DomainType: 'a>(foo: fn(DomainType)) -> Box<dyn Fn(DomainType) + 'a> {
    Box::new(foo)
}
fn my_func(x: &str) {
    println!("my_func: {}", x);
}
fn make2() -> Box<dyn Fn(&str)> {
    Box::new(|x| println!("closure: {}", x))
}
fn main() {
    let x = "abc".to_string();
    let f = make(my_func);
    let f2 = make2();
    let fs = [f2, f];
}

error[E0308]: mismatched types
  --> src/main.rs:19:19
   |
19 |     let fs = [f2, f];
   |                   ^ one type is more general than the other
   |
   = note: expected trait object `dyn for<'r> Fn(&'r str)`
              found trait object `dyn Fn(&str)`

fn make<'a, DomainType: 'a>(foo: fn(DomainType)) -> Box<dyn Fn(DomainType) + 'a> {
    Box::new(foo)
}
fn my_func(x: &str) {
    println!("my_func: {}", x);
}
fn make2() -> Box<dyn Fn(&str)> {
    Box::new(|x| println!("closure: {}", x))
}
fn main() {
    let f = make(my_func);
    let f2 = make2();
    {
        let x = "abc".to_string();
        f2(&x); // 可以工作
        f(&x); // 无法编译通过
    }
}

error[E0597]: `x` does not live long enough
  --> src/main.rs:20:11
   |
20 |         f(&x); // 无法编译通过
   |           ^^ borrowed value does not live long enough
21 |     }
   |     - `x` dropped here while still borrowed
22 | }
   | - borrow might be used here, when `f` is dropped and runs the destructor for type `Box<dyn Fn(&str)>`
   |
   = note: values in a scope are dropped in the opposite order they are defined

fn make<F, DomainType>(foo: F) -> Box<dyn Fn(DomainType)>
where
    for<'r> F: Fn(DomainType) + Clone + 'r
{
    let foo_clone = foo.clone();
    let bar = move |input: DomainType| {foo_clone(input)};
    Box::new(bar)
} 

fn make<F, DomainType>(foo: F) -> Box<dyn Fn(DomainType)> 
where 
    for<'r> F: Fn(DomainType) + 'r 
{
    Box::new(foo)
} 

fn make<F, DomainType>(foo: &F) -> Box<dyn Fn(DomainType)> 
where 
    for<'r> F: Fn(DomainType) + Clone + 'r 
{
    Box::new(foo.clone())
}