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