Rust 支持可能寿命的高阶函数

假设我有一个高阶函数，例如：

这也不会编译。现在的问题是，

compose

试图在每次调用结果函数时获得

f

的所有权。我看不到一种方法来修复

用_id

编写_（不坚持

F:Copy

）

compose

拥有

f

的所有权，这只能发生一次，因此我们必须选择一个生存期，但返回值需要处理任何生存期

我们可以创建一个用于引用的

compose

变体：

fn compose<A, B, C, G, F>(f: F, g: G) -> impl Fn(&A) -> C
where
    F: Fn(&A) -> &B,
    G: Fn(&B) -> C,
{
    move |x| g(f(x))
}

fn组合（f:f，g:g）->impl-fn（&A）->C
哪里
F:Fn（&A）->&B，
G:Fn&B）->C，
{
移动| x | g（f（x））
}

（其返回值具有HRTB），但不能用于非参考输入

---

我如何定义

compose

，以便它可以部分应用于不可复制的函数（有或没有引用输入？

如何添加生存期注释以使用\u id进行组合

fn compose_with_id<'a, T, U, F>(f: F) -> impl Fn(&'a T) -> U
where
    T: 'a,
    U: 'a,
    F: Fn(&'a T) -> U,
{
    compose(id, f)
}

fn用_idu组合
哪里
T:a，
U:a，
F:Fn（&'a T）->U，
{
组合（id，f）
}

这使得带有id的compose_的返回类型更窄（即对于某些特定的

'a

，而不是对于U），但这可能是我们能做的最好的了。

fn compose_with_id<T, U, F>(f: F) -> impl Fn(&T) -> U
where
    F: Fn(&T) -> U
{
    move |t| compose(id, f)(t)
}

fn compose<A, B, C, G, F>(f: F, g: G) -> impl Fn(&A) -> C
where
    F: Fn(&A) -> &B,
    G: Fn(&B) -> C,
{
    move |x| g(f(x))
}

fn compose_with_id<'a, T, U, F>(f: F) -> impl Fn(&'a T) -> U
where
    T: 'a,
    U: 'a,
    F: Fn(&'a T) -> U,
{
    compose(id, f)
}