scala> def f(x:Int) = x match {
     | case 0 | 1 | 2 => "unoduetre"
     | case _ => "altro"
     | }
f: (x: Int)String

scala> f(0)
res0: String = unoduetre

scala> f(10)
res1: String = altro

scala> def f(x:Int) = x match {
     | case _ if (x<0) => "negativo"
     | case 0 => "zero"
     | case _ => "positivo"
     | }
f: (x: Int)String

scala> f(-45)
res2: String = negativo

scala> f(0)
res3: String = zero

scala> f(10)
res4: String = positivo

scala> def f(x:Int) = x match {
     | case n if (n>0) => "Negativo"
     | case _ => "Non negativo"
     | }
f: (x: Int)String

scala> def f(x:Int,y:Int) = (x,y) match {
     | case (0,0) => "entrambi zero"
     | case (0,_) => "primo zero"
     | case (_,0) => "secondo zero"
     | case _ => "nessuno zero"
     | }
f: (x: Int, y: Int)String

scala> f(0,0)
res5: String = entrambi zero

scala> f(0,1)
res6: String = primo zero

scala> f(1,0)
res7: String = secondo zero

scala> f(1,1)
res8: String = nessuno zero

scala> def f(x:Int,y:Int) = (x,y) match {
     | case t if (t._1==0 && t._2==0) => "zero"
     | case _ => "altro"
     | }
f: (x: Int, y: Int)String

scala> f(0,0)
res9: String = zero

scala> f(0,10)
res10: String = altro

scala> def len[T](l:List[T]):Int = l match {
     | case Nil => 0
     | case h::t => 1 + len(t)
     | }
len: [T](l: List[T])Int

scala> len(List())
res11: Int = 0

scala> len(Nil)
res12: Int = 0

scala> len(List(1,2,3,4,5))
res13: Int = 5

scala> def merge(l1:List[Int],l2:List[Int]):List[Int] = (l1,l2) match {
     | case (Nil,_) => l2
     | case (_,Nil) => l1
     | case (h1::t1,h2::t2) if (h1<h2) => h1::merge(t1,l2)
     | case (_,h2::t2) => h2::merge(l1,t2)
     | }
merge: (l1: List[Int], l2: List[Int])List[Int]

scala> merge(List(1,3,5,7), List(0,2,4,6))
res14: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 7)

scala> def f(l:List[Int]) = l match {
     | case h::t => "lista non vuota"
     | case _ => "lista vuota"
     | }
f: (l: List[Int])String

scala> f(Nil)
res15: String = lista vuota

scala> f(List(1,2,3))
res16: String = lista non vuota

scala> def f(x:Any) = x match {
     | case i:Int => println("intero "+i)
     | case f:Float => println("float "+f)
     | case s:String => println("stringa "+s)
     | case _ => println("non so")
     | }
f: (x: Any)Unit

scala> f(8)
intero 8

scala> f(8.4)
non so

scala> f(8.4f)
float 8.4

scala> f("ciao")
stringa ciao

scala> f(Nil)
non so

scala> def equal[T](l1:List[T],l2:List[T]):Boolean = (l1,l2) match {
     | case (Nil,Nil) => true
     | case (Nil,_) => false
     | case (_,Nil) => false
     | case (h1::t1, h2::t2) => h1==h2 && equal(t1,t2)
     | }
equal: [T](l1: List[T], l2: List[T])Boolean

scala> equal(Nil,Nil)
res22: Boolean = true

scala> equal(Nil,List(1,2,3))
res23: Boolean = false

scala> equal(List(1,2,3),List(1,2,3))
res24: Boolean = true

scala> def map[A,B](l:List[A], f:A=>B):List[B] = Nil
map: [A, B](l: List[A], f: A => B)List[B]

scala> def map[A,B](l:List[A], f:A=>B):List[B] = l match {
     | case Nil => Nil
     | case h::t => f(h)::map(t,f)
     | }
map: [A, B](l: List[A], f: A => B)List[B]

scala> map(List(1,2,3), (x:Int)=>2*x)
res26: List[Int] = List(2, 4, 6)

scala> val l=List(1,3,6,3,5,9)
l: List[Int] = List(1, 3, 6, 3, 5, 9)

scala> l.zipWithIndex
res27: List[(Int, Int)] = List((1,0), (3,1), (6,2), (3,3), (5,4), (9,5))

scala> l.zip(List.range(0,l.length))
res28: List[(Int, Int)] = List((1,0), (3,1), (6,2), (3,3), (5,4), (9,5))

scala> l.zip(0 to l.length-1)
res29: List[(Int, Int)] = List((1,0), (3,1), (6,2), (3,3), (5,4), (9,5))