Rust中如何为函数创建类型别名？编译报错问题求助

我想在Rust里给使用FnMut的函数创建类型别名来简化代码，写了示例代码但编译失败。加上dyn关键字后，又没法把这个类型别名当作trait来用。类似的写法在Haskell里能正常运行，我的实际需求是给nom库的Parser创建基于FnMut的类型别名。

我的Rust示例代码：

type MyType<T, V> = FnMut(T) -> (T, V);

fn compose<T, U, V>(fst: MyType<T, U>, snd: MyType<U, V>) -> MyType<T, V> {
    |mut& x| {
        let (t, u) = fst(x);
        let (_, v) = snd(u);
        (t, v)
    }
}

对应的Haskell代码（能正常运行）：

type MyType a b = a -> (a, b)

compose :: MyType a b -> MyType b c -> MyType a c
compose f g = \x ->
    let (a, b) = f x
        (_, c) = g b
    in  (a, c)

问题根源 #

Rust中的FnMut是trait而非具体类型，这和Haskell的函数类型本质不同：Haskell里a -> b是单一的具体函数类型，而Rust中每个闭包、函数项都是独有的匿名类型，它们只是实现了Fn/FnMut/FnOnce系列trait。直接将FnMut(...)作为类型别名的目标，Rust无法确定你要的是具体实现类型还是动态分发的trait对象，因此编译报错。

解决方案 #

方案1：泛型约束+impl Trait（静态分发，推荐） #

如果不需要动态分发（绝大多数场景首选），可以用泛型参数的trait约束替代类型别名，配合impl Trait返回值，既简化代码又保留静态分发的性能优势：

// 可选：用类型别名简化约束写法
type MyType<T, V, F> = F where F: FnMut(T) -> (T, V);

// 核心实现：用泛型约束限定参数类型，impl Trait返回闭包
fn compose<T, U, V, F1, F2>(mut fst: F1, mut snd: F2) -> impl FnMut(T) -> (T, V)
where
    F1: FnMut(T) -> (T, U),
    F2: FnMut(U) -> (U, V),
{
    move |x| {
        let (t, u) = fst(x);
        let (_, v) = snd(u);
        (t, v)
    }
}

方案2：dyn FnMut+智能指针（动态分发） #

如果需要动态分发（例如存储不同类型的闭包到同一容器），可以用dyn FnMut结合Box定义类型别名，因为trait对象是动态大小类型，必须用智能指针包裹才能传递：

type MyType<T, V> = Box<dyn FnMut(T) -> (T, V)>;

fn compose<T, U, V>(fst: MyType<T, U>, snd: MyType<U, V>) -> MyType<T, V> {
    Box::new(move |x| {
        let (t, u) = fst(x);
        let (_, v) = snd(u);
        (t, v)
    })
}

方案3：针对nom Parser的实际场景 #

nom的Parser trait本身基于FnMut，可以直接定义简化的类型别名适配：

use nom::{IResult, Parser};

// 动态分发版本的Parser别名
type MyDynParser<I, O> = Box<dyn Parser<I, O, nom::error::Error<I>>>;

// 静态分发版本的Parser别名（配合泛型约束）
type MyStaticParser<I, O, P> = P where P: Parser<I, O, nom::error::Error<I>>;

// 示例compose函数，适配nom的Parser
fn compose_nom<I, O1, O2, P1, P2>(mut p1: P1, mut p2: P2) -> impl Parser<I, O2, nom::error::Error<I>>
where
    P1: Parser<I, O1, nom::error::Error<I>>,
    P2: Parser<O1, O2, nom::error::Error<I>>,
{
    move |input| {
        let (rest, o1) = p1.parse(input)?;
        let (_, o2) = p2.parse(o1)?;
        Ok((rest, o2))
    }
}

内容的提问来源于stack exchange，提问作者gust