pattern matching in scala (map/fold)

higher_order.scala

// simple map and fold left/right implementations 
// in scala using pattern matching for List[Int]

def map(list:List[Int], f:(Int) => Int):List[Int] = {
  list match {
    case Nil => Nil
    case head::tail => f(head)::map(tail, f)
  }
}

def foldRight(list:List[Int], initVal:Int, f:(Int, Int) => Int):Int = {
  list match {
    case Nil => initVal
    case head::tail => f(head, foldRight(tail, initVal, f))
  }
}

def foldLeft(list:List[Int], initVal:Int, f:(Int, Int) => Int):Int = {
  list match {
    case Nil => initVal
    case head::tail => foldLeft(tail, f(initVal, head), f)
  }
}


// quick tests

val list = List(1, 2, 3, 4)

val addOne = (x:Int) => x + 1

val myMap = map(list, addOne)
val libMap = list.map(addOne)

println("Map: %s = %s, %s".format(myMap, libMap, myMap == libMap))


val subtract = (x:Int, y:Int) => x - y

val myFoldR = foldRight(list, 0, subtract)
val libFoldR = list.foldRight(0)(subtract)

val myFoldL = foldLeft(list, 0, subtract)
val libFoldL = list.foldLeft(0)(subtract)

println("Fold Right: %d = %d, %s".format(myFoldR, libFoldR, myFoldR == libFoldR))
println("Fold Left: %d = %d, %s".format(myFoldL, libFoldL, myFoldL == libFoldL))