HKTs plans for TypeScript [OT]


Quasi-approved HKTs for TypeScript:

In approximated Rust-esque:

trait Monad<T<*>> {
    fn map<A, B>(f: &Fn(A) -> B) -> Box<Fn(T<A>) -> T<B>>;
    fn lift<A>(a: A) -> T<A>;
    fn join<A>(tta: T<T<A>>) -> T<A>;

trait Cartesian<T<*>> {
    fn all<A>(a: Vec<T<A>>) -> T<Vec<A>>;

trait Foo<T<*, *>> {
    fn bar<A, B>(f: Fn(A) -> B) -> T<A, B>;

Add lifetimes and the different Rust closures, and things get more “interesting” :slight_smile:


Ah being able to specify a generic bound on a generic parameter would be interesting!

I wonder how it would hypothetically resolve T<*> for A where:

struct A;

impl Trait1<B> for A { }

impl Trait2<B> for A { }

I guess you could limit it on the struct definition and not traits, that example is actually a fairly flimsy argument.


Maybe I’m wrong but shouldn’t topics like this go under the section? (I know it was marked OT but still as it may spawn more interesting discussion over there)


I am sometimes shy in posting in the internals group, but you’re right. Do you know if there’s a way to move a thread there? :slight_smile:


Sorry but I have no idea :slight_smile:


There is not, as they’re totally separate instances.


Looks like the example uses Haskell-like syntax that ignores Self and also has explicit currying, in Rust it would have to be:

trait<*> Monad {
    fn map<A, B>(f: &Fn(A) -> B, ta: Self<A>) -> Self<B>;
    fn lift<A>(a: A) -> Self<A>;
    fn join<A>(tta: Self<Self<A>>) -> Self<A>;

trait<*> Cartesian {
    fn all<A>(a: Vec<Self<A>>) -> Self<Vec<A>>;

trait<*, *> Foo {
    fn bar<A, B>(f: Fn(A) -> B) -> Self<A, B>;

Although a syntax like trait Monad: type<type> {...} is probably better suited for Rust.