How map work on Options in Scala?

Question

I have this two functions

  def pattern(s: String): Option[Pattern] =
try {
  Some(Pattern.compile(s))
} catch {
  case e: PatternSyntaxException => None
}

and

  def mkMatcher(pat: String): Option[String => Boolean] =
     pattern(pat) map (p => (s: String) => p.matcher(s).matches)

Map is the higher-order function that applies a given function to each element of a list.

Now I am not getting that how map is working here as per above statement.

Answer 1

Map is the higher-order function that applies a given function to each element of a list.

This is an uncommonly restrictive definition of map.

At any rate, it works because it was defined by someone who did not hold to that.

For example, that someone wrote something akin to

sealed trait Option[+A] {
  def map[B](f: A => B): Option[B] = this match {
    case Some(value) => Some(f(value))
    case None => None
  }
}

as part of the standard library. This makes map applicable to Option[A]

It was defined because it makes sense to map many kinds of data structures not just lists. Mapping is a transformation applied to the elements held by the data structure.

It applies a function to each element.

Option[A] can be thought of as a trivial sequence. It either has zero or one elements. To map it means to apply the function on its element if it has one.

Now it may not make much sense to use this facility all of the time, but there are cases where it is useful.

For example, it is one of a few distinct methods that, when present enable enable For Expressions to operate on a type. Option[A] can be used in for expressions which can be convenient.

For example

val option: Option[Int] = Some(2)

val squared: Option[Int] = for {
  n <- option
  if n % 2 == 0
} yield n * n

Interestingly, this implies that filter is also defined on Option[A].

If you just have a simple value it may well be clearer to use a less general construct.