=>? type alias for PartialFunction

A big thanks to Ben Jackman for this tip.

His tip cleans up the examples in post Chaining Partial Functions with orElse
The secret is to define the type alias type =>?[-A, +B] = PartialFunction[A, B]. This alias may be added to Predef in the future but until it is you can add it yourself.

1. scala> type =>?[-A, +B] = PartialFunction[A, B]
2. defined type alias $eq$greater$qmark
4. scala> val i : (Any =>? Unit) = {case x:Int => println("int found")}
5. i: =>?[Any,Unit] = < function1>
7. scala> val j : (Any =>? Unit) = {case x:Double => println("Double found")}
8. j: =>?[Any,Unit] = < function1>
10. scala> val * : (Any =>? Unit) = {case x=> println("Something else found")}
11. *: =>?[Any,Unit] = < function1>
13. scala> (i orElse j orElse *)(1)
14. int found
16. scala> (i orElse j orElse *)(1.0)
17. Double found
19. scala> (i orElse j orElse *)(true)
20. Something else found
22. scala> def =>?[A, B](id : A =>? B) = id
23. $eq$greater$qmark: [A,B](id: =>?[A,B])=>?[A,B]
25. scala> ( =>?[Any, Unit]{case s : String => println("String found")} orElse j orElse *)("hello")
26. String found

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