mixins

Mixins can be instantiated with different parent classes depending on the requirements of a particular context.

Mixins are allowed to have parameters, just like components.

By incorporating mixins using generic types, we are able to work around many of the key limitations of other formulations of mixins.

The reason: both mixins and generic classes can be thought of as functions mapping existing classes to new classes.

Nevertheless, it's a very unfortunate restriction because it limits the set of classes eligible to be turned into mixins.

But it is appealing, almost seductive, to incorporate mixins as part of a generic type system.

Mixins can be viewed as functions mapping existing classes to new subclasses.

The Mixins annotation allows a list of mixing names to be specified.

Mixins: allow to extract common groups of properties, name them and then include them in selectors.

When mixins are formulated as generic classes, the problem of accidental overrides is particularly nasty.

With mixins formulated as generic classes, we always have a handle on the parent class, the type parameter that the class extends.

However, there are other significant difficulties with formulating mixins as generic types.

This can mean generating new objects from a runtime definition or based on mixins of existing types or objects.

Mixins are classes that are parameterized by their parent class.

Although mixins are simply a design pattern in these languages, there's no reason why they can't be supported at the language level.

Static members are associated with instantiations of mixins; there are no "shared" static members of mixins.

In the case of mixins as generic types, we can apply the same solution.

Thus, in Jam, the visitor pattern can't be used with mixins.

This is where a very useful feature comes in: Mixins.