Hacker News Reader

Comment by rkangel | Hacker News Reader

> And with a much better object oriented system based on Traits

Note that Traits are a system for generics specifically. You can have useful OO without generics (C++ is useful without templates, go does't have them at all).

View on HN

Traits go a bit beyond generics, in my view. You can say i'm a "smug Lisp coder", but after having used CLOS (Common Lisp Object System), i'd say that generics are one of the most useful things you can have in OOP.

With Traits you can separate implementation of certain methods (implementation of Traits) from object definitions. Which for me is excellent, and approaches CLOS' way (in CLOS methods are not directly coupled to a particular object; methods are applied to the combination of one (or more) object(s).

In a similar way as English language; where you apply an action involving many subects: "Angel transport his luggage using a car." Here the 'transport' action can't really be bound to the Person class, nor the Luggage class. Perhaps it belongs on the Car class, but with CLOS you can just define "transport" to act on the combination of <actor> <object to be transported> and <vehicle>.

"Transport", thus, is a "generic method" and can be defined (implemented) for all kinds of class combinations.

With Traits you can achieve something more or less similar, by defining the necessary Traits for each kind of class, to be able to have all of them "transport" harmoniously. So Traits can link (and then impement) the operations performed between classes, without having to bound the code to a particular class.

CLOS: A combination of applicable methods from a generic function is applied to objects.

In Rust, you can have functions/enums/structs that are generic without traits, and you can have traits that aren't generic. Generics and traits are orthogonal features.

Can you give me an example of a function, enum or struct that is generic without traits?

The standard library's own `Vec` type is an example of a struct that is generic without traits. See the source: https://github.com/rust-lang/rust/blob/4ed2edaafe82fb8d44e81... . In fact, almost no struct or enum uses traits in combination with generics. On the other hand, generic functions do almost always leverage traits, because otherwise you basically can't do anything in the function with the generic parameter.

However, note that there does exist a very important generic function in the stdlib that doesn't use traits at all: `std::mem::drop`. Here's the source, which is very, very interesting: https://github.com/rust-lang/rust/blob/4ed2edaafe82fb8d44e81... . And no, I'm not being facetious when I call it interesting; figuring out what `std::mem::drop`'s purpose is from its amusing implementation is a test that you understand what ownership means in Rust. :)

That's the way round I meant. Yes you can have generics without traits (particularly with data structures as you've pointed out). Not sure of anything that uses traits without generics.

> Not sure of anything that uses traits without generics.

Traits do a lot of things in Rust that have nothing to do with generics. :) Implementing a trait is how one gives a type a destructor. Implementing various traits (the ones in std::ops) allows one to do operator overloading for user-defined types. Defining a trait allows one to give methods to types that are defined in other compilation units, including the standard library, e.g.:

    trait Foo {
        fn foo(self);
    }
    
    impl Foo for i32 {
        fn foo(self) {
            println!("Hello, traits!");
        }
    }
    
    fn main() {
        42.foo();  // Hello, traits!
    }

Thank you for that.

How about Read and Write, two of the most widely-used traits?

https://doc.rust-lang.org/std/io/trait.Read.html https://doc.rust-lang.org/std/io/trait.Write.html

But those are excellent examples of the use of generics. They allow you write code that can operates on a generic object, not know what type it is, but know that you can read from it.

Oh, I think I see what you're saying. If I'm understanding correctly, then you're saying that the types that traits define are only used with generics? This isn't quite correct, as you can use trait objects to get dynamic dispatch rather than using generics. But yes, in general, functions that are defined to take traits as parameters generally use generics. I'm not sure I'd still consider the idea of traits to be inherently tied to generics, though; the Iterator trait, for instance, is usually just used to call Iterator methods on different types rather than as a way to bound the types of function parameters.

Somewhat facetiously:

    fn identity<T>(t: T) -> T { t }

Has no trait bounds, and is clearly generic. You typically can't do very much with completely free type variables, but Rust has syntactic support for them.

And even that implicitly relies on the Sized trait.

Reply on news.ycombinator.com