1 programming in scala – mixin inheritance summer 2008
TRANSCRIPT
![Page 1: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/1.jpg)
1
Programming in Scala – Mixin inheritance Summer 2008
![Page 2: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/2.jpg)
The very short history of multiple inheritance
• C++ had multiple inheritance
• Java removed it• Mostly due to diamond-
inheritance problem.
• Should alice behave like Women are defined to behave, or like Directors are defined to behave?
2
Person
DirectorWoman
alice
«instanceOf»«instanceOf»
![Page 3: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/3.jpg)
Mixin-based inheritance
• Scala allows mixin-type inheritance to be used as a mean to improve reusability and modularization
• Contents of this talk:
1. Introduction
2. Sparse interfaces versus rich interfaces
3. Stackable modifications via traits
4. Improving modularization of JSF beans
• Themes 1-3 are rephrased from the chapter 12 of ’Programming in Scala’
3
![Page 4: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/4.jpg)
Theme 1: Introduction
• Inheritance between two classes can be defined as
R = P ΔR⊕where
R is the newly defined subclass,
P denotes the properties inherited from an existing class,
ΔR denotes the incrementally added new properties that differentate R from P and
⊕ stands for operation of combining P and ΔR
4
![Page 5: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/5.jpg)
Traditional (single-)inheritance
• Traditional inheritance defines classes as
Class P is
[..properties..]
Endclass
Class R inherits P and
[.. modifies P by ΔR .. ]
Endclass
5
![Page 6: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/6.jpg)
Mixin-inheritance
• In mixin-inheritance, the ΔR part is written into its own mixin-class, as:
Class P is
[… properties … ]
Endclass
Class Rmixin is
[… modifications (ΔR) …]
Endclass
Class R inherits P, Rmixin.
6
![Page 7: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/7.jpg)
Properties of mixins
• One never instantiates a mixin; but a mixin is combined with a concrete class
• Many mixins can be combined with a concrete class at a time
• The order of the mixins gives a resolution to the diamond-inheritance problem
• Both abstract methods and concrete methods can be contained in a mixin-class– This is different than in Java, which allows
multiple inheritance via interfaces only
7
![Page 8: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/8.jpg)
Scala-examples
• Defining a mixin-class Philosophical:
trait Philosophical {
def philosophize() {
println("I consume memory, therefore I am!”)
}
}• The trait does not declare a superclass, so similar to
classes, it has the default superclass of AnyRef.• It defines one method, named philosophize, which is
concrete.
8
![Page 9: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/9.jpg)
Defining a philosophical frog
abstract class Animal {
def color: String
override def toString = ”a ” + color + ” animal.”
}
class Frog extends Animal with Philosophical {
def color = "green"
}• We’ve defined three methods for class Frog:
color(), toString() and philosophize()
9
![Page 10: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/10.jpg)
Traits are more than interfaces with implementations
• Traits do about all the same than classes, e.g.– Traits can declare fields and contain state– Traits can be defined in inheritance hierarchies– Traits can be declared abstract
• There are two cases in which trait classes differ from regular classes:
1. It is not possible to define class parameters for traits – it is the class, which defines how it is constructed
2.The ’super’-calls are dynamically bound when the trait is mixed with a class
10
![Page 11: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/11.jpg)
Theme 2: Sparse and Rich interfaces
• Sparse interfaces define just a few functions, which need to be implemented in the implementing class
• A tradeoff between caller convenience and implementor convenience– In a rich interface, it is more work to implement
all of the required methods• The Java API favours sparse interfaces, due to
single-inheritance• Traits allow to reduce the tradeoff’s effect
11
![Page 12: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/12.jpg)
Example: a rectangle
• Rectangles are used in graphical user interfaces in various contexts:– Windows have a rectangular bounding box– Bitmap images are rectangular– Regions selected with a mouse are rectangular
• We could implement the rectangulariness in the base class of all rectangular things– But then, other aspects of these things would be
missing– A.k.a tyranny of dominant decomposition
12
![Page 13: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/13.jpg)
An enrichment trait - Rectangular
class Point
trait Rectangular {
def topLeft: Point
def bottomRight: Point
def left = topLeft.x
def right = bottomRight.x
def width = right - left
def height = bottomRight.y – topLeft.y;
// and many more geometric methods...
} 13
![Page 14: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/14.jpg)
A selection event (hypothetical)
class SelectionEvent(val topLeft: Point,
val bottomRight: Point)
extends MouseEvent
with Rectangular
{
// structure from MouseEvent is
// mixed with Rectangular’s methods and
// attributes
}
14
![Page 15: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/15.jpg)
A bitmap image (hypothetical)
class Bitmap(val topLeft: Point, val bottomRight: Point) extends Rectangular {
// It is also possible to directly to extend a trait class
def setImage(img: Array[int]) = {
if(img.length != width * length) {
throw new IllegalArgumentException(”!!”);
}
}
15
![Page 16: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/16.jpg)
Another trait-example: rational numbers
class Rational(val numerator: Int, val denominator: Int) {
// ...
def < (that: Rational) =
this.numerator * that.denominator >
that.numerator * this.denominator
def > (that: Rational) = that < this
def <= (that: Rational) = (this < that) || (this == that)
def >= (that: Rational) = (this > that) || (this == that)
}
16
![Page 17: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/17.jpg)
The ordered trait
• Rational’s rich interface is cumbersome to write, as it would be duplicated in similar classes
• While the order can be defined with a single function, ”compare”, it is inconvenient to need to write
object1 compare object2 <= 0
when actually meaning to say
object1 <= object2.• Ordering of objects is another area where rich
interfaces can be useful
17
![Page 18: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/18.jpg)
Ordered.scala
trait Ordered[A] {
def compare(that: A): Int
def < (that: A): Boolean = (this compare that) < 0
def > (that: A): Boolean = (this compare that) > 0
def <= (that: A): Boolean = (this compare that) <= 0
def >= (that: A): Boolean = (this compare that) >= 0
def compareTo(that: A): Int = compare(that)
}
18
![Page 19: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/19.jpg)
MixinRational.scala
class MixinRational(val numer: Int, val denom: Int)
extends Ordered[MixinRational] {
// ...
def compare(that: MixinRational) =
(this.numer * that.denom) -
(that.numer * this.denom)
// todo: define equals, hashcode
}
19
![Page 20: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/20.jpg)
Theme 3: Stackable modifications
• Due to a trait’s super-calls being bound dynamically, multiple traits can be stacked
• Let’s think about a Queue, where you can put values into and get values from:
abstract class IntQueue {
def get(): Int
def put(x: Int)
}
20
![Page 21: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/21.jpg)
BasicIntQueue.scala
import scala.collection.mutable.ArrayBuffer
class BasicIntQueue extends IntQueue {
private val buf = new ArrayBuffer[Int]
def get() = buf.remove(0)
def put(x: Int) { buf += x }
}
21
![Page 22: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/22.jpg)
Defining three behaviour modifying traits
1. Doubling: – double all integers that are put in the queue
2. Incrementing: – increment all integers that are put in the queue
3. Filtering: – filter out negative integers from a queue
22
![Page 23: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/23.jpg)
Doubling.scala
trait Doubling extends IntQueue {
abstract override def put(x: Int) { super.put(2 * x) }
}
• abstract override is not possible for regular classes• For traits, it means that this trait can only be mixed
in with a class that already has the corresponding method concretely defined
• Usage: – class MyQueue extends BasicIntQueue with
Doubling
23
![Page 24: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/24.jpg)
Incrementing.scala, Filtering.scala
trait Incrementing extends IntQueue {
abstract override def put(x: Int) { super.put(x + 1) }
}
trait Filtering extends IntQueue {
abstract override def put(x: Int) {
if (x >= 0) super.put(x)
}
}
24
![Page 25: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/25.jpg)
Ordering of mixins is significant
• Basically, the list of mixin-modifications is traversed from right to left
• Each new mixin is put ”on stack” of the previous ones
• new BasicIntQueue with Incrementing with Doubling– First double, then increment
• new BasicInQueue with Doubling with Incrementing– First increment, then double
25
![Page 26: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/26.jpg)
Theme 4: JSF-example
• Java Server Faces, JSF, is a JSR-127, thus a ’standard’ way of constructing web applications in Java
• Facelets are a common technique for defining reuseable layouts in XML
• User interface state is contained in Managed beans, whose getters and setters follow the JavaBeans conventions
26
![Page 27: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/27.jpg)
JSF data table
• Two components: a data table and a scroller
• Data table’s state – List of cars– First row number
• Scroller’s state– Number of pages– Current page
27
![Page 28: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/28.jpg)
Car listing’s backing bean
• A managed bean in Java, which contains accessors for both the data table and the scroller’s state
class CarListingManagedBean {
private int startingRow;
private Object carListing; // an array or an iterator
private int currentPage;
private int pageCount;
public void setStartingRow(int i) { … }
public int getStartingRow() { …. }
…..
}28
![Page 29: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/29.jpg)
Single-point of non-modularization
• While the facelet UI pages can be modularized to a reasonable degree, the managed bean part tends to become a mold of all corresponding state variables
• E.g. both the data table’s and scroller’s variables are contained in the one UI bean class
• When reusing the same UI components, the state variables and accessors are duplicated to multiple managed beans
29
![Page 30: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/30.jpg)
Traits to the rescue
• With traits, we can isolate each of the UI component’s state variables into their own modules
• For a given UI page’s backing bean, mix in the corresponding traits
• E.g.
30
trait DataTableBacker {
var startingRow: int;
var listing: Object;
}
trait DataScrollerBacker {
var currentPage: int;
var lastPage: int;
}
![Page 31: 1 Programming in Scala – Mixin inheritance Summer 2008](https://reader035.vdocument.in/reader035/viewer/2022062308/56649f0b5503460f94c1e7e0/html5/thumbnails/31.jpg)
References
• [Bracha & Cook 1990]: Mixin-based inheritance• [Taivalsaari 1996]: On the notion of inheritance
31