Scala en

“I can honestly say if someone had shown me the Programming in Scala book by Martin Odersky, Lex Spoon & Bill Venners back in 2003 I'd probably have never created Groovy.“JamesStrachan, Groovy creator

“No other language on the JVM seems as capable of being a "replacement for Java" as Scala, and the momentum behind Scala is now unquestionable.“CharlesNutter, JRubycoredeveloper

“Scala.“JamesGosling, Java creatorAnswer on a question, which language would he use now on JVM except Java.

“On my radar, the current best exit strategy for Java is Scala.„BruceEckel,author of many books

Scala vs JavaScala removesbreak, continue, gotostaticprimitive typesraw types (every type parameter „generics“ has to be stated)operators (all are methods)override is not more optional (when overriding in Scala one has to declare override)

Scala vs Ruby and GroovyScala has two type of fansJava programmers (pros of functional programming)Ruby programmers (pros of language with static typing)Implicits, structural typing and type inference, resembles work with language with dynamic typingScala is compiles a compiled language and all types are checked in compilation timeone can not call a non existing methodno ClassCastException in runtimepossibility to refactoras fast as Java

Why to unify FP and OOPBoth approaches are complementaryFunctionalObject-orientedAbstractionFunctionsHigher-order functionsParametric polymorphismExtending, state dependent behaviorInheritancePolymorphismEncapsulationDynamic configuration

Where?Manipulation of data structures collections, trees, ADTs, ...Internal/External DSLsOSGi, Apache Camel, scala-query, specs, built-in parserModular applicationsMixins, dependency injection, DCI (data, context & interaction)

How?Function as input argument

Pattern matching, case classes

ImplicitsManipulation of data structures collections, trees, ADTs, ...Internal/External DSLsOSGi, Apache Camel, scala-query, specs, built-in parserModular applicationsMixins, dependency injection, DCI (data, context & interaction)

Function as valueManipulation of data structuresCollectionsTreesDSL

Example - filteringJavapublic Collection<Ticket> approved(Collection<Ticket> tickets){ Collection<Ticket> result = new ArrayList<Ticket>();for(Ticket ticket : tickets){if(ticket.getState() == State.APPROVED)result.add(icket); }return result;}

Example - filteringJavapublicCollection<Ticket> approved(Collection<Ticket> tickets){Collection<Ticket> result = new ArrayList<Ticket>();for(Ticketticket: tickets){ filterif(ticket.getState()== State.APPROVED)result.add(ticket);}returnresult;}With what?What to do?How?

Yes, it can be done in JavaInterface for conditon... and the useFilter util methodpublicinterfaceICondition<T> {publicbooleancheck(T toBeChecked);}publicstatic <T> Collection<T> filter(Collection<T> ts, ICondition<T> c){Collection<T> result = new ArrayList<T>();for(T t : ts)if(c.check(t)) result.add(t);returnresult;}CollestionUtils.filter(verzie, new ICondition<Ticket>() { public boolean check(TickettoBeChecked) { return toBeChecked.getState() == State.APPROVED; }});

Example - filteringScaladefapproved(tickets: List[Ticket]) { tickets filter (_.getState() == State.APPROVED) }

WTF ?What type has the parameter in the function „filter“?List[+A]{deffilter (p : (A) => Boolean) : List[A] }Java : (A) => Booleanpublic interface Function1<O, I> { O apply(I input);}interface ICondition<I> extends IFunction1<Boolean, I> {}

Scala Listcount (p : (A) => Boolean) :Intexists (p : (A) => Boolean) : Booleanfilter (p : (A) => Boolean) : List[A] find (p : (A) => Boolean) : Option[A] foldLeft [B](z : B)(f : (B, A) => B) : Bforall (p : (A) => Boolean) : Booleanforeach (f : (A) => Unit) : Unitmap [B](f : (A) => B) : List[B] remove (p : (A) => Boolean) : List[A]

Scala ListMost of them is inherited from trait Iterable. So every collection, array has them, because they inherit from Iterable.Similar functions can be written for trees.count (p : (A) => Boolean) :Intexists (p : (A) => Boolean) : Booleanfilter (p : (A) => Boolean) : List[A] find (p : (A) => Boolean) : Option[A] foldLeft [B](z : B)(f : (B, A) => B) : Bforall (p : (A) => Boolean) : Booleanforeach (f : (A) => Unit) : Unitmap [B](f : (A) => B) : List[B] remove (p : (A) => Boolean) : List[A]

Function can be assigned to variablevarf : (String => Unit) = (x) => println(x)Function can be passed to another functiontickets filter (t => t.getState() == State.APPROVED)Return value from function can be a function defdeductKind = tax | insurance | retirementFunction is primitive type, basic building block, with the same importance as an integer or a string.If functions takes another function as an argument or if it returns a function, it is called a higher-order function.

ExamplesNumbers multiplied by twoEmployees to DTOsList(1, 2, 3, 4, 5) map { _ * 2 }> List[Int] = List(2, 4, 6, 8, 10)caseclassEmployee( varname : String)caseclass DTOEmployee( var name : String)deftoDto(e : Employee) = newDTOZamestnanec(z.meno)List(newEmployee(“John"), newEmployee(“Jack")) maptoDto> List[DTOEmployee] = List(DTOEmployee(John), DTOEmployee(Jack))

Type declarationIn Scala types are written after colonexists (p : (A) => Boolean) : Booleanvar age :Int= 24 val age = 33If type is unambiguous, it doesn’t have to be declaredReturn type of function existsArgument p is of type function from A to BooleanType of variableage

ValvsVar immutable (v Java it would be final) creates field and gettervalage:Int=22age = 33 //ERROR variable

creates field, getter and settervarage:Int=22age = 33

ListOperator :: is bound from rightval list1 = List("Programming", "Scala") val list2 = "People" :: "should" :: "read" :: list1val list2 = ("People" :: ("should" :: ("read" :: list1))) val list2 = list1.::("read").::("should").::("People")list2

MapState -> Capitalis mapped toState -> length of the capital namevalstateCapitals = Map("Alabama" -> "Montgomery", "Alaska" -> "Juneau", "Wyoming" -> "Cheyenne")vallengths = stateCapitalsmap { kv => (kv._1, kv._2.length)} println(lengths)> Map(Alabama -> 10, Alaska -> 6, Wyoming -> 8)

FoldLeftdeffoldLeft[B](z: B)(op: (B, A) => B): B = thismatch{caseNil => zcase x :: xs => (xsfoldLeftop(z, x))(op)}

FoldLeftList(1,2,3,4,5).foldLeft(10)(_ * _)(((((10 * 1) * 2) * 3) * 4) * 5)List(1,2,3,4,5).foldLeft(10)( (x, y) => x +y)(((((10 + 1) + 2) + 3) + 4) + 5)Shortcut for arguments of anonymous functions. First underscore means the first argument, second the second…

QuestionsHow would we write function “sum” with the help of foldLeft?defdistinct[A](l : List[A]) : List[A] = (l foldLeft List[A]()) {(res, a)=> if (!res.contains(a)) a :: reselseres}defsumInt(l : List[Int]) : Int = l.foldLeft(0)(_ + _)How would we write function “distinct“with the help of foldLeft? (Selects only distinct elements form the list.)

Every value is an objectEvery operator a methodfactorial(x - 1)factorial (x.-(1))map.containsKey(‘a’)map containsKey ‘a’There are no operators in Scala. Method names can contain some symbols.Every method can be called on the object without the dot and the brackets.

There are no operators in Scala. Method names can contain some symbols.trait Ordered[A] extendsjava.lang.Comparable[A] {def compare(that: A): Intdef < (that: A): Boolean = (this compare that) < 0def > (that: A): Boolean = (this compare that) > 0def <= (that: A): Boolean = (this compare that) <= 0def >= (that: A): Boolean = (this compare that) >= 0defcompareTo(that: A): Int = compare(that)}

“While” doesn’t have to be a keyword... But it is...defwhileAwesome(conditional: => Boolean)(f: => Unit) {if (conditional) { fwhileAwesome(conditional)(f) }}var count = 0whileAwesome(count < 5) {println("still awesome") count += 1}>stillawesomestillawesomestillawesomestillawesomestillawesomeConditionalis of type (=> Boolean) , so it is evaluated in the function “whileAwesome”If conditionalwas of typeBoolean, it would be evaluated before calling the function so the loop would never stop writing"still awesome"

It has many real life usestx{ valperson = new Person(id=null, name= "Ivanka"); manager.persist(person) }deftx(f: => Unit) = {manager.getTransaction().begin()try {txmanager.getTransaction().commit() } catch {casee: Exception => manager.getTransaction().rollback() }}

Functions are objects tootraitFunction1[-S, +T] {defapply(x: S):T}E.g. anonymous function (x: Int ) => x + 1 is translated by the compiler tonew Function1[Int, Int] { def apply(x: Int): Int = x + 1}

Functions are objects tooWhile (=>)is a class, it can be inherited from it.So we can specialize the concept of a function.Instead ofa(i) = a(i) + 2we can writea.update(i, a.apply(i) + 2)Array[T] is a function Int => T, so if such function is needed we can pass an Array[T]classArray[T] ( length: Int) extends(Int=> T) {deflength: Int= ...defapply(i: Int): T= ...defupdate(i: Int, x: T): Unit= ...defelements: Iterator[T] = ...defexists(p: T => Boolean):Boolean = ...}

CurryingPartial function application

CurryingFunction can return a functiondef cat(s1: String)(s2: String) = s1 + s2def cat(s1: String) = (s2: String) => s1 + s2cat("foo")("bar") > java.lang.String = foobarcat("foo") returns a function {(s2 : Int) => “foo” + s2}, to which is passed an argument "bar" Both notations are correct

Curryingdef cat(s1: String, s2: String) = s1 + s2> cat: (String,String) java.lang.StringvalcurryCat = Function.curried(cat _)> curryCat: (String) => (String) => java.lang.String= <function>cat("foo", "bar") == curryCat("foo")("bar")> res2: Boolean = trueFunction.curried() converts functions to their curried form

Partial function applicationval curryCat = Function.curried(cat _)> curryCat: (String) => (String) => java.lang.String= <function>val partialCurryCat = curryCat("foo")(_)> partialCurryCat: (String) => java.lang.String = <function>partialCurryCat("bar")> res3: java.lang.String = foobarPartial application= we didn’t passed all parameters

Partial function applicationIt is not needed to pass all parametersUses Curryingval numbers= List(1, 2, 3, 4, 5);println( numbers map ( 8 +))def plus(a : Int)(b : Int) : Int = a + bval plusFive = plus(5) _println( numbers map plusFive )f(A : a)(B : b) : Cf(B : b) : C

„There are two ways of constructing a software design. One way is to make it so simple that there are obviously no deficiencies. And the other way is to make it so complicated that there are no obvious deficiencies.”C.A.R. Hoare, author of Quicksort

Quicksortdef sort(xs: Array[Int]) {defswap(i: Int, j: Int) {val t = xs(i); xs(i) = xs(j); xs(j) = t}def sort1(l: Int, r: Int) {val pivot = xs((l + r) / 2)var i = l; var j = rwhile (i <= j) {while (xs(i) < pivot) i += 1while (xs(j) > pivot) j -= 1if (i <= j) {swap(i, j)i += 1j -= 1}}if (l < j) sort1(l, j)if (j < r) sort1(i, r)}sort1(0, xs.length 1)}FunctionalImperativedef sort(xs: Array[Int]): Array[Int] =if (xs.length <= 1) xselse {val pivot = xs(xs.length / 2)Array.concat( sort(xs filter (pivot >)),xs filter (pivot ==), sort(xs filter (pivot <)))}

ImplicitsOnly single implicit can be used (they can not chain)!println(intToPimpedInt(3).minutes())implicitdefintToPimpedInt(i : Int) = newPimpedInt(i)defmain(args: Array[String]) { 3 timesprintln("sdfs")println(5 minutes)}classPimpedInt(i : Int){deftimes(f : => Unit) : Unit = for(x <- 0 until i) fdefseconds = 1000 * idefminutes = 60 * seconds}intToPimpedInt(3).times(println("sdfs"))times(f : => Unit)seconds()minutes()

objectComplex {val i = newComplex(0, 1)implicitdef double2complex(x: Double) : Complex = newComplex(x, 0)}classComplex(valre: Double, val im: Double) {def + (that: Complex): Complex = new Complex(this.re + that.re, this.im + that.im)def - (that: Complex): Complex = new Complex(this.re - that.re, this.im - that.im)def * (that: Complex): Complex = new Complex(this.re * that.re - this.im * that.im,this.re * that.im + this.im * that.re)def / (that: Complex): Complex = { valdenom = that.re * that.re + that.im * that.imnew Complex((this.re * that.re + this.im * that.im) / denom, (this.im * that.re - this.re * that.im) / denom)}overridedeftoString = re+(if (im < 0) "-"+(-im) else"+"+im)+"*i"}By importing Complex one can use complex numbers like they were built in language feature.import pads.Complex._objectComplexTest {defmain(args: Array[String]) { val x : Complex = 4 + 3 * ival y : Complex = x * i println(y)}}

Structural typing“Type safe duck typing”

StructuraltypingclassEmployee {varmeno : String = null}classFirm {var title : String = nulldef name = "Firm is called " + title}Attribute nameMethod nameEmployee and Firm does not have a common supertype

Structural typingdefgetName(x : {val name : String}) : String = x.namedefsetName(x : {var name : String}) : Unit = x.name = "new name"val employee = new Employee()employee.name = “Kate"val firm = new Firm()firm.name = "PosAm"println (getName(employee))println (getName(firm))println (setName(employee))println (setName(firm)) //ERRORtype mismatch; found : firm.type (with underlying type pads.Firm) required: AnyRef{def name: String; defname_=(x$1: String): Unit}

DSL - domain specific languageImplicitsHigher order functionsOptional dots, semi-colons, parenthesesOperators like methodsCurrying

DSLExternal DSL + own language, freedom - need to write a parser - extensible from insideInternal DSL + extensible from outside, it’s just a library - syntax of a host languageParser library in Scala simplifies writing external DSLsImplicits, higher-order functions, optional dots and brackets, operator methods and currying simplifies writing of internal DSLs

External DSL written with the help of library scala.util.parsing.combinator._ /** @returnParser[Money] */defpercentage = toBe ~> doubleNumber <~ "percent" <~ "of" <~ "gross" ^^ {percentage => grossAmount * (percentage / 100.) }defamount = toBe ~> doubleNumber <~ "in" <~ "gross" <~ "currency" ^^ { Money(_) }deftoBe = "is" | "are"defdoubleNumber = floatingPointNumber ^^ { _.toDouble }|, ~> , <~, ^^ are just functionsLibrary pasing.combinator is internal DSL

^^ /** A parser combinator for function application * *<p>`p ^^ f' succeeds if `p' succeeds; it returns `f' applied to the result of `p'.</p> * * @param f a function that will be applied to this parser's result (see `map' in `ParseResult'). * @return a parser that has the same behaviour as the current parser, but whose result is * transformed by `f'. */def ^^ [U](f: T => U): Parser[U] = map(f).named(toString+"^^")

TraitMixinsDependency injection Data, context & interaction

TypesObject has only a single instance. One can obtain this instance by writing object’s name. It can be extended by the Traits.Class can inherit from one class but it can be extended by several Traits.Like an interface/abstract class.Can have an implementation.Can not have a constructor.ClassObjectTrait

Dependency injectionclassUserRepository{def authenticate(user: User): User = { println("authenticating user: " + user) user } def create(user: User) = println("creating user: " + user) def delete(user: User) = println("deleting user: " + user) } classUserService { def authenticate(username: String, password: String): User = userRepository.authenticate(username, password) def create(username: String, password: String) = userRepository.create(new User(username, password)) def delete(user: User) = All is statically typed. userRepository.delete(user) } UserService is dependent onUserRepository. It can have more implementations as well.UserRepository can have more implementations.

Cake PatterntraitUserRepositoryComponent{valuserRepository: UserRepositoryclassUserRepository { ... } } traitUserServiceComponent { this: UserRepositoryComponent => valuserService: UserServiceclassUserService { ... }}Classes are wrapped in components (traits), where its dependencies are declared.

Cake PatternobjectComponentRegistryextends UserServiceComponentwith UserRepositoryComponent{valuserRepository = newUserRepositoryvaluserService = newUserService}In the result object we set implementations of all necessary components. Every component uses right implementation on which it is dependent.

Pattern matchingMatching by valuesJava swicht-case analogyvalrandomInt = new Random().nextInt(10)randomIntmatch {case 7 => println( "lucky seven!" )caseotherNumber => println(„not seven "+ otherNumber)}

Pattern matchingMatching by typeval sundries = List(23, "Hello", 8.5, 'q')for (sundry <- sundries) { sundry match { casei: Int => println("got an Integer: " + i) case s: String => println("got a String: " + s) case f: Double => println("got a Double: " + f) case other => println("got something else: " + other) } }

Scala en

Related slideshows

More Related Content

Scala en