Scala jargon cheatsheet

SCALA FUNDAMENTALS JARGON DICTIONARY

(ADT, TYPECLASSES, EXTENSION METHODS, CAKE, ETC …. )

// Ruslan Shevchenko

Legend:

— you start to learn scala and found a dozen of new words.

ADTGADT

typeclasses

existential typesPattern-matching

Call by {name, value}

Legend:

— words, idioms, …

— let’s made cheatsheet

ADT = { Algebraic Data Types }ADT = { Abstract Data Types } (not SCALA)

— in context:

Algol 60

Simula

CLUAlgol 68

Scala

LISP

Flavours

ML

ADT = { Algebraic Data Types }ADT = { Abstract Data Types } (not SCALA)

Pattern MatchingNominative types, Structured TypesGeneric = (Parameter Polymorphism)

Existential typesType aliases F-Bounded Polymorphism

Traits = (mixins, flavors)

typeclasses = (typeclasses, concepts )implicit.

extension methods.

ADT = { Abstract Data Types } (not SCALA)

CLU (1970, MIT)

"An abstract data type defines a class of abstract objects which is completely characterized by the operations available on those objects. This means that an abstract data type can be defined by defining the characterizing operations for that type." // 1974, ACM Sigplan, Congress of very hight-level languages.

From today-s point of view: Interface

cluster stack[t] is create push pop isEmpty %rep struct { arr: array[t] idx: Int } create = proc() returns(cvt) …. push = proc(x:t) signal(overflow)

trait Stack[T] { def push(x:T): Unit ……. }

Barbara Leskov

ADT = { Algebraic Data Type }

HOPE (1970, Edinburg)From today-s point of view: ADT ;)

data list alpha = nil ++ alpha :: list alpha

(A, B) == Pair[A,B] (A+B) == emulated by sealed trait (a:A,b:B)== case classes.

A | B ~~ partially emulated by traits (will be implemented in dotty)

A & B ~~ partially emulated by A with B (will be implemented in dotty)

A => B == Function[A,B]

Rod Burstall David MacQueen

Some initial set of types: A, B, C, ….

Operations on types: Pair [A*B] records (set of name-value-pairs) discriminated unions (one of A or B)

functions: A=>B// often (incorrectly): discr. union == ADT

Equality by value

ADT = { Algebraic Data Type }

data X = A ++ B data A = ‘A#integer#integer data B = ‘B#string

(a:A,b:B)== case classes [or objects].

sealed trait X case class A(x:Int,y:Int) extends X case class B(s:String) extends X

discriminated unions (one of A or B)

// often (incorrectly): discr. union == ADT

A+B

A+0

B+0

BOOL

BOOL

isAisB

Pattern Matching

HOPE (1970, Edinburg)data list alpha = nil ++ alpha::list alpha

sealed trait List[+A]

class Nil extends List[Nothing] class Cons[A](head:A, tail:List[A]) extends List[A]

Rod Burstall David MacQueen

dec length: list(alpha) -> int — length nil <= 0 — length (a::l) <= length(l) + 1

def length[A](l: List[A]): Int = l match { case Nil => 0 case Cons(head,tail) => 1+length(tail) }

Pattern Matching

SCALA data list alpha = nil

++ alpha::list alphasealed trait List[+A]



def length[A](l: List[A]): Int = l match { case Nil => 0 case Cons(head,tail) => 1+length(tail) }

Pattern Matching

SCALA data list alpha = nil

++ alpha::list alphasealed trait List[+A]



def length[A](l: List[A]): Int = l match { case Nil => 0 case head :: tail => 1+length(tail) }

Pattern Matching

Why Pattern Matching is better than sequence of IF-s ?

- Binding. (i.e. information from structure is extracted into variables)

We have not only algebraic, but object-oriented types.- Views. (bridge, which represent object as algebraic type). Wadler, 1984

- Pattern objects. (Pattern-object method call return algebraic type) - ODersky, 2006

- Exhaustive checking (if we miss something then we will see this)

x match { case A(x,y) => y1 …. }

We have not only algebraic, but object-oriented types.

Pattern-Object

object A { def unapply(x: X): Option[(A,B)] }

extractor

Regular expressions:final val StackElement = “""\W+([^)]+)$([^:]*):([^)]*)$\W*""".r

line match { case StackElement(class,file,lineno) => …. …. }

sealed trait Option[+A]

case class Some[A](a:A) extends Option[A] case object None extends Option[Nothing]

val fac: Int => Int = { case 0 => 1 case n => n*fac(n-1) }

Partial functions syntax: object Succ { def unapply(n: Int):Option[Int] = if (n==0) None else Some(n-1) }

{ case (x,y) => (y,x) }

val positiveOne: Int => Int = { case Succ(n) => 1 }

positiveOne.isDefinedAt(0) false

positiveOne.isDefinedAt(3) true

Partial functions:val positiveOne: Int => Int = { case Succ(n) => 1 }

positiveOne.isDefinedAt(0) false

positiveOne.isDefinedAt(3) true

PartialFunction[A,B]

B

BooleanA

apply

isDefinedAt

Types: A <: B

Nominative typing (type == name)

{ def x:Int ; def y: Int } val a = A(1,2) val b = new B(1,2)

f(a) ==> 3 f(b) ==> 3

Structured typing (type == structure)

case class A(x: Int, y: Int)

class B(x: Int, y: Int) A != B

- Effective implementation in JVM - Simula, Clu, C++, Java, …..

~ (A <: B) ~ (B <: A)

def f(p: { def x:Int ; def y: Int }):Int = p.x + p.y

- implementation in JVM require reflection (can be better) - ML, OCaml, Go - theoretically have less corner cases than nominative

Refined type

Generics [Parametric Polymorphism]

B { def z: Int }

F[T]

- Structured type, based on nominative. - Scala: structured types are refinement of AnyRef

Existential types: F[_] F[X] for Some X

Bounded type parameters:

Type aliases

F[T <: Closeable]F[T <: { def close(): Unit }]

trait Expression[A] { type Value = A }

trait Expression { type Value <: X }

Undefined type alias

Scolem type

//CLU where

Traits:trait Interpeter { type Value }

trait BaseInterpreter[A] extends Additive with Multiplicative with Show { type Value = A }

Flavours (Flavours, [LISP dialects]) 1980, MIT

Mixing

trait Show { this: Interpreter => def show }

trait Additive { this: Interpreter => def plus(x:Value, y:Value): Value }

// Howard Cannon, David Moor

(CLOS, OCaml, Groovy, Python ..)

Traits:

trait LoggedInterpreter[A] extends BaseInterpreter[A] with Logged with LoggedAdditive

trait LoggedAdditive extends Additive { this => Logged def plus(x:Value, y: Value) : Value = { log(s”(${x}+${y}”) super.plus(x,y) } }

trait Additive { this: Interpreter => def plus(x:Value, y:Value): Value }

// AOP (aspect oriented programming)

// Flavours : around : before-next : after-next

Type classes.

class Eq a where == :: a -> a -> Bool /= :: a -> a -> Bool

class (Eq a) => Ord a where compare :: a->a->Int

instance Ord Int where compare x y = (x-y)

//addition to Haskell, Wadler, 1988Constructor classes (type classes with multiple type parameters).

//addition to Haskell, Jone, 1993

instance (Eq a) (Eq b) => Eq(Pair a b) where == (Pair x y) (Pair z w) = x == z and y == w

classes = rules; instances = adaptors to this rules

Type classes.

trait Eq[A] { def === (x:A, y:A):Boolean def !== (x:A, y:A):Boolean = !(x===y) }

trait Ord[A] extends Eq[A] { def compare :: a->a->Int

override def ===(x:A, y:A):Boolean = (compare(x,y)==0) }

implicit val intOrd: Ord[Int] = new Ord[Int] { def compare(x:Int, y:Int) = (x-y) }

//in scala as design pattern (implicit) & one word

implicit def pairEq[A,B]: Eq[Pair[A,B]] ( implicit eqA:Eq[A], eqB:Eq[B]) = { def ===(x: Pair[A,B],y:Pair[A,B]):Boolean= eqA(x._1,y._1) && eqB(x._1, y._1) }

implicit (val, def, classes )

- define rules of your world - can be usable via implicit parameters - implicit search <=> logical deduction - can be dangerous.

implicit def stringToInt(s:String):Int = s.toInt

def f(x:Int):Int = x+1

f(“45”)

implicit (val, def, classes )

- define rules of your world - can be usable via implicit parameters - implicit search <=> logical deduction - can be dangerous.

implicit def toJson(x:Int): Json = JsonNumeric(10)

def printAsJson[A](x:A)(implicit convert:A=>Json): String = convert(x).prettyPrint

Type classes.//Libraries: universal rules (like ontologies in philosophy)

scalaz : https://github.com/scalaz/scalaz spire/algebra: https://github.com/non/algebra

(now - part of cats)

//Potenial problem: premature abstraction

// Human is an upright, featherless, ripped with broad, flat nails

+Z / 10^64 Z << BigInt

Z{ |x| < 10^32} <<ERROR

https://github.com/scalaz/scalaz

https://github.com/non/algebra

Extension methods.//implicit-based technique (pimp my library pattern [obsolete name])

implicit class WithPow(x: Int) { def pow(y: Int): Int = Math.pow(x,y).toInt }

scala> 2 pow 3 scala> res1: Int = 8

• pow — Int have no pow method • => compiler search for implicit with pow

Scala types.//whats-left for advanced talks:

42.type

Dynamic

// Homework:

Path dependency issues.

What’s left out of scala type system (?)

Call by ……….

Value.

Reference:

Name

Need

// value is copied.

// reference is copied by value. // reference in language must exists

// Algol 68 (today - call by closure)

// lazy one-time evaluation

Call by ……….

Name // Algol 68 (today - call by closure)

def doWhile(x: => Boolean)(f : =>Unit) { while(x) { f } }

doWhile(x < 10)(x = x + 1)

Call by ……….

Need

def dupN[A](n: Int, v : =>A): Seq[A] = { lazy val neededV = v for( i <- 1 to N) yield v }

Scala.

Scala / Dotty : like grand unification theory for large subset of type theories.

Mathematical jargon hide quite simple patterns.

Questions ?

// [email protected]

mailto:[email protected]

Scala jargon cheatsheet

Software

Transcript of Scala jargon cheatsheet