在Scala中执行map / getOrElse返回单位的惯用方式是什么？

Question

What's the most idiomatic way to do a side-effect if a value is Some(...) and do another side-effect if a value is None. Here's what I'd currently tend to write:

def doSideEffectA(value: Int) {
  // ...
}

def doSideEffectB() {
  // ...
}

def doSideEffect(valueOption: Option[Int]) {
  valueOption map { value =>
    doSideEffectA(value)
  } getOrElse {
    doSideEffectB()
  }
}

My problem is that if I didn't have to do anything if valueOption is None, here's what I'd write:

def doSideEffectNothingIfNone(valueOption: Option[Int]) {
  valueOption foreach { value =>
    doSideEffectA(value)
  }
}

map/getOrElse are usually not used in a side-effect context, while foreach is. I'm not really comfortable with valueOption map { ... } getOrElse { ... } returning Unit, as I don't really "get" anything from my Option[Int].

Answer 1

What Kim Stebel said: pattern matching is a simple solution.

valueOption match {
  case Some(value) => doSideEffectA(value)
  case None => doSideEffectB()
}

Answer 2

Scala 2.10 includes a fold method on Option which is suitable for any case where you need both None and Some to resolve to the same type (including Unit ):

scala> Option("salmon").fold(println("No fish")){f => println(s"I like $f")}
I like salmon

Answer 3

With scalaz you get a fold method on Option , that takes two functions and executes one of them depending on whether you have a Some or a None :

scala> some(3).fold({ x => println(x) }, println("FOO"))
3

scala> none[String].fold({ x => println(x) }, println("FOO"))
FOO

Answer 4

Scalaz has cata , which would allow you to state it like this:

valueOption.cata(doSideEffectA, doSideEffectB)

Never used it, but it looks pretty useful and readable to me. This is how it's implemented:

  /**
   * Catamorphism over the option. Returns the provided function `some` applied to item contained in the Option
   * if it is defined, otherwise, the provided value `none`.
   */
  def cata[X](some: A => X, none: => X): X = value match {
    case None => none
    case Some(a) => some(a)
  }

Answer 5

Despite the fact that I still think pattern matching is the most readable option, you can also have it your way and define a wrapper around Option with an implicit conversion.

class Else(doit:Boolean) {
  def orDoThis[A](f: =>A) {
    if (doit) f
  }
}

class OptionWrapper[A](o:Option[A]) {
  def each[B](f: A=>B):Else = o match {
    case Some(v) => f(v); new Else(false)
    case None => new Else(true)
  }
}

implicit def wrapOption[A](o:Option[A]):OptionWrapper[A] = new OptionWrapper(o)

Then you can write for example:

Some(1) each println orDoThis println("nothing there")

Answer 6

The most idiomatic way really is pattern matching. Otherwise, you can create an implicit wrapper which provides the desired method:

class RichOption[T](o: Option[T]) {
  def ifEmpty(action: => Unit) { if (o.isEmpty) action }
}

object RichOption {
  implicit def enrich(o: Option[T]) = return new RichOption(o)
}

EDIT: the one in @KimStebel's answer better matches the desired usage.