Inf / Scala

Scala: language principles

Quellen

  • läuft auf JVM und benutzt Java Datentypen und KlassenLibrary
    • scalac compiler
    • scala interpreter und executor
      • ohne Argumente als Interpreter
      • alle compiler optionen sind erlaubt: scala -depreciation
      • :help im Interpreter
      • :load file um ein File zu interpretieren
      • im Gegensatz zum Compiler, müssen benutzte Sachen vorher deklariert werden
  • syntax weniger strikt als java,
    • ; werden erraten, **
    • ( ) und Punkte sind nicht immer nötig, z.B. kann folgendermassen Abkgekekürzt werden
      • o.m(a) als o m a
      • f(a,b) als a f b, Prio uns Assoziativität hängt syntax von f bzw. m ab
      • o.m() als o m
      • f() as f
    • Methoden/FunktionsNamen können Namen oder Folgen von Spezialzeichen sein
    • == ist die überschreibbare inhaltliche Gleichheit, eq die PointerGleichheit
    • Kommentare mit // oder /* ... */, doc comments mit /** .... */
    • Annotations, vordefiniert z.B. @serializable
  • extensibilität: z.B. Operator overloading, eigene KontrollKonstrukte
  • funktional und OO
  • alles ist ein Objekt, auch Methoden und Funktionen
    • anonyme Funktion (x: Int) => x * x
    • geschachtelte Funktionen mit Closures
    • Parameter by value a: Int oder by name a: => Int, da wird Ausdruck bei jeder Erwähnung ausgewertet: def e(i: => Int) = {println("evaluating"); try { i} catch {case e => println("catch " + e); -123 }}
  • Object ⇔ Class ⇔ Trait
    • val, var, def, class, object definiert je Konstante, Variable, Methode, Klasse,
    • object (Klasse mit Singleton - aber innerhalb scope, ist ein Modul und auch Ersatz für statische KlassenKonstrukte)
    • trait Abstrakte Klasse für Mixin Komposition (ersetzt Interfaces, implementiert Art von multiple Inheritance)
    • if für Statements und Expressions, genauer Statments und Expressions werden einheitlich behandelt: Unit ist Statement ohne return value
  • basic Types
    • Byte..String
    • Unit: no value
    • Null empty reference
    • Nothing, Any, AnyRef
    • Tuples (a, "abc")._2
    • Arrays, 0-relativ, mit Parameter Types, aber mit Function Syntax: var a = new Array[String](3); a(1)="soLaLa" (eckige Klammern sind für typeParameters!)
    • Lists: Nil als leere Liste, A::x as append, x:::A als prepend
      • ranges 3 to 7
      • PatternMatching für Listen def r2(A:List[Int]) = A match {case Nil => List(-99);case x::Nil => List(x*x);case s => -98::s}
      • for mit Filtern for (e <- 2 to 22 if e %2==1; if e%3==0) println(e)
    • Map: val m = Map(1 -> "eins", 2 -> "zwei") , m(1) ⇒eins und (5) ⇒exception,
      • aber get braucht None und Some: m.get(1) ⇒Some(zwei) und m.get(5) ⇒None
  • packages können (wie in C#) geschachtelt werden
  • Patterns
    • case classes/Objects ==> mit entsprechendem Patternmatching in Verarbeitung 
      abstract class Nat 
case object Zero extends Nat
case class Succ(pre: Nat) extends Nat
def p2I(n: Nat) : Int = n match {    
     case Zero => 0                       
     case Succ(p) => 1 + p2I(p) }         
scala> p2I(Succ(Succ(Succ(Zero))))     
res67: Int = 3
    • Pattern Guards: case (x,_) if x>= 17 => ... und _ als Wildcard
    • sealed, Compiler macht Warning, wenn match nicht alle cases enthält
  • Polymorphismus
    • universal
      • parametrisch
      • inclusion (inheritance)
    • ad hoc
      • overloading (Richtigen Operator je nach OperandenTypen aussuchen)
      • coercion (implicit type conversion when needed) ==> implicit def ... um Implizite Konversion zu definieren, CompileFehler falls nicht eindeutig
  • implicit
    • Funktionen für implizite TypenKonversion wie oben
    • implizite Parameter dürfen weggelassen werden ==> sieht aus wie verschiedene Signaturen
  • Relatins between types
    • ≡ type equivalence
    • <: conformance relation (subtype <: supertype)
    • Co/Contra/variance annotions für type parameters: X[+COVAR, -CONTRA]: if COVAR' <: COVAR and CONTRA <: CONTRA' then X[COVAR', CONTRA'] <: X[COVAR, CONTRA]
    • damit können upper und lower bounds für Typen deklariert werden
  • Parser
    • in scala.util.parsing.combinator.Parsers sind viele Parser Konbinatoren definiert
  • XML kann direkt einer Variabeln zugewiesen werden oder seamless als tree verarbeitet werden
  • GUI via scala.swing
  • concurrent programming via java.lang.Runnable etc.
    • scala.concurrent enthält MailBox als oo Concurrent Konstrukt, Actors und vieles mehr