Mai temak

Kikerult feature-ok

Csendes szintaxis

Implicitek ujragondolasa

Tipuslambdak

Union es intersection tipusok

Opaque tipusok

Generikus tuple-ok

Trait parameterek

Fuggvenytipusok tovabbfejlesztese

Enumok

Egyeb

Kikerult feature-ok

DelayedInit

Macrok (ujrairjak oket)

Egzisztencialis tipusok

Tipusprojekciok

Do-While

Procedura szintaxis

Package Objectek

Early Initializer

Class Shadowing

XML literalok

Symbol Literalok

Auto-applikacio

Gyenge kikovetkeztetes

Nemlokalis return

[this]

Csendes szintaxis

Control statementek korul elhagyhatoak a ()-k es a {}-k

if x < 0 then
   "negative"
else if x == 0 then
   "zero"
else
   "positive"

if x < 0 then -x else x

while x >= 0 do x = f(x)

for x <- xs if x > 0
yield x * x

for
   x <- xs
   y <- ys
do
   println(x + y)

try body
catch case ex: IOException => handle

Implicitek ujragondolasa

A Scala 2 implicitjei nagyon hatasosak, de bonyolultak voltak

A legtobb direktben hasznalt feature-t szetbontjak, es sepcializaljak

Using: a hivo oldalon meghatarozott informacio tovabbpasszolasa implicit modon

Given: tipusosztaly peldany meghatarozasara. Egy scope-on belule egy kanonikus ertek hasznalata egy tipusra

Extension methods: a regi implicit konverzio helyett egy "ad-hoc" bovites

Konverzio: a scala.Conversion osztaly peldanyai

Context function: fuggvenytipusok csak context parameterekkel (?=>)

Hianyzo implicit elem eseten a compiler probal sgiteni: import ajanlasok

Tipuslambdak

A koncepcio ugyanaz, mint a fuggvenylambdaknal

// Tipus curry-zese
({ type T[A] = Map[Int, A] })#T
// helyett:
[A] =>> Map[Int, A]

Union es intersection tipusok

Union: nem diszjunkt unio (mint pl. Either)

val a: A | B = new A()
val b: A | B = new B()

Union: kommutativ

Intersection: Union parja

val a: A & B = new A() with B

Intersection: nem kommutativ (A & B != B & A)

Opaque tipusok

Type alias eddig is letezett

type Age = Double

Ez tenyleg csak alias: eredeti tipust lehet hasznalni

opaque type Age = Double

A ket tipus nem egyezik meg => compile error

Generikus tuple-ok

Eddig: tuple implementacio: Tuple<1..22> osztalyok

Mostantol: Shapeless HList-szeru tuple-ok

(a, (b, (c, ())))

Trait parameterek

A traitek is kaphatnak parametereket

trait Foo(val s: String) {
  ...
}

Csak osztalyok passzolhatnak nekik erteket

Diamond-oroklodes: compile error

Fuggvenytipusok tovabbfejlesztese

Dependent tipusok

val fooFunction: (a: A) => a.Foo = ...

Polimorfikus tipusok

[A] => List[A] => List[A]

Implicit tipusok

type MyFunction[B] = implicit A => B
def foo(f: Foo)(implicit a: A): B = ...

Nem implicitkonverzio

Enumok

Java-s enumokhoz hasonlo

enum Weekday(val index: Int) {   
private def next(i: Int) = (i + 1) % 7
private def prev(i: Int) = (i + 7) - 1 % 7  

def nextDay = Weekday.enumValue(next(index))  
def prevDay = Weekday.enumValue(prev(index))  

case Mon   extends Weekday(0)
case Tue   extends Weekday(1)
  ...
}

Egyeb

Null-safety: Foo | null

Egyenloseg tipusbiztos ("123" == 123 compile error)

open class: egy osztaly kibovitesre tervezve

Transparent traitek: traitek, amiket csak mas tipusok mixelnek

Export clause: osztalypeldanyok metodusainak lathatova tetele (kompozicio elosegitese)

Inline: ertekek es fuggvenyek