Would someone explain when I would want to use [Groovy Traits][1] vs. Mixins (@Mixin) vs. Delegates (@Delegate)? Maybe some trade-offs and design concerns would help.

They all seem to allow for reusing multiple &quot;classes&quot; of behavior. Thanks. :-)

This SO thread was helpful too: https://stackoverflow.com/questions/8527500/difference-between-delegate-and-mixin-ast-transformations-in-groovy

  [1]: http://beta.groovy-lang.org/docs/groovy-2.3.0-SNAPSHOT/html/documentation/core-traits.html

Difference between @Delegate, @Mixin and Traits in Groovy?

I wanted to implement the `Shl` trait for `Vec`, the code is below. This would make things like `vec &lt;&lt; 4` possible, which would be nice sugar for `vec.push(4)`.

    use std::ops::Shl;
    
    impl&lt;T&gt; Shl&lt;T&gt; for Vec&lt;T&gt; {
        type Output = Vec&lt;T&gt;;
    
        fn shl(&amp;self, elem: &amp;T) -&gt; Vec&lt;T&gt; {
            self.push(*elem);
            *self
        }
    }
    
    fn main() {
        let v = vec![1, 2, 3];
        v &lt;&lt; 4;
    }

The compilation fails with the following error:

&lt;!-- language: none --&gt;

&gt; cannot provide an extension implementation where both trait and type are not defined in this crate [E0117]

or

&lt;!-- language: none --&gt;

&gt; type parameter `T` must be used as the type parameter for some local type (e.g. `MyStruct&lt;T&gt;`); only traits defined in the current crate can be implemented for a type parameter [E0210]

As I understand it, I&#39;d have to patch the stdlib, more specifically the `collections::vec` crate. Is there another way to change this code to compile successfully?



How do I implement a trait I don&#39;t own for a type I don&#39;t own?

I am using Laravel 5 and I am confused about where to place traits files in the Laravel 5 directory structure. Should they exist in public, resources or any other directory?

Where to place traits in Laravel 5?

I have a trait called `Sleep`:

```
pub trait Sleep {
    fn sleep(&amp;self);
}
```

I could provide a different implementation of sleep for every struct, but it turns out that most people sleep in a very small number of ways. You can sleep in a bed:

```
pub trait HasBed {
    fn sleep_in_bed(&amp;self);
    fn jump_on_bed(&amp;self);
}

impl Sleep for HasBed {
    fn sleep(&amp;self) {
        self.sleep_in_bed()
    }
}
```

If you&#39;re camping, you can sleep in a tent:

```
pub trait HasTent {
    fn sleep_in_tent(&amp;self);
    fn hide_in_tent(&amp;self);
}

impl Sleep for HasTent {
    fn sleep(&amp;self) {
        self.sleep_in_tent()
    }
}
```

There are some oddball cases. I have a friend that can sleep standing against a wall, but most people, most of the time, fall into some simple case.

We define some structs and let them sleep:

```
struct Jim;

impl HasBed for Jim {
    fn sleep_in_bed(&amp;self) {}
    fn jump_on_bed(&amp;self) {}
}

struct Jane;

impl HasTent for Jane {
    fn sleep_in_tent(&amp;self) {}
    fn hide_in_tent(&amp;self) {}
}

fn main() {
    use Sleep;
    let jim = Jim;
    jim.sleep();

    let jane = Jane;
    jane.sleep();
}
```

Uh-oh!  Compile error:

```none
error[E0599]: no method named `sleep` found for type `Jim` in the current scope
  --&gt; src/main.rs:44:9
   |
27 | struct Jim;
   | ----------- method `sleep` not found for this
...
44 |     jim.sleep();
   |         ^^^^^
   |
   = help: items from traits can only be used if the trait is implemented and in scope
   = note: the following trait defines an item `sleep`, perhaps you need to implement it:
           candidate #1: `Sleep`

error[E0599]: no method named `sleep` found for type `Jane` in the current scope
  --&gt; src/main.rs:47:10
   |
34 | struct Jane;
   | ------------ method `sleep` not found for this
...
47 |     jane.sleep();
   |          ^^^^^
   |
   = help: items from traits can only be used if the trait is implemented and in scope
   = note: the following trait defines an item `sleep`, perhaps you need to implement it:
           candidate #1: `Sleep`
```

This compiler error is strange because if there was something wrong with a trait implementing another trait, I expected to hear about it way back when I did that, not at the very bottom of the program when I try to use the result.

In this example, there are only 2 structs and 2 ways to sleep, but in the general case there are many structs and several ways to sleep (but not as many ways as there are structs).  

A `Bed` is mostly an implementation for `Sleep`, but in the general case a `Bed` has many uses and could implement many things.

The only immediately obvious approach is to convert `impl Sleep for...` into a macro that structs themselves use, but that seems hacky and terrible.


I implemented a trait for another trait but cannot call methods from both traits

I recently came across [Traits][1] in PHP and I&#39;m trying to understand them. During my research I stumbled upon this Stack Overflow question: [Traits vs. Interfaces][2]. The accepted answer mentions the following:

&gt; An interface defines a set of methods that the implementing class must
&gt; implement.
&gt; 
&gt; When a trait is use&#39;d the implementations of the methods come along
&gt; too--which doesn&#39;t happen in an Interface.

So far so good but this sounds exactly like the difference between an interface and an abstract class to me. So this raises a follow-up question for me:

 - What is the difference between a Trait and an Abstract Class in PHP?

I am aware that I can extend from only one abstract class and on the other hand use any amount of traits. But is this really the only difference? I still don&#39;t completely understand traits and its use.

  [1]: http://php.net/manual/en/language.oop5.traits.php
  [2]: https://stackoverflow.com/questions/9205083/traits-vs-interfaces

Difference between Trait and an Abstract Class in PHP

I have a trait with two associated functions:

    trait WithConstructor: Sized {
        fn new_with_param(param: usize) -&gt; Self;
    
        fn new() -&gt; Self {
            Self::new_with_param(0)
        }
    }

Why does the default implementation of the second method (`new()`) force me to put the `Sized` bound on the type? I think it&#39;s because of the stack pointer manipulation, but I&#39;m not sure.

If the compiler needs to know the size to allocate memory on the stack,
why does the following example not require `Sized` for `T`?  
  
    struct SimpleStruct&lt;T&gt; {
        field: T,
    }
    
    fn main() {
        let s = SimpleStruct { field: 0u32 };
    }


Why is the `Sized` bound necessary in this trait?

I wrote a program that has the trait `Animal` and the struct `Dog` implementing the trait. It also has a struct `AnimalHouse` storing an animal as a trait object `Box&lt;Animal&gt;`.

    
    trait Animal {
        fn speak(&amp;self);
    }
    
    struct Dog {
        name: String,
    }
    
    impl Dog {
        fn new(name: &amp;str) -&gt; Dog {
            return Dog {
                name: name.to_string(),
            };
        }
    }
    
    impl Animal for Dog {
        fn speak(&amp;self) {
            println!{&quot;{}: ruff, ruff!&quot;, self.name};
        }
    }
    
    struct AnimalHouse {
        animal: Box&lt;Animal&gt;,
    }
    
    fn main() {
        let house = AnimalHouse {
            animal: Box::new(Dog::new(&quot;Bobby&quot;)),
        };
        house.animal.speak();
    }

It returns &quot;Bobby: ruff, ruff!&quot; as expected, but if I try to clone `house` the compiler returns errors:

    fn main() {
        let house = AnimalHouse {
            animal: Box::new(Dog::new(&quot;Bobby&quot;)),
        };
        let house2 = house.clone();
        house2.animal.speak();
    }

&lt;!-- language: none --&gt;

    error[E0599]: no method named `clone` found for type `AnimalHouse` in the current scope
      --&gt; src/main.rs:31:24
       |
    23 | struct AnimalHouse {
       | ------------------ method `clone` not found for this
    ...
    31 |     let house2 = house.clone();
       |                        ^^^^^
       |
       = help: items from traits can only be used if the trait is implemented and in scope
       = note: the following trait defines an item `clone`, perhaps you need to implement it:
               candidate #1: `std::clone::Clone`

I tried to add `#[derive(Clone)]` before `struct AnimalHouse` and got another error:

&lt;!-- language: none --&gt;

    error[E0277]: the trait bound `Animal: std::clone::Clone` is not satisfied
      --&gt; src/main.rs:25:5
       |
    25 |     animal: Box&lt;Animal&gt;,
       |     ^^^^^^^^^^^^^^^^^^^ the trait `std::clone::Clone` is not implemented for `Animal`
       |
       = note: required because of the requirements on the impl of `std::clone::Clone` for `std::boxed::Box&lt;Animal&gt;`
       = note: required by `std::clone::Clone::clone`

How do I make the struct `AnimalHouse` cloneable? Is it idiomatic Rust to use a trait object actively, in general?

How to clone a struct storing a boxed trait object?

[Traits](https://doc.rust-lang.org/rust-by-example/trait.html) in Rust seem at least superficially similar to [typeclasses](http://en.wikipedia.org/wiki/Type_class) in Haskell, however I&#39;ve seen people write that there are some differences between them. I was wondering exactly what these differences are.

What is the difference between traits in Rust and typeclasses in Haskell?

What is the difference between Mixins and Traits?

&lt;a href=&quot;http://en.wikipedia.org/wiki/Trait_(abstract_type)&quot;&gt;According to Wikipedia&lt;/a&gt;, Ruby Modules are sort of like traits. How so?

Mixins vs. Traits

[Traits][1] have been one of the biggest additions for PHP 5.4. I know the syntax and understand the idea behind traits, like horizontal code re-use for common stuff like logging, security, caching etc.

However, I still don&#39;t know how I would make use of traits in my projects. 

Are there any open source projects that already use traits? Any good articles/reading material on how to structure architectures using traits?

  [1]: http://php.net/manual/en/language.oop5.traits.php

Traits in PHP – any real world examples/best practices?

Given a lambda, is it possible to figure out it&#39;s parameter type and return type? If yes, how?

Basically, I want `lambda_traits` which can be used in following ways:

    auto lambda = [](int i) { return long(i*10); };

    lambda_traits&lt;decltype(lambda)&gt;::param_type  i; //i should be int
    lambda_traits&lt;decltype(lambda)&gt;::return_type l; //l should be long

The motivation behind is that I want to use `lambda_traits` in a function template which accepts a lambda as argument, and I need to know it&#39;s parameter type and return type inside the function:

    template&lt;typename TLambda&gt;
    void f(TLambda lambda)
    {
       typedef typename lambda_traits&lt;TLambda&gt;::param_type  P;
       typedef typename lambda_traits&lt;TLambda&gt;::return_type R;
      
       std::function&lt;R(P)&gt; fun = lambda; //I want to do this!
       //...
    }

For the time being, we can assume that the lambda takes exactly one argument.

Initially, I tried to work with `std::function` as:

    template&lt;typename T&gt;
    A&lt;T&gt; f(std::function&lt;bool(T)&gt; fun)
    {
       return A&lt;T&gt;(fun);
    }

    f([](int){return true;}); //error

But it obviously would give error. So I changed it to `TLambda` version of the function template and want to construct the `std::function` object inside the function (as shown above).


Is it possible to figure out the parameter type and return type of a lambda?

Is it a safe practice to use **default methods as a poor&#39;s man version of traits** in Java 8?

[Some claim it may make pandas sad](http://zeroturnaround.com/rebellabs/how-your-addiction-to-java-8-default-methods-may-make-pandas-sad-and-your-teammates-angry/) if you use them just for the sake of it, because it&#39;s cool, but that&#39;s not my intention. It is also often reminded that default methods were introduced to support API evolution and backward compatibility, which is true, but this does not make it wrong or twisted to use them as traits per se.

I have [the following practical use case](http://www.opencredo.com/2015/01/30/traits-java-8-default-methods/) in mind:

    public interface Loggable {
        default Logger logger() {
            return LoggerFactory.getLogger(this.getClass());
        }
    }

Or perhaps, define a `PeriodTrait`:

    public interface PeriodeTrait {
        Date getStartDate();
        Date getEndDate();
        default isValid(Date atDate) {
            ...
        }
    }

Admitedly, composition could be used (or even helper classes) but it seems more verbose and cluttered and does not allow to benefit from polymorphism.

So, **is it ok/safe to use default methods as basic traits**, or should I be worried about unforeseen side effects?

[Several questions](https://stackoverflow.com/search?q=java+default+method+trait) on SO are related to Java vs Scala traits; that&#39;s not the point here. I&#39;m not asking merely for opinions either. Instead, I&#39;m looking for an authoritative answer or at least field insight: if you&#39;ve used default methods as traits on your corporate project, did it turn out to be a timebomb?

Java 8 default methods as traits : safe?

I was going through the [effective scala slides][1] and it mentions on slide 10 to never use `val` in a `trait` for abstract members and use `def` instead. The slide does not mention in detail why using abstract `val` in a `trait` is an anti-pattern. I would appreciate it if someone can explain best practice around using val vs def in a trait for abstract methods  


  [1]: http://www.slideshare.net/mircodotta/effective-scala

When to use val or def in Scala traits?

&gt; **Possible Duplicate:**  
&gt; [Scala traits vs abstract classes](https://stackoverflow.com/questions/1991042/scala-traits-vs-abstract-classes)  

&lt;!-- End of automatically inserted text --&gt;

What is the conceptual difference between abstract classes and traits?

Difference between Abstract Class and Trait

I want to use functionality of an existing `trait` and create my own `trait` on top of it only to later apply it on classes.

I want to extend `Laravel SoftDeletes` trait to make `SaveWithHistory` function, so it will create a copy of a record as a deleted record. I also want to extend it with `record_made_by_user_id` field.

Is there a way to extend a trait in PHP?

I&#39;m wondering why PHP Trait (PHP 5.4) cannot implement interfaces.

**Update from user1460043&#39;s answer =&gt; ...cannot require class which uses it to implement a specific interface** 

I understand that it could be obvious, because people could think that if a `Class A` is using a `Trait T` which is implementing an `interface I`, than the `Class A` should be implementing the `interface I` undirectly (and this is not true because `Class A` could rename trait methods).

In my case, my trait is calling methods from the interface that the class using the trait implements. 

The trait is in fact an implementation of some methods of the interface.
So, i want to &quot;design&quot; in the code that every class that want to use my trait have to implement the interface. That would allow the Trait to use class methods defined by the interface and be sure they are existing in the class.

Why PHP Trait can&#39;t implement interfaces?

How do I get `Box&lt;B&gt;` or `&amp;B` or `&amp;Box&lt;B&gt;` from the `a` variable in this code:
    
    trait A {}
    
    struct B;
    impl A for B {}
    
    fn main() {
        let mut a: Box&lt;dyn A&gt; = Box::new(B);
        let b = a as Box&lt;B&gt;;
    }


This code returns an error:

&lt;!-- language: none --&gt;

    error[E0605]: non-primitive cast: `std::boxed::Box&lt;dyn A&gt;` as `std::boxed::Box&lt;B&gt;`
     --&gt; src/main.rs:8:13
      |
    8 |     let b = a as Box&lt;B&gt;;
      |             ^^^^^^^^^^^
      |
      = note: an `as` expression can only be used to convert between primitive types. Consider using the `From` trait



How to get a reference to a concrete type from a trait object?

Scenario:

    trait A {
        function calc($v) {
            return $v+1;
        }
    }
    
    class MyClass {
        use A;
        
        function calc($v) {
            $v++;
            return A::calc($v);
        }
    }
    
    print (new MyClass())-&gt;calc(2); // should print 4

This code doesn&#39;t work, and I cannot find a way to call a trait function like it was inherited. I tried calling `self::calc($v)`, `static::calc($v)`, `parent::calc($v)`, `A::calc($v)` and the following:

    trait A {
        function calc($v) {
            return $v+1;
        }
    }
    
    class MyClass {
        use A {
            calc as traitcalc;
        }
        
        function calc($v) {
            $v++;
            return traitcalc($v);
        }
    }

Nothing works.  

Is there a way to make it work or must I override completely the trait function which is much more complex than this :)

How to override trait function and call it from the overridden function?

I have a trait `Foo`

    pub trait Foo {
       fn do_something(&amp;self) -&gt; f64;
    }

and a struct which references that trait

    pub struct Bar {
       foo: Foo,
    }

Trying to compile I get

&lt;!-- language: none --&gt;

    error: reference to trait `Foo` where a type is expected; try `Box&lt;Foo&gt;` or `&amp;Foo`

Changing the struct to

    struct Bar {
       foo: &amp;Foo,
    }

Tells me `error: missing lifetime specifier`

Changing the definition to

    struct Bar {
       foo: Box&lt;Foo&gt;,
    }

Compiles — yay!

However, when I want a function to return `foo` on `bar` - something like:

    impl Bar {
    	fn get_foo(&amp;self) -&gt; Foo {
    		self.foo
    	}
    }

Well obviously `bar.foo` is a `Box&lt;Foo&gt;`, so expectedly I get ``error: reference to trait `Foo` where a type is expected; try `Box&lt;Foo&gt;` or `&amp;Foo` ``

Changing the signature to

    impl Bar {
    	fn get_foo(&amp;self) -&gt; Box&lt;Foo&gt; {
    		let this = *self;
    		this.foo
    	}
    }

But now I get ``error: cannot move out of dereference of `&amp;`-pointer`` on trying to dereference `self`.

Changing to

    impl Bar {
    	fn get_foo(self) -&gt; Box&lt;Foo&gt; {
    		self.foo
    	}
    }

Is all good.

So....

 1. Why doesn&#39;t `&amp;` in the `bar` struct work? I&#39;m assuming I have to box
    as structs have a set memory layout so we have to say it&#39;s a pointer
    to a trait (as we can&#39;t know how big that will be), but why does the
    compiler suggest something that wont compile?
 2. Why can&#39;t I dereference `self` in `get_foo()` - All examples I&#39;ve seen use the borrowed `self` syntax?
 3. What&#39;s the implication of removing the `&amp;` and just using `self`?

Learning Rust is fascinating, but the memory safety is both fascinating and intimidating!

Code in full that compiles:
    
    trait Foo {
        fn do_something(&amp;self) -&gt; f64;
    }
    
    struct Bar {
        foo: Box&lt;Foo&gt;,
    }
    
    impl Bar {
        fn get_foo(self) -&gt; Box&lt;Foo&gt; {
            let foo = self.foo;
            foo.do_something();
            foo
        }
    }
    
    fn main() {}

References to traits in structs

Can someone please explain traits in Scala? What are the advantages of traits over extending an abstract class?

What are the pros of using traits over abstract classes?

A self-type for a trait `A`:

    trait B
    trait A { this: B =&gt; }
 
says that *&quot;`A` cannot be mixed into a concrete class that does not also extend `B`&quot;*.

On the other hand, the following:

    trait B
    trait A extends B

says that *&quot;any (concrete or abstract) class mixing in `A` will also be mixing in B&quot;*.

Don&#39;t these two statements mean the same thing? The self-type seems to serve only to create the possibility of a simple compile-time error.

What am I missing?

What is the difference between self-types and trait subclasses?

What is the advantage of using an abstract class instead of a trait (apart from performance)? It seems like abstract classes can be replaced by traits in most cases.

What is the advantage of using abstract classes instead of traits?

I made a two element `Vector` struct and I want to overload the `+` operator.

I made all my functions and methods take references, rather than values, and I want the `+` operator to work the same way.

    impl Add for Vector {
        fn add(&amp;self, other: &amp;Vector) -&gt; Vector {
            Vector {
                x: self.x + other.x,
                y: self.y + other.y,
            }
        }
    }

Depending on which variation I try, I either get lifetime problems or type mismatches. Specifically, the `&amp;self` argument seems to not get treated as the right type.

I have seen examples with template arguments on `impl` as well as `Add`, but they just result in different errors.

I found https://stackoverflow.com/questions/24594374/overload-operators-with-different-rhs-type but the code in the answer doesn&#39;t work even if I put a `use std::ops::Mul;` at the top.

I am using rustc 1.0.0-nightly (ed530d7a3 2015-01-16 22:41:16 +0000)

I won&#39;t accept &quot;you only have two fields, why use a reference&quot; as an answer; what if I wanted a 100 element struct? I will accept an answer that demonstrates that even with a large struct I should be passing by value, if that is the case (I don&#39;t think it is, though.) I am interested in knowing a good rule of thumb for struct size and passing by value vs struct, but that is not the current question.

How do I implement the Add trait for a reference to a struct?

Recent Rust changes have made &quot;trait objects&quot; more prominent to me, but I only have a nebulous grasp of what actually makes something into a trait object. One change in particular is the [upcoming change](https://github.com/rust-lang/rust/issues/19187) to allow trait objects to forward trait implementations to the inner type.

Given a trait `Foo`, I&#39;m pretty sure that `Box&lt;Foo&gt;` / `Box&lt;dyn Foo&gt;` is a trait object. Is `&amp;Foo` / `&amp;dyn Foo` also a trait object? What about other smart-pointer things like `Rc` or `Arc`? How could I make my own type that would count as a trait object?

The [reference](https://doc.rust-lang.org/0.12.0/reference.html) only mentions trait objects once, but nothing like a definition.

What makes something a &quot;trait object&quot;?

I&#39;ve been trying to study up on PHP lately, and I find myself getting hung up on traits. I understand the concept of horizontal code reuse and not wanting to necessarily inherit from an abstract class. What I don&#39;t understand is: What is the crucial difference between using traits versus interfaces?

I&#39;ve tried searching for a decent blog post or article explaining when to use one or the other, but the examples I&#39;ve found so far seem so similar as to be identical.




Traits vs. interfaces

In PHP 5, I can to overload constructors (and any others methods). But if I get some code like this:

    class Base {
        
        public function __construct($a, $b) {
            echo $a+$b;
        }
    
    
        public function sayHello() {
            echo &#39;Hello &#39;;
        }
    }
    
    
    trait SayWorld {
    
        public function __construct($a, $b, $c = 0) {
            echo (int)$c * ($a+$b);
        }
    
        public function sayHello($a = null) {
            parent::sayHello();
            echo &#39;World!&#39;.$a;
        }
    }
    
    class MyHelloWorld extends Base {
        use SayWorld;
    }
    
    $o = new MyHelloWorld(2, 3);
    $o-&gt;sayHello(1);

I have an error:

&gt; Fatal error:  MyHelloWorld has colliding constructor definitions coming from traits 

How can I to fix it? You can test my code [here][1].


  [1]: http://sandbox.onlinephpfunctions.com/code/2c61c8c1a0a829283d8f6afaecfaa08228c169cc

How to overload class constructor within traits in PHP &gt;= 5.4

What is the best way to define constants that may be used by a number of classes within a namespace? I&#39;m trying to avoid too much inheritance, so extending base classes is not an ideal solution, and I&#39;m struggling to find a good solution using traits. Is this in any way possible in PHP 5.4 or should a different approach be taken?

I have the following situation:

    trait Base
    {
        // Generic functions
    }

    class A 
    {
        use Base;
    }

    class B 
    {
        use Base;
    }

The problem is that it is not possible to define constants in PHP traits. Ideally, I would want something like the following:

    trait Base
    {
        const SOME_CONST = &#39;someconst&#39;;
        const SOME_OTHER_CONST = &#39;someotherconst&#39;;

        // Generic functions
    }

Then these could be accessed though the class that applies the trait:

    echo A::SOME_CONST;
    echo B::SOME_OTHER_CONST;

But due to the limitations of traits this isn&#39;t possible. Any ideas?


PHP traits - defining generic constants

Sealed classes are described in &#39;Programming in Scala&#39;, but sealed traits are not.
Where can I find more information about a sealed trait?

I would like to know, if a sealed trait is the same as a sealed class?
Or, if not, what are the differences? 
When is it a good idea to use a sealed trait (and when not)?

What is a sealed trait?

I&#39;m reading Scott Meyers&#39; [*Effective C++*](https://rads.stackoverflow.com/amzn/click/0321334876). He is talking about traits classes, I understood that I need them to determine the type of the object during compilation time, but I can&#39;t understand his explanation about what these classes actually do? (from technical point of view)

How do traits classes work and what do they do?

I have a base abstract class (trait). It has an abstract method `foo()`. It is extended and implemented by several derived classes. I want to create a trait that can be mixed into the derived classes so that it implements `foo()` and then calls the derived class&#39;s `foo()`.

Something like:

    trait Foo {
      def foo()
    }

    trait M extends Foo {
      override def foo() {
        println(&quot;M&quot;)
        super.foo()
      }
    }

    class FooImpl1 extends Foo {
      override def foo() {
        println(&quot;Impl&quot;)
      }
    }

    class FooImpl2 extends FooImpl1 with M 

I tried self types and structural types, but I can&#39;t get it to work.


Traits and abstract methods override in Scala

*Quick note: Examples from the tutorial &lt;em&gt;[Scala for Java Refugees Part 5: Traits and Types][1]&lt;/em&gt;.*

Suppose I have the traits Student, Worker, Underpaid, and Young.

How could I declare a class (**not instance**), CollegeStudent, with all these traits?

*Note:* I am aware of the simplests cases, such as CollegeStudent with one or two Traits:

    class CollegeStudent extends Student with Worker

  [1]: https://web.archive.org/web/20170423024917/http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-5


Mixing multiple traits in Scala

I am trying to initialise an array of structs in Rust:

    enum Direction {
        North,
        East,
        South,
        West,
    }

    struct RoadPoint {
        direction: Direction,
        index: i32,
    }

    // Initialise the array, but failed.
    let data = [RoadPoint { direction: Direction::East, index: 1 }; 4]; 

When I try to compile, the compiler complains that the `Copy` trait is not implemented:

&lt;!-- language: none --&gt;

    error[E0277]: the trait bound `main::RoadPoint: std::marker::Copy` is not satisfied
      --&gt; src/main.rs:15:16
       |
    15 |     let data = [RoadPoint { direction: Direction::East, index: 1 }; 4]; 
       |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Copy` is not implemented for `main::RoadPoint`
       |
       = note: the `Copy` trait is required because the repeated element will be copied

How can the `Copy` trait be implemented?

How can I implement Rust&#39;s Copy trait?

In Rust, the main tool for abstraction are *traits*. In C++, there are two tools for abstractions: abstract classes and templates. To get rid of some of the disadvantages of using templates (e.g. hard to read error messages), C++ introduced *concepts* which are [&quot;named sets of requirements&quot;](https://en.cppreference.com/w/cpp/language/constraints). 

Both features *seem* to be fairly similar: 

- Defining a trait/concept is done by listing requirements. 
- Both can be used to bound/restrict generic/template type parameters.
- Rust traits and C++ templates with concepts are both monomorphized (I know Rust traits can also be used with dynamic dispatch, but that&#39;s a different story). 

But from what I understand, there are also notable differences. For example, C++&#39;s concepts seem to define a set of expressions that have to be valid instead of listing function signatures. But there is a lot of different and confusing information out there (maybe because concepts only land in C++20?). That&#39;s why I&#39;d like to know: **what exactly are the differences between and the similarities of C++&#39;s concepts and Rust&#39;s traits?**

Are there features that are only offered by either concepts or traits? E.g. what about Rust&#39;s associated types and consts? Or bounding a type by multiple traits/concepts? 

What are the similarities and differences between C++&#39;s concepts and Rust&#39;s traits?

I know the feature doesn&#39;t exist in C#, but PHP recently added a feature called [Traits](http://php.net/manual/en/language.oop5.traits.php) which I thought was a bit silly at first until I started thinking about it.

Say I have a base class called `Client`. `Client` has a single property called `Name`.

Now I&#39;m developing a re-usable application that will be used by many different customers. All customers agree that a client should have a name, hence it being in the base-class.

Now Customer A comes along and says he also need to track the client&#39;s Weight. Customer B doesn&#39;t need the Weight, but he wants to track Height. Customer C wants to track both Weight and Height.

With traits, we could make the both the Weight and the Height features traits:

    class ClientA extends Client use TClientWeight
    class ClientB extends Client use TClientHeight
    class ClientC extends Client use TClientWeight, TClientHeight

Now I can meet all my customers&#39; needs without adding any extra fluff to the class. If my customer comes back later and says &quot;Oh, I really like that feature, can I have it too?&quot;, I just update the class definition to include the extra trait.

How would you accomplish this in C#?

Interfaces don&#39;t work here because I want concrete definitions for the properties and any associated methods, and I don&#39;t want to re-implement them for each version of the class.

(By &quot;customer&quot;, I mean a literal person who has employed me as a developer, whereas by &quot;client&quot; I&#39;m referring a programming class; each of my customers has clients that they want to record information about)



How would you implement a &quot;trait&quot; design-pattern in C#?

I want to know if there is a solution on how to unit-test a PHP trait.

I know we can test a class which is using the trait, but I was wondering if there are better approaches.

Thanks for any advice in advance :) 

**EDIT**

One alternative is to use the Trait in the test class itself as I&#39;m going to demonstrate bellow.

**But** I&#39;m not that keen on this approach since there is no guaranty there are no similar method names between the trait, the class and also the `PHPUnit_Framework_TestCase` (in this example):

Here is an example trait:

    trait IndexableTrait
    {
        /** @var int */
        private $index;

        /**
         * @param $index
         * @return $this
         * @throw \InvalidArgumentException
         */
        public function setIndex($index)
        {
            if (false === filter_var($index, FILTER_VALIDATE_INT)) {
                throw new \InvalidArgumentException(&#39;$index must be integer.&#39;);
            }

            $this-&gt;index = $index;

            return $this;
        }

        /**
         * @return int|null
         */
        public function getIndex()
        {
            return $this-&gt;index;
        }
    }

and its test:

    class TheAboveTraitTest extends \PHPUnit_Framework_TestCase
    {
        use TheAboveTrait;

        public function test_indexSetterAndGetter()
        {
            $this-&gt;setIndex(123);
            $this-&gt;assertEquals(123, $this-&gt;getIndex());
        }

        public function test_indexIntValidation()
        {
            $this-&gt;setExpectedException(\Exception::class, &#39;$index must be integer.&#39;);
            $this-&gt;setIndex(&#39;bad index&#39;);
        }
    }

How to unit test PHP traits

Is it at all possible to define functions inside of traits as having `impl Trait` return types?  I want to create a trait that can be implemented by multiple structs so that the `new()` functions of all of them returns an object that they can all be used in the same way without having to write code specific to each one.

```
trait A {
    fn new() -&gt; impl A;
}
```

However, I get the following error:

```none
error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
 --&gt; src/lib.rs:2:17
  |
2 |     fn new() -&gt; impl A;
  |                 ^^^^^^
```

Is this a limitation of the current implementation of `impl Trait` or am I using it wrong?

Is it possible to use `impl Trait` as a function&#39;s return type in a trait definition?

I see that traits in Scala are similar to interfaces in Java (but interfaces in Java extend other interfaces, they don&#39;t extend a class). I saw [an example on SO about traits usage][1] where a trait extends a class.

What is the purpose of this? Why can traits extend classes?


  [1]: https://stackoverflow.com/questions/1229743/scala-traits-usage

All Traits Solutions on Gang of Coders

Total of 37 Traits Solutions