PHP Documentation about conflicts: If two Traits insert a method with the same name, a fatal error is produced, if the conflict is not explicitly resolved. To resolve naming conflicts between Traits used in the same class, the insteadof operator needs to be used to chose exactly one of the conflicting methods. Since this only … Read more
I agree, they all seem to allow reusing multiple “classes” of behaviour. There are differences, though, and understanding these will probably aid your decision. Before providing a brief summary/highlight of each feature and examples of suitable usage, let’s just summarize on the conclusion of each. Conclusion / typical usage: @Delegate: Used to add all the … Read more
Traits allow you to share code between your classes without forcing you into a specific class hierarchy. Say you want all your classes to have the convenient utility method foo($bar); without traits you have two choices: implement it individually with code redundancy in each class inherit from a common (abstract) ancestor class Both solution aren’t … Read more
You need to implement the second trait for objects that implement the first trait: impl<T> Sleep for T where T: HasBed, { fn sleep(&self) { self.sleep_in_bed() } } Previously, you were implementing Sleep for the trait’s type, better expressed as dyn HasBed. See What does “dyn” mean in a type? for more details. However, this … Read more
Yes they can, a trait that extends a class puts a restriction on what classes can extend that trait – namely, all classes that mix-in that trait must extend that class. scala> class Foo defined class Foo scala> trait FooTrait extends Foo defined trait FooTrait scala> val good = new Foo with FooTrait good: Foo … Read more
Disclaimer: I have not yet used concepts, all I know about them was gleaned from the various proposals and cppreference, so take this answer with a grain of salt. Run-Time Polymorphism Rust Traits are used both for Compile-Time Polymorphism and, sometimes, Run-Time Polymorphism; Concepts are only about Compile-Time Polymorphism. Structural vs Nominal. The greatest difference … Read more
You can get the syntax by using marker interfaces and extension methods. Prerequisite: the interfaces need to define the contract which is later used by the extension method. Basically the interface defines the contract for being able to “implement” a trait; ideally the class where you add the interface should already have all members of … Read more
There are a few problems. The first is that there’s nothing to require that an Animal also implements Clone. You could fix this by changing the trait definition: trait Animal: Clone { /* … */ } This would cause Animal to no longer be object safe, meaning that Box<dyn Animal> will become invalid, so that’s … Read more
You can test a Trait using a similar to testing an Abstract Class’ concrete methods. PHPUnit has a method getMockForTrait which will return an object that uses the trait. Then you can test the traits functions. Here is the example from the documentation: <?php trait AbstractTrait { public function concreteMethod() { return $this->abstractMethod(); } public … Read more
You were very close. Add the abstract modifier to M.foo, and you have the ‘Stackable Trait’ pattern: http://www.artima.com/scalazine/articles/stackable_trait_pattern.html trait Foo { def foo() } trait M extends Foo { abstract override def foo() {println(“M”); super.foo()} } class FooImpl1 extends Foo { override def foo() {println(“Impl”)} } class FooImpl2 extends FooImpl1 with M