Mixins vs. Traits

by
  1. Mixins may contain state, (traditional) traits don’t.
  2. Mixins use “implicit conflict resolution”, traits use “explicit conflict resolution”
  3. Mixins depends on linearization, traits are flattened.

Lecture about traits

ad 1.
In mixins you can define instance variables. Traits do not allow this. The state must be provided by the composing class (=class using the traits)

ad 2.
There may be the name conflict. Two mixins (MA and MB) or traits (TA and TB) define the method with the same definition foo():void.

Mixin MA {
    foo():void {
        print 'hello'
    }
}

Mixin MB {
    foo():void {
        print 'bye'
    }
}

Trait TA {
    foo():void {
        print 'hello'
    }
}

Trait TB {
    foo():void {
        print 'bye'
    }
}

In mixins the conflicts in composing class C mixins MA, MB are resolved implicitly.

Class C mixins MA, MB {
    bar():void {
        foo();
    }
}

This will call foo():void from MA

On the other hand while using Traits, composing class has to resolve conflicts.

Class C mixins TA, TB {
    bar():void {
        foo();
    }
}

This code will raise conflict (two definitions of foo():void).

ad 3.
The semantics of a method does not depend of whether it is defined in a trait or in a class that uses the trait.

In other words, it does not matter whether the class consists of the Traits or the Traits code is “copy – pasted” into the class.

More Related Contents:

  1. What is a mixin and why is it useful?
  2. Mixins for ES6 classes, transpiled with babel
  3. Mixing in a trait dynamically
  4. “Expected type parameter” error in the constructor of a generic struct
  5. How to get a reference to a concrete type from a trait object?
  6. Java Multiple Inheritance
  7. What is the difference between self-types and trait subclasses?
  8. How do I return an instance of a trait from a method?
  9. What is the advantage of using abstract classes instead of traits?
  10. What is a sealed trait?
  11. Multiple inheritance for an anonymous class
  12. How does Python’s “super” do the right thing?
  13. Conflicting implementations of trait in Rust
  14. How to override trait function and call it from the overridden function?
  15. Traits in PHP – any real world examples/best practices? [closed]
  16. Linearization order in Scala
  17. Resolving metaclass conflicts
  18. Functional programming and non-functional programming
  19. How can interfaces replace the need for multiple inheritance when have existing classes
  20. Generics Error: expected type parameter, found struct
  21. When to use val or def in Scala traits?
  22. Cake pattern with overriding abstract type don’t work with Upper Type Bounds
  23. Can I avoid eager ambiguity resolution for trait implementations with generics?
  24. Why can a Scala trait extend a class?
  25. Can traits be used on enum types?
  26. Is Multiple Inheritance allowed at class level in PHP?
  27. Implement fmt::Display for Vec
  28. How to reference a generic return type with multiple bounds
  29. When virtual inheritance IS a good design?
  30. Do I have to implement a trait twice when implementing it for both reference and non-reference types?

Leave a Comment