News for hackers. Stuff that matters.
Re:Rust for functional programmers by dbaupp on Sunday July 13, 2014 @06:29PM (#8028753)
Rust traits only don't support higher order types because they are missing from the whole language, i.e. it's not a philosophical difference between traits and type classes.

Also, Haskell has existential types, which are exactly like Rust's trait objects.

Re:Rust for functional programmers by thinkpad20 on Sunday July 13, 2014 @07:29PM (#8028898)
Rust has generics, which are higher order types (you can't have just a vector, it needs to be a vector "of something"). I'm not sure if the rust team would describe them that way, but there doesn't seem to be that much of a theoretical difference.

Thus if they wanted to, they could (presumably) allow for a higher-order trait like Functor:

    trait Functor {
      fn map<a, b> : (|a| -> b) -> Self<a> -> Self<b>
    }
(I'm not sure if that's valid syntax but you get the idea).

As for existential types, they're an area of Haskell I haven't really explored that much, but they seem to be seen as a bit more of an advanced feature than their equivalents in Rust or Java. Not just because they require a GHC extension and additional keywords, but because there's a bit more theoretical overhead to understand how they work, while the presentation in Rust/Java is more intuitive and straightforward.

Re:Rust for functional programmers by dbaupp on Sunday July 13, 2014 @07:51PM (#8028962)
> Rust has generics, which are higher order types (you can't have just a vector, it needs to be a vector "of something"). I'm not sure if the rust team would describe them that way, but there doesn't seem to be that much of a theoretical difference.

No, there's no first class "type level functions", i.e. you always need `Vec<T>`, and you can't ever write `Vec` by itself, which is what a true higher-order type is (and what Functor needs:

  impl Functor for Vec { ... } 
  impl Functor for Option { ... }
Thus, your example isn't at all possible now or even in the near future.
Re:Rust for functional programmers by thinkpad20 on Monday July 14, 2014 @10:30AM (#8031077)
I'm aware that my example isn't possible, which is why I said, "if they wanted to, they (presumably) could allow for..."

My point being that Rust restricts what one can do with higher-order types, but those types still exist and are expressible in the language. From a theoretical point of view, there doesn't seem to be any reason that they couldn't allow for traits on higher-kinded types -- they simply choose not to. Perhaps for performance reasons, or for simplicity, or for syntax or whatever, but I haven't seen any reason why they couldn't. That was the point that I was making.