Re:Announcing Rust 1.0 Alpha
by mopo2000 on Friday January 09, 2015 @03:09PM
(#8864203)
How can you have an alpha without generics?
[ Parent
| on HN ]
You can read up here: http://doc.rust-lang.org/book/generics.html, as well about "output" generics here: https://github.com/rust-lang/rfcs/blob/master/text/0195-asso..., and explore usage in collections here: http://doc.rust-lang.org/nightly/std/collections/.
Are "Traits" basically C++ Concepts?
Somewhere between C++ concepts and Haskell typeclasses with a hint of Java interfaces.
But yes, their primary usage is to require that type parameters exhibit a certain set of properties.
For someone who knows C#, I would explain them as abstract extension methods that can be overriden for specific types.
They fill the same role as concepts - ie. bringing type checking to the call site when using parametrized types, rather than using a duck typed approach, which leads to the big template stack traces that you get in C++.
Re:Announcing Rust 1.0 Alpha
by steveklabnik on Friday January 09, 2015 @05:42PM
(#8864958)
There are some technical details that make them different, if I recall correctly. But they're kinda similar. They're also close to Haskell's typeclasses.
I think you misunderstood something somewhere. This alpha definitely has generics. For example:
enum Option<T> { Some{value: T}, None }
Re:Announcing Rust 1.0 Alpha
by steveklabnik on Friday January 09, 2015 @03:12PM
(#8864220)
We have them.
Like three different kinds, too!
// Old-style generics; monomorphized
// with S as an "input" type of MyTrait
fn foo<S, T: MyTrait<S>>(elem: T) { ... }
// Where-clause-style generics; monomorphized,
// with S as an "output" (associated) type of MyTrait
fn foo<S, T>(elem: T)
where T: MyTrait<Thing = S> { ... }
// Trait objects; dynamic dispatch
fn foo(elem: Box<MyTrait>) { ... }Well, the first two are really just the same thing :P
Eh, with the new oprhan/impl rules associated and uh... not... associated(...?) types have developed quite a schism.
Well, the first two confusingly change two variables at once: the things that are the same (which I presume is what kimundi meant) are
fn foo<S, T: MyTrait<S>>(elem: T) { ... }
fn foo<S, T>(elem: T) where T: MyTrait<S> { ... }
and fn foo<S, T: MyTrait<Thing = S>>(elem: T) { ... }
fn foo<S, T>(elem: T) where T: MyTrait<Thing = S> { ... }To be fair, there were _some_ languages and frameworks which did not have generics on the 1.0 release. It is a bit strange to assert that a new language should.
It's pretty hard to add them afterwards in a backward-compatible way that is not a great hack
Re:Announcing Rust 1.0 Alpha
by pinumbernumber on Friday January 09, 2015 @03:33PM
(#8864326)
It does have generics, unless I'm misunderstanding you