Structural Types: Multiple Methods and Type Aliasing

There are two more aspects related to structural typing that are useful to look at. Structural types with multiple methods and type aliases.

For background on this topic also look at:

• Introducing Structual Types
• Dynamic Calls Using Structural Types

Structural Types are not limited to defining a single method. In that regard they are very similar to interfaces without the binary incompatibility issues. However do not be fooled into thinking they are the same thing. For one reason reflection is used so performance can be an issue in certain cases and also interfaces/traits have semantics that structural types do not.

1. /*
2. Defining a types that has both a length and charAt method.  
4. Just a warning.  If you leave off the () after length this will not work.  This is not a bug.  Martin kindly left a comment on why it is not.
5. */
6. scala> def foreach(t : {def length():Int; def charAt(i:Int):Char}, f : Char => Unit) = {
7.      | 0 until t.length foreach {i => f(t.charAt(i))}  
8.      | }
9. foreach: (t: AnyRef{def length(): Int; def charAt(i: Int): Char},f: (Char) => Unit)Unit
11. // A string matches the structural type
12. scala> foreach ("hello", println _)
13. h
14. e
15. l
16. l
17. o

Pretty unexpected I would say. A feature of Scala which complements Structural types are type aliases. They are useful in many situations and one is with use with Structural Types:

1. /*
2. With type aliasing you can assign a structural type a name
3. */
4. scala> type IChar = {def length():Int
5.      |               def charAt(i:Int):Char}
6. defined type alias IChar
8. scala> def print( t : IChar) = 0 until t.length() foreach {i => println(t.charAt(i))}
9. print: (t: IChar)Unit
11. scala> print("gurk")
12. g
13. u
14. r
15. k

Type aliasing and implicit conversions in harmony

This topic combines advanced two topics. types and implicit methods. This topic is not really intended to be instructional as much as a illustration of the cool stuff you can do with the language. As always becareful not to cut yourself :-)

In keeping with the uniform principle of Scala, types can defined as variables. This is useful for several reasons but this topic covers a cool/fun effect of having types be declared like variables. Type Aliasing. In the example below an alias | is created for the Either class. This allows the | to be used in place of Either.

1. // Start of example 1.  creating the type alias
2. // define the | type
3. scala> type |[A,B] = Either[A,B]
4. defined type alias $bar
6. // If a Type has 2 parameters it can be used in operator form
7. scala> Array[Int | Long](Left(5),Right(12L))
8. res0: Array[|[Int,Long]] = Array(Left(5), Right(12))
10. // start of example 2.  Simplify creation of an Array (or other collection) of either
11. scala> implicit def makeLeft[A,B](a:A):Either[A,B] = Left(a)
12. makeLeft: [A,B](a: A)Either[A,B]
14. scala> implicit def makeRight[A,B](b:B):Either[A,B] = Right(b) 
15. makeRight: [A,B](b: B)Either[A,B]
17. // Since there are implicits to convert to Right and Left the values in the Array will be wrapped
18. // automatically.  Makes the syntax MUCH cleaner and easier to read.
19. scala> Array[Int|String](5,"Wurst",123,2,6)
20. res1: Array[|[Int,String]] = Array(Left(5), Right(Wurst), Left(123), Left(2), Left(6))