是否有一个内在的原因可以解释为什么 Rust 没有更高种类的类型

发布于09月25日

rust 没有更高级的种类.例如，函子(以及单子)不能用 rust 迹书写.我想知道是否有一个深刻的原因来解释这一点，为什么.

例如，我能理解的原因可能是，不存在使HKT成为可能的零成本抽象.或者类型推断要困难得多.当然，我也在寻找一个真正的局限性.

如果anwer已经在其他地方提供了，你能给我链接吗？

推荐答案

Time & Priority

从本质上来说，缺少更高级的类型并不是一个设计决定.这是为了让Rust有某种形式，目前更受欢迎的候选人是Generic Associated Types (2017)人.

不过，实现这些功能需要时间，而且与其他功能相比，还没有被视为优先事项.例如，async/await优先于HKTs，而const泛型似乎也优先于HKTs.

例如，函子(以及单子)不能用Rust编写.

事实上，他们可以，尽管这是一个bit的笨拙.

参见他在https://www.reddit.com/r/rust/comments/cajn09/new_method_for_emulating_higherkinded_types_in/上发布的Edmund's Smith lovely hack:

trait Unplug {
    type F; //The representation type of the higher-kinded type
    type A; //The parameter type
}

trait Plug<A> {
    type result_t;
}

pub  struct  Concrete<M: Unplug + Plug<A>,A> {
    pub unwrap: <M as Plug<A>>::result_t
}

impl<M: Unplug + Plug<A>, A> Concrete<M,A> {
    fn of<MA: Unplug<F=M, A=A> + Plug<A>>(x: MA) -> Self
        where M: Plug<A, result_t = MA>
    {
        Concrete { unwrap: x }
    }
}

他们实现了Functor个特征:

pub trait Functor: Unplug + Plug<<Self as Unplug>::A> {
    fn map<B, F>(f: F, s: Self) -> <Self as Plug<B>>::result_t
        where
            Self: Plug<B>,
            F: FnMut(<Self as Unplug>::A) -> B
        ;
}

//  Example impl for a represented Vec
impl<A> Functor for Concrete<Vec<forall_t>, A> {
    //  remember, Self ~ (Vec<_>, A) ~ "f a"
    fn map<B, F>(f: F, s: Self) -> <Self as Plug<B>>::result_t
        where
            F: FnMut(<Self as Unplug>::A) -> B 
    {        
        Concrete::of(s.unwrap.into_iter().map(f).collect())
    }
}

从那时起，建造Applicative和Monad:

pub trait Applicative: Functor {
    fn pure(s: <Self as Unplug>::A) -> Self;

    fn app<B, F>(
        f: <Self as Plug<F>>::result_t, //M<F>
        s: Self                         //M<A>
    ) -> <Self as Plug<B>>::result_t   //M<B>
    where
        F: FnMut(<Self as Unplug>::A) -> B + Clone,
        Self: Plug<F> + Plug<B> + Unplug,
        <Self as Plug<F>>::result_t:
            Unplug<F=<Self as Unplug>::F, A=F> +
            Plug<F> +
            Clone,
        <Self as Unplug>::F: Plug<F>
    ;
}

pub trait Monad : Applicative {
    fn bind<F,B>(f: F, s: Self) -> <Self as Plug<B>>::result_t
    where
        Self: Plug<F>+Plug<B>,
        F: FnMut(<Self as Unplug>::A) ->
            <Self as Plug<B>>::result_t + Clone
        ;
}

I did say it was a bit unwieldy...