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

Dynamic calls using Structural Types

Using reflection can be a real pain in Java since the API is a Java API and consists of many gets and searches through collections not to mention so many exceptions that need to be handled. In Scala there is a wonderful way to clean up a reflective call down to a single line (assuming you don't want to worry about handling exceptions.) Here structural typing can really be a pleasure.

1. // I am assigning a string to an Any reference
2. scala> val s:Any = "hello :D"
3. s: Any = hello :D
5. // Any does not have a length method
6. scala> s.length
7. < console>:6: error: value length is not a member of Any
8.        s.length
9.          ^
11. /*
12. But I can cast it to a structural type with a length method
13. */
14. scala> s.asInstanceOf[{def length:Int}].length
15. res2: Int = 8

There are restrictions to this. For example implicits will not work:

1. /*
2. The method r is part of StringLike (or RichString in Scala 2.7) 
3. and there is an implicit conversion from String to RichString/StringLike.
4. The structural type does not try to apply the implicits because implicits are a
5. compile time artifact and that information is not kept at run time.  Perhaps this
6. will be added in the future but it is not present now.
7. */
8. scala> s.asInstanceOf[{def r:util.matching.Regex}].r
9. java.lang.NoSuchMethodException: java.lang.String.r()

More examples:

1. scala> val s:Any = "hello :D"
2. s: Any = hello :D
4. scala> s.asInstanceOf[{def charAt(x:Int):Char}].charAt(2)
5. res9: Char = l
7. /*
8. This is interesting.  The actual method returns Char, but Char is
9. compatible with Any so this cast works.
10. */
11. scala> s.asInstanceOf[{def charAt(x:Int):Any}].charAt(2) 
12. res10: Any = l
14. // Now lets test to see if that lenience is available for parameters:
15. scala> class X 
16. defined class X
18. scala> class Y extends X
19. defined class Y
21. scala> class T {
22.      | def x(x:X):Int = 1
23.      | }
24. defined class T
26. scala> val a:Any = new T()
27. a: Any = T@687c3b99
29. scala> a.asInstanceOf[{def x(x:X):Any}].x(new Y())
30. res11: Any = 1
32. /*
33. Ok so return values can be subclasses but not params
34. */
35. scala> a.asInstanceOf[{def x(x:Y):Any}].x(new Y())
36. java.lang.NoSuchMethodException: T.x(Y)
37. at java.lang.Class.getMethod(Class.ja

Use with care :-D

Introducing Structural Types

Structural types allows one to declare types based on the methods the type has. For example you could define a method that takes a class containing a close method. This is fairy analogous to duck-typing in dynamic languages. Except that it is statically enforced.

The main example used here was from a comment on the Code Monkeyism Blog. The commenter further explains that this example is in fact from Beginning Scala chapter 4 (which I would like to read but have not yet had the time.)

1. /*
2. A can be any object that has a close method.  
4. This is statically typed which makes some restrictions which are explained later
5. */
6. scala> def using[A <: {def close(): Unit}, B](param: A)(f: A => B): B = 
7.      | try {
8.      |     f(param)
9.      |   } finally {
10.      |     try {
11.      |        param.close()
12.      |     } catch { case _ => () }
13.      |   }
14. using: [A <: AnyRef{def close(): Unit},B](param: => A)(f: (A) => B)B
16. scala> using(new java.io.ByteArrayInputStream("hello world".getBytes)){ in => 
17.      | io.Source.fromInputStream(in) foreach (print)                          
18.      | }
19. hello world
21. scala> using(new java.io.ByteArrayInputStream("hello world".getBytes)){ in => 
22.      | io.Source.fromInputStream(in) mkString ""                              
23.      | }
24. res8: String = hello world

That is extremely powerful and the consequences will be visited more in the future. But because structural typing is statically enforced it is not quite as flexible as dynamic language's version of duck typing. For example you cannot do:

1. scala> val i:Any = new java.io.ByteArrayInputStream("hello world".getBytes)
2. i: Any = java.io.ByteArrayInputStream@145a25f3
4. /*
5. This does not work because 'i' is defined as type Any.  Not a type that is closeable.  
7. Casting can be used to get around this issue.  I will address that in its own post
8. */
9. scala> using(i){ in => 
10.      | io.Source.fromInputStream(in) mkString ""
11.      | }
12. < console>:8: error: inferred type arguments [Any,B] do not conform to method using's type parameter bounds [A <: AnyRef{def close(): Unit},B]
13.        using(i){ in =>

An alternative to the first using example is to use call by name to construct the closeable. The reason one might want to do that is because it allows currying of the method:

1. scala> def using[A <: {def close(): Unit}, B](param: =>A)(f: A => B): B = 
2.      | val closeable = param  // notice param is only referenced once
3.      | try {
4.      |     f(closeable)
5.      |   } finally {
6.      |     try {
7.      |        closeable.close()
8.      |     } catch { case _ => () }
9.      |   }
10. using: [A <: AnyRef{def close(): Unit},B](param: => A)(f: (A) => B)B
12. /*
13. if this was accessing a database a new connection would be made automatically each time this function was used
14. */
15. scala> val usingTheWorld = using[BStream,Int](new java.io.ByteArrayInputStream("hello world".getBytes))_
16. usingTheWorld: ((java.io.ByteArrayInputStream) => Int) => Int = < function1>
18. scala> usingTheWorld { s => io.Source.fromInputStream(s).length}  
19. res3: Int = 11
21. scala> usingTheWorld { s => io.Source.fromInputStream(s).getLines().length}
22. res5: Int = 0

Labelled Multiple Returns

A cool idea I found at http://stackoverflow.com/questions/1827672/is-there-a-way-to-have-tuples-with-named-fields-in-scala-similar-to-anonymous-cl. A very simple idea but very useful.
To summarize, you want to return multiple values but want to assign names to the values rather than use a tuple which more or less assigns indices to the different values. Here are a couple of solutions:

Using structured types. Simplest solution with the least extra code.

1. scala> def multipleReturns1 = {
2.      | new { val first = 1; val second = 2 }
3.      | }
4. multipleReturns1: java.lang.Object{def first: Int; def second: Int}
6. scala> multipleReturns1
7. res0: java.lang.Object{def first: Int; def second: Int} = $anon$1@549b6976
9. scala> res0.first
10. res1: Int = 1
12. scala> res0.second
13. res2: Int = 2
15. scala> import res0._
16. import res0._
18. scala> first
19. res3: Int = 1
21. scala> second
22. res4: Int = 2

Using case classes. Returns a product which has properties that may be useful.

1. scala> def moreReturns = {
2.      | case class Returns (one:Int, two:Int)
3.      | Returns(1,2)
4.      | }
5. moreReturns: java.lang.Object with ScalaObject with Product{def one: Int; def two: Int}
7. scala> moreReturns
8. res5: java.lang.Object with ScalaObject with Product{def one: Int; def two: Int} = Returns(1,2)
10. scala> res5.one
11. res6: Int = 1
13. scala> res5.two
14. res7: Int = 2
16. scala> import res5._
17. import res5._
19. scala> one
20. res8: Int = 1
22. scala> two
23. res9: Int = 2
25. scala> res5.productIterator foreach println _
26. 1
27. 2
29. scala> res5.productPrefix
30. res15: java.lang.String = Returns