c# barcode generator library open source TRAITS AND TYPES AND GNARLY STUFF FOR ARCHITECTS in Font

Creator Data Matrix in Font TRAITS AND TYPES AND GNARLY STUFF FOR ARCHITECTS

Only instances of classes that extend Baz, Blarg, and FruitBat may be passed into this method. Let s go model some living things.

abstract abstract abstract abstract class class class class LivingThing Plant extends LivingThing Fungus extends LivingThing Animal extends LivingThing

Good so far. A LivingThing must be a plant, fungus, or animal. But, what about legs Who can have legs

trait HasLegs extends Animal { def walk() {println("Walking")} }

The HasLegs trait extends Animal. But Animal is a class, so what does it mean for a trait to extend a class It means that the compiler will only let you mix HasLegs into something which subclasses from Animal. Thus, we ve defined that only animals have legs, but any type of animal can have legs. It s the same for HasWings:

trait HasWings extends Animal { def flap() {println("Flap Flap")} }

But, only things with wings can fly. This is a different notation. We define the rules of the self type with this: HasWings =>. The compiler will flag an error if this trait is not mixed into a class that also extends HasWings. So, we can use self types to define the rules for what classes a given trait can be mixed into.8

trait Flies { this: HasWings => def fly() {println("I'm flying")} }

And Birds have wings and legs:

Let s define a couple of different Birds:

8. Self types can also be used to discover at compile time what class a trait has been mixed into. See http://www.scala-lang.org/node/124.

All mammals have a bodyTemperature:

abstract class Mammal extends Animal { def bodyTemperature: Double }

Some animals know their name, and if they do, we can ask their name:

trait KnowsName extends Animal { def name: String }

So, a Dog is a Mammal that has legs and knows its name:

class Dog(val name: String) extends Mammal with HasLegs with KnowsName { def bodyTemperature: Double = 99.3 }

Some animals, cats, and children come to mind who know their own name but will sometimes ignore their name:

trait IgnoresName { this: KnowsName => def ignoreName(when: String): Boolean def currentName(when: String): Option[String] = if (ignoreName(when)) None else Some(name) }

Now we can define a Cat class that has legs, knows its name, and ignores its name except at dinner time:

class Cat(val name: String) extends Mammal with HasLegs with KnowsName with IgnoresName { def ignoreName(when: String) = when match { case "Dinner" => false case _ => true } def bodyTemperature: Double = 99.5 }

Some Animals can be Athletes, and Runners are Athletes with legs:

trait Athlete extends Animal trait Runner { this: Athlete with HasLegs => def run() {println("I'm running")}

A Person is a Mammal with legs and knows its name:

class Person(val name: String) extends Mammal with HasLegs with KnowsName { def bodyTemperature: Double = 98.6 }

A Biker is a Person but may only be added to an Athlete:

trait Biker extends Person { this: Athlete=> def ride() {println("I'm riding my bike")} }

And finally, let s define some Genders:

We ve defined a complex hierarchy of classes and traits. Let s see what we can do with these classes. First, let s try to create a Dog that s also a Biker:

<console>:4: error: illegal inheritance; superclass Dog is not a subclass of the superclass Person of the mixin trait Biker val bikerDog = new Dog("biker") with Athlete with Biker

Cool, the compiler enforced our rule about Bikers needing to be Persons. Let s create some valid LivingThings. Please note that we can compose together different traits as part of the object creation. So, archer is an instance of a class that is a subclass of Dog that implements Athlete, Runner, and Male. The Scala compiler automatically creates this new, anonymous class for you.