1) The option method is intended to encapsulate the deconstruction of the Option type. Consider that Option has two case class constructors, None and Some, therefore, the method has two arguments. Furthermore, one of the constructors (Some) takes a single argument, therefore, one of the method arguments is a function that takes 1 argument.

It might be a good exercise to attempt to write the option method while maintaining the given type signature. You will use pattern matching to do so. The point is, however, that you have encapsulated the most general form of Option deconstruction and so you needn’t (theoretically) ever manually deconstruct Option again with pattern matching.

2) There is an implicit from Option to Iterable in the Option object. http://www.scala-lang.org/docu/files/api/scala/Optionobject.html#option2Iterable%28Option%5BA%5D%29

3) It may be the case that you have a general deconstruction form where you use the hypothetical option method. Then, are there any recurring patterns? If so, write a more specific function.

There is no problem with your call to map then getOrElse. Efficiency should not be considered here in favour of the compiler performing what is called ‘fusing’. In practice though, the compiler will not fuse this expression, nor will the efficiency cost be negligible to the gain in expressivity.

Finally, you may want to ‘compose’ these functions yourself and I recommend you do so even if just for your own satisfaction. You can implement it by calling map then getOrElse with the appropriate arguments. Then, if one day performance becomes a huge issue, change the implementation to use pattern matching. Doing this is essentially manual fusing.

I hope this helps; ask more questions if you need.

1. I don’t understand the def option[A,X] method, since no body is given. Is this something generic that should be so obvious I can write it myself, or is it something specific to a given situation?

2. Methods forall and exists are not listed in the scaladoc for Option, but I tried them and they do work. Where do they come from? Is there an implicit conversion happening here?

3. Most seriously, I have a pattern that does not match any of the patterns given:

def process(o: Option[A], cc: C): B =
o match {
case Some(a) => f (a, cc) // value of type B that depends on both a and cc
case None => g(cc) // value of type B that depends only on cc
}

The only way that I see to replace this match is with

o.map(f(_,cc)).getOrElse(g(cc))

This seems less efficient since it uses two calls, and the first call constructs an extra Option[B] to which to apply the second call.

case Full(dbuser) => if (dbuser.password.match_?(password)) User.logUserIn(dbuser) else error(”wrong password”)
case Empty => notice(”sending verification mail”)

Then of course, you could just call the option method or equivalent for Can. Then you might want to get even more specific by decomposing your if. Since you can write if yourself in Scala, you can then apply certain specialisations to it. I’ll let you write your Scala if, then various specialisations without giving the answer away

User.find(By(User.email, email)) match {
case Full(dbuser) if (dbuser.password.match_?(password)) => User.logUserIn(dbuser)
case Full(dbuser) => error(”wrong password”)
case Empty => notice(”sending verification mail”)
}

Here its a Can with Full instead of Some, but that shouldn’t be important.

I’m wondering, how would one use Option in the case described in the first comment here (http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-2#numcomments)?

(Copied from there)

abstract class Shape {
..var fillColor:Option[Color] = None
..// etc
}

class Circle(var radius:Int) extends Shape {
..def draw(g:Graphics):Unit = fillColor match {
....case None =>
......g.drawCircle(0, 0, radius / 2, radius / 2)
....case Some(color) => {
......g.setColor(color);
......g.fillOval(0, 0, radius / 2, radius / 2)
....}
..}
}

I suspect the problem is the inherent imperative-ness of requiring setColor to be called before fillOval. Can I get around this in Scala using the examples above, or is there more to the story?