Scala intro

Alapvető tulajdonságok

• Fejlett, erős típusrendszer
• OOP - öröklődés
• OOP - case classok
• OOP - generikus típusok
• FP - Pattern matching
• FP - Monadikus programozás

Típusrendszer

• Erős, statikus
• Kovariancia, kontravariancia ([+T], [-T])
• Absztrakt típusok (family polymorphism)
• Meghatározható korlátok(<:, >:, >:>)
• Strukturális típusok (duck typing)
• Implicitek (konverzió, paraméterlista)
• Típusosztályok
• A függvények elsőrendû részei
• Parciális függvények, currying

Öröklődés

• Egyszeres öröklődés
• Traitek
• Több is bemixelhető
• Nincs konstruktoruk
• Tartalmazhatnak adatot, deklarációt, definíciót
• Linearizácio (vs gyémánt)
• Osztálykonstruktorok
• Konstruktorlánc
• Láthatóság (private, public, protected, package)

Case classok

case class A(val x: Int, val y: String) {
        def f = x.toString + y
    }

• Minél kevesebb kód, annál kevesebb bug
• Szemantikusan helyes
• toString, hashCode, equals, ==, clone
• setterek, getterek
• apply, unapply

Generikus típusok

class A[T, +U <: T, -C]() extends B[T]

• Default: invariáns
• Varianciafigyelés (compiler)
• Bytecode: nem generikus (erasure)
• TypeTagek
• Öröklődést leíró operátorok

Pattern matching

def f(a: Any) = a match {
        case x: Int => "Integer"
        case (_, sec @ (_, "tupling")) => "Comlex tuple" + sec.toString
        case _ => "default"
    }

• apply/unapply (case class)
• Regex

val pat = "[a-z]".r
    "asdf" match {
        case pat => "Matched!"
        case _ => "No match"
    }

• Extraktor objektumok
• Compiler: figyel a teljességre

Monádok

• Számítási lépések struktúrája
• FP: "érzésre állapot módosítása"
• Típuskonstruktor, unit, bind
• Generikus paraméter, object apply, flatMap
• Alapvető eleme a Scala Std Lib-nek
• Option[A]
• Future[A], Promise[A]
• Try[A], Success[A], Failure[A]
• Either[A]

Megkülönböztető tulajdonságok

DSL-ek

• Beépített, erős támogatás
• Ami nem feltétlenül szükséges, elhagyható (., (), ;, {})
• $-t kivéve bármi lehet függvénynév (pl. +=:)
• Függvényliterálok "kontrolszerkezetekhez"

def f(x: String)(f: Unit => Unit) = [...]
f("DoSomething") {
    [...]
}

• Ha ez sem elég, compiler pluginek, makrók

Makrók

• Scala program, ami compile-time fut
• AST-transzformáció (AST node-ok: Scala generikus objektumok)
• Futás közben megkapjuk a compiler állapotát
• Ha új típust kell létrehozni: compiler plugin
• Fontos szerep a TypeTageknek, pattern matchingnek
• Meghatározható, melyik compiler phase után fusson
• reify, splice
• User kód módosítása
• Continuations, state machine, etc.

Makrók pelda

def hello(param: String): Unit = macro hello_impl
                
def hello_impl(c: Context)(param: c.Expr[String]): c.Expr[Unit] ={
    import c.universe._
    reify { println("Hello " + param.splice + "!") }
}
                
            

hello("World") ~> println("Hello " + "World" + "!")
                
            

Path-dependent típusok

• Típusdefiníciók egymásba ágyazása
• A belső típus definíciójának része az "út"
• class A(x: Int){object B {val z = x * 2}}
• A külső típus típusa helyett a peldányhoz kötjük a belső típust
• val a1 = A(1); val a2 = A(1)
• a1.B =:= a2.B hamis

Collections

• Fejlett collections könyvtár
• Immutabilitás támogatása, "erőltetése"
• Magasabbrendű függvények
  map, zip, flatMap, fold, fold[Left, Right], groupBy, find...
• Típusinformáció megőrzése(variancia, builderek, CanBuildFrom)
• Gyakran Java collection köré wrapper
• Java collection gazdagítása (implicitek, richString)
• Konkurrens változatok

Aktorok

• Lényegeben egy DSL

   actor ! msg 

• Akka -> Scala Actors -> Akka
• Skálázhatóság
• Üzenetküldés
• Pattern matching

XML literálok

• Webközpontúság (twitter, linkedin)
• Literálok + könyvtárak programmatikus hozzáféréshez
• Kódsnippetek a literálok közben

val myXML = <input type='radio'
name={package.getMeTheName()}
value='true'
checked={ if (myFunc.get.isEmpty) {
    "checked"
} else {
    null
}}/>