Trait (computer programming)

In computer programming, a trait is a concept used in object-oriented programming: a trait represents a collection of methods that can be used to extend the functionality of a class. Essentially a trait is similar to a class made only of concrete methods that is used to extend another class with a mechanism similar to multiple inheritance, but paying attention to name conflicts, hence with some support from the language for a name-conflict resolution policy to use when merging.

Traits provide a "simple conceptual model for structuring object-oriented programs" similar to mixins. Traits provide a simple way to create classes that reuse behavior from software components.

Traits are somewhat between an interface and a mixin: an interface may define one or more behaviors via method signatures, while a trait defines behaviors via full method definitions, on the other side mixins include full method definitions and may also carry state through attributes while traits usually don't.

An interface is used by a class by "implementing" its methods. A mixin is used by a class by mixing-into itself all the features of the mixin: i.e. the attributes and the methods. A trait is used by a class by merging the collection of extra methods provided with some mechanism to resolve name conflicts.

Hence an object defined as a trait is created as the composition of methods, which can be used by other classes without requiring multiple inheritance. In case of a naming collision, when more than one trait to be used by a class has a method with the same name, the programmer must explicitly disambiguate which one of those methods will be used in the class; thus manually solving the "diamond problem" of repeated inheritance. This is different from other composition methods in object-oriented programming, where conflicting names are automatically resolved by scoping rules.

Whereas mixins can be composed only using the inheritance operation, traits offer a much wider selection of operations, including:

• symmetric sum: an operation that merges two disjoint traits to create a new trait
• override (or asymmetric sum): an operation that forms a new trait by adding additional methods possibly overriding some of the methods of an existing trait
• alias: an operation that creates a new trait by adding a new name for an existing method
• and exclusion: an operation that forms a new trait by removing a method from an existing trait. (Combined with the alias operation yields a shallow rename operation).

A trait differs from an interface in that it provides implementations of its methods, not just type signatures.

Properties

Traits have the following properties:

• Provides a set of methods that implement behaviour.
• Requires a set of methods that parameterize the provided behaviour.
• Traits can be composed:
  • Trait composition is symmetric; the ordering of adding traits does not matter. For example, given trait S = A + B, then trait T = B + A is the same as S.
  • Conflicting methods are excluded from the composition.
  • Nested traits are equivalent to flattened traits; the composition hierarchy does not affect the traits behaviour. For example given trait S = A + X, where X = B + C, then trait T = A + B + C is the same as S.

Supported languages

Traits come from the Self programming language and are supported by the following programming languages:

• Fortress programming language: Where they also play the role of types.
• Perl 5: Implemented with the Moose module, they are called "roles".
• Perl 6: It calls them "roles", and are a part of the language.
• JavaScript Delegation – Functions as Roles (Traits and Mixins)
• Java 8: Default methods
• Squeak Smalltalk
• D: using __traits language extension and std.traits module helper templates, for compile time traits. Available in D 2 since version 2.003, with later extended functionality. Together with other language features (notably templets and mixins) they allow flexible automatic generation of methods based on interfaces and types. D also allows explicit aliasing of member methods and variables, including forwarding to multiple member classes.
• Pharo
• PHP 5.4
• Ruby: Modules can be used to implement traits.
• Rust
• Lasso
• Scala The busy Java developer's guide to Scala: Of traits and behaviors
• Python: using a Traits package
• Groovy: From version 2.3
• Kotlin
• Racket

Traits for the Smalltalk programming language were initially developed at the Software Composition Group, University of Bern. AmbientTalk combines the properties of Self traits (object-based multiple inheritance) and Smalltalk's Squeak traits (requiring explicit composition of traits by the programmer); AmbientTalk builds upon the research on stateful and freezable traits to enable state within traits, which was not allowed in the first definitions.

The concept has been applied as libraries to mainstream languages like C++, PHP, and JavaScript.

Abstract classes as mixins in the multiple-inheritance Curl programming language permit method implementations and thus constituted traits by another name. Module mixins in Ruby are similar to traits to some degree. Racket supports traits as a library and uses macros, structures, and first-class classes to implement them.

Implementation

In computer programming, a traits class is a class template used to associate state and/or behaviour to a compile-time entity, typically a data type or a constant, without modifying the existing entity. In the C++ programming language and PHP programming language, this is normally achieved by defining a primary class template, and creating explicit or partial specializations for the relevant types.

It is used in Standard Template Library and the C++ standard library to support generic container classes. The technique is used extensively in the Boost TypeTraits library.

Traits function differently in PHP. Since version 5.4.0, PHP allows users to specify templates that provide the ability to "inherit" from more than one (trait-)class, as a pseudo multiple inheritance. Traits in PHP are not as dynamic as C++ in using different data types.

Examples

PHP

Since version 5.4.0 PHP allows traits. This example uses one template class (trait) to enhance another class:

// The template
trait TSingleton
{
    private static $_instance = null;

    public static function getInstance()
    {
        if (null === self::$_instance)
        {
            self::$_instance = new self();
        }

        return self::$_instance;
    }
}

class FrontController
{
    use TSingleton;
}

// Can also be used in already extended classes
class WebSite extends SomeClass
{
    use TSingleton;
}

This gives the user power to simulate aspects of multiple inheritance:

trait TBounding
{
    public $x, $y, $width, $height;
}

trait TMoveable
{
    public function moveTo($x, $y)
    {
        // ...
    }
}

trait TResizeable
{
    public function resize($newWidth, $newHeight)
    {
        // ...
    }
}

class Rectangle
{
    use TBounding, TMoveable, TResizeable;

    public function fillColor($color)
    {
        // ...
    }
}

External links

• Generic Programming Techniques from Boost
• iterator_traits<Iterator> from SGI
• Traits: a new and useful template technique, Nathan C. Myers, C++ Report, June 1995 issue
• Traits - PHP Documentation
• Traits
• traits.js - Traits for JavaScript
• CocktailJS - ANNOTATIONS. TRAITS. TALENTS., April 2013
• The many talents of JavaScript for generalizing Role Oriented Programming approaches like Traits and Mixins, April 11, 2014