Cheatsheet request: Scala

[rajit]

Perhaps things like:

Passing lambdas as values

Anonymous parameter syntax:

List(1, 2, 3).map(_ + 1) // = List(2, 3, 4)

Named parameter/expanded syntax, inferred type:

List(1, 2, 3).map(i => i + 1) // = List(2, 3, 4)

Named parameter, explicit type:

List(1, 2, 3).map((i: Int) => i + 1) // = List(2, 3, 4)

Receiving lambdas and using them

Single parameter:

def filter(list: List[Int], predicate: Int => Boolean): List[Int] = list match {
  case x :: xs if predicate(x) => x :: filter(xs, predicate)
  case Nil => Nil
}

Multiple parameters:

def combine(emptyValue: Int, list: List[Int], combiner: (Int, Int) => Int): Int = list match {
  case x :: y :: xs => combine(combiner(x, y) :: xs)
  case x :: Nil => x
  case Nil => emptyValue
}

Curried parameters:

def map(list: List[Int], adder: Int => Int => Int, amount: Int): List[Int] = list.map(adder(amount))
map(List(1, 2, 3), a => i => i + a, 10) // = List(11, 12, 13)

ADTs

sealed trait Message
case class Hello(name: String) extends Message
case object Goodbye extends Message

def log(msg: Message): Unit = msg match {
  case Hello(name) => println(s"Hello $name")
} // On compilation will warn of non-exhaustive match unless Goodbye is also matched

Type aliases

type MyType = String

def ping(msg: MyType) = ???

To change the kind of a type:

type ErrorOr[A] = Either[Throwable, A]
// Can be used where * -> * required

More ideas:

• Type lambdas
• Self types
• Type classes
• Context bounds
• Higher-kinded types