-------------------------------------------
Gerarchia delle classi:

scala> null
res0: Null = null

scala> val x:List[Int] = null
x: List[Int] = null

scala> val x:String = null
x: String = null

scala> Nil
res1: scala.collection.immutable.Nil.type = List()

scala> val x : List[Nothing] = Nil
x: List[Nothing] = List()

scala> val x = Traversable(1,2,7,3)
x: Traversable[Int] = List(1, 2, 7, 3)

scala> val x = Seq(1,2,7,3)
x: Seq[Int] = List(1, 2, 7, 3)

scala> "ciao"(2)
res2: Char = a

scala> val x = scala.collection.immutable.TreeSet(2,5,1)
x: scala.collection.immutable.TreeSet[Int] = TreeSet(1, 2, 5)

scala> val x = scala.collection.immutable.SortedSet(2,5,1)
x: scala.collection.immutable.SortedSet[Int] = TreeSet(1, 2, 5)

-------------------------------------------
mappe:

scala> Map("uno"->1, "due"->2, "tre"->3)
res3: scala.collection.immutable.Map[String,Int] = Map(uno -> 1, due -> 2, tre -> 3)

scala> "Uno" -> 1
res4: (String, Int) = (Uno,1)

scala> val m = Map("uno"->1, "due"->2, "tre"->3)
m: scala.collection.immutable.Map[String,Int] = Map(uno -> 1, due -> 2, tre -> 3)

scala> m("due")
res5: Int = 2

scala> m("dueeee")
java.util.NoSuchElementException: key not found: dueeee
  at scala.collection.MapLike$class.default(MapLike.scala:228)
  at scala.collection.AbstractMap.default(Map.scala:59)
  at scala.collection.MapLike$class.apply(MapLike.scala:141)
  at scala.collection.AbstractMap.apply(Map.scala:59)
  ... 33 elided

scala> if (m contains "pippo") m("pippo") else -1
res7: Int = -1

scala> m.toList
res8: List[(String, Int)] = List((uno,1), (due,2), (tre,3))

-------------------------------------------
groupBy:

scala> List(1,3,2,6,8,5,6,3).groupBy(x=>x)
res9: scala.collection.immutable.Map[Int,List[Int]] = Map(5 -> List(5), 1 -> List(1), 6 -> List(6, 6), 2 -> List(2), 3 -> List(3, 3), 8 -> List(8))

scala> List(1,3,2,6,8,5,6,3).groupBy(identity)
res10: scala.collection.immutable.Map[Int,List[Int]] = Map(5 -> List(5), 1 -> List(1), 6 -> List(6, 6), 2 -> List(2), 3 -> List(3, 3), 8 -> List(8))

scala> case class Studente(nome:String, eta:Int)
defined class Studente

scala> val l = List(Studente("Paola",20), Studente("Marco",21), Studente("Sonia",20))
l: List[Studente] = List(Studente(Paola,20), Studente(Marco,21), Studente(Sonia,20))

scala> l.groupBy(s=>s.eta)
res11: scala.collection.immutable.Map[Int,List[Studente]] = Map(20 -> List(Studente(Paola,20), Studente(Sonia,20)), 21 -> List(Studente(Marco,21)))

-------------------------------------------
Option, Some, None:

scala> Set(1,3,4,1,5)
res12: scala.collection.immutable.Set[Int] = Set(1, 3, 4, 5)

scala> l
res13: List[Studente] = List(Studente(Paola,20), Studente(Marco,21), Studente(Sonia,20))

scala> l.find(s=>s.nome == "Marco")
res14: Option[Studente] = Some(Studente(Marco,21))

scala> l.find(s=>s.nome == "Mario")
res15: Option[Studente] = None

scala> l.find(s=>s.eta == 20)
res16: Option[Studente] = Some(Studente(Paola,20))

scala> val o = l.find(s=>s.eta == 20)
o: Option[Studente] = Some(Studente(Paola,20))

scala> o.get
res17: Studente = Studente(Paola,20)

scala> val o = l.find(s=>s.eta == 27)
o: Option[Studente] = None

scala> o.get
java.util.NoSuchElementException: None.get
  at scala.None$.get(Option.scala:347)
  at scala.None$.get(Option.scala:345)
  ... 33 elided

scala> o orElse null
res19: Option[Studente] = null

scala> val o = l.find(s=>s.eta == 27)
o: Option[Studente] = None

scala> o getOrElse "hello"
res21: java.io.Serializable = hello

scala> o getOrElse 10
res22: Any = 10

scala> val x = o getOrElse 10
x: Any = 10

scala> val x = Some("hello") getOrElse 10
x: Any = hello

scala> val x = Some("hello") getOrElse "ciao"
x: String = hello

scala> val l = List(1,2,3)
l: List[Int] = List(1, 2, 3)

scala> val o = l.find(x=>x>2)
o: Option[Int] = Some(3)

scala> o.get
res29: Int = 3

scala> o getOrElse -1
res30: Int = 3

scala> l.find(x=>x<0) getOrElse -1
res32: Int = -1

scala> l.find(x=>x<0) getOrElse "err"
res33: Any = err

scala> res33
res34: Any = err

scala> res33 match {
     | case i:Int => println("intero i")
     | case _ => println("errore")
     | }
errore

scala> Map()(10)
java.util.NoSuchElementException: key not found: 10
  at scala.collection.MapLike$class.default(MapLike.scala:228)
  at scala.collection.AbstractMap.default(Map.scala:59)
  at scala.collection.MapLike$class.apply(MapLike.scala:141)
  at scala.collection.AbstractMap.apply(Map.scala:59)
  ... 33 elided

-------------------------------------------
Inizializzazione lazy:

scala> lazy val x = { println("!!"); 1}
x: Int = <lazy>

scala> x
!!
res37: Int = 1

scala> x
res38: Int = 1

-------------------------------------------
Bound sui tipi generici:

scala> class C[T](val x:T)
defined class C

scala> new C("ciao")
res39: C[String] = C@1db93cce

scala> new C(3.14)
res40: C[Double] = C@4e99e262

scala> class C[T<:AnyVal](val x:T)
defined class C

scala> new C(3.14)
res41: C[Double] = C@5dbb410b

scala> new C("ciao")
<console>:12: error: inferred type arguments [String] do not conform to class C's type parameter bounds [T <: AnyVal]
       new C("ciao")
       ^
<console>:12: error: type mismatch;
 found   : String("ciao")
 required: T
       new C("ciao")
             ^

scala> def check[T](x:T, y:T) = x<y
<console>:11: error: value < is not a member of type parameter T
       def check[T](x:T, y:T) = x<y
                                 ^

scala> def check[T<:AnyVal](x:T, y:T) = x<y
<console>:11: error: value < is not a member of type parameter T
       def check[T<:AnyVal](x:T, y:T) = x<y
                                         ^
scala> def check[T<%Ordered[T]](x:T, y:T) = x<y
check: [T](x: T, y: T)(implicit evidence$1: T => Ordered[T])Boolean

scala> def check[T<%Ordered[T]](x:T, y:T) = x<=y
check: [T](x: T, y: T)(implicit evidence$1: T => Ordered[T])Boolean

scala> check(10,20)
res44: Boolean = true

scala> check(10.5,20.8)
res45: Boolean = true

scala> check(10.5,0.8)
res46: Boolean = false

scala> check("str","kkk")
res47: Boolean = false

-------------------------------------------
Stream:

scala> 1 #:: 2 #:: 5 #:: Stream.empty
res48: scala.collection.immutable.Stream[Int] = Stream(1, ?)

scala> 1 :: 2 :: 5 :: Nil
res49: List[Int] = List(1, 2, 5)

scala> val s = 1 #:: 2 #:: 5 #:: Stream.empty
s: scala.collection.immutable.Stream[Int] = Stream(1, ?)

scala> s
res50: scala.collection.immutable.Stream[Int] = Stream(1, ?)

scala> s.toList
res51: List[Int] = List(1, 2, 5)

scala> s.take(2)
res52: scala.collection.immutable.Stream[Int] = Stream(1, ?)

scala> s.take(2).toList
res53: List[Int] = List(1, 2)

scala> s.map(x=>2*x).take(2)
res54: scala.collection.immutable.Stream[Int] = Stream(2, ?)

scala> s.map(x=>2*x).take(2)
res55: scala.collection.immutable.Stream[Int] = Stream(2, ?)

scala> s.map(x=>2*x).take(2).toList
res56: List[Int] = List(2, 4)

scala> def nat(n:Int):Stream[Int] = n #:: nat(n+1)
nat: (n: Int)Stream[Int]

scala> val N = nat(0)
N: Stream[Int] = Stream(0, ?)

scala> N(5)
res57: Int = 5

scala> N.take(7).toList
res58: List[Int] = List(0, 1, 2, 3, 4, 5, 6)

scala> N.toList
java.lang.OutOfMemoryError: GC overhead limit exceeded
  at scala.collection.immutable.Stream$ConsWrapper.$hash$colon$colon(Stream.scala:1186)
  at .nat(<console>:10)
  at $anonfun$nat$1.apply(<console>:10)
  at $anonfun$nat$1.apply(<console>:10)
  at scala.collection.immutable.Stream$Cons.tail(Stream.scala:1233)
  at scala.collection.immutable.Stream$Cons.tail(Stream.scala:1223)
  at scala.collection.generic.Growable$class.loop$1(Growable.scala:54)
  at scala.collection.generic.Growable$class.$plus$plus$eq(Growable.scala:57)
  at scala.collection.mutable.ListBuffer.$plus$plus$eq(ListBuffer.scala:183)
  at scala.collection.mutable.ListBuffer.$plus$plus$eq(ListBuffer.scala:45)
  at scala.collection.TraversableLike$class.to(TraversableLike.scala:635)
  at scala.collection.AbstractTraversable.to(Traversable.scala:104)
  at scala.collection.TraversableOnce$class.toList(TraversableOnce.scala:292)
  at scala.collection.AbstractTraversable.toList(Traversable.scala:104)
  ... 18 elided

scala> def fib(a:Int, b:Int):Stream[Int] = a #:: fib(b,a+b)
fib: (a: Int, b: Int)Stream[Int]

scala> val f = fib(1,1)
f: Stream[Int] = Stream(1, ?)

scala> f(56)
res60: Int = 363076002

scala> f.take(12).toList
res61: List[Int] = List(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144)

-------------------------------------------
Eccezioni:

object ExcMain extends App {
    val x = try {
            Map((1,999))(2)
        } catch {
            case e:Exception => "err"
        }
    x match {
        case i:Int => println("intero "+i)
        case _ => println("errore")
    }
}