Higher-order operators. Higher-order operators. Scala. Higher-order operators. Java8. numerosi operatori higher-order sulle collezioni

Transcription

1 numerosi operatori higher-order sulle collezioni fold left /: fold right :\ filter partition find foreach takewhile dropwhile span (Splits into a prefix/suffix pair according to a predicate) forall exists (z /: List(a,b,c))(op) = op(op(z,a),b),c) def sum(xs:list[int]):int = (0/: xs) (_+_) def product(xs:list[int):int = (1/:xs)(_*_) > val words = List( the, quick, brown, fox ) res: List[java.lang.String] = List(the,quick,brown,fox) String => Int > words map (_.length) res: List[Int] = List(3,5,5,3) > words map (_.tolist) res: List[List[Char]] = List(List(t,h,e),List(q,u,i,c,k), List(b,r,o,w,n),List(f,o,x)) > words flatmap(_.tolist) res: List[Char] = List(t,h,e,q,u,i,c,k,b,r,o,w,n,f,o,x) Scala > map(f:a val words => = B) List( the, quick, brown, fox ) trasforma List[A] in List[B] res: List[java.lang.String] = List(the,quick,brown,fox) String => Int > words map (_.length) res: List[Int] = List(3,5,5,3) > words map (_.tolist) res: List[List[Char]] = List(List(t,h,e),List(q,u,i,c,k), List(b,r,o,w,n),List(f,o,x)) > words flatmap(_.tolist) res: List[Char] = List(t,h,e,q,u,i,c,k,b,r,o,w,n,f,o,x) map(f:a => B) trasforma List[A] in List[B] flatmap(f:a => List[B]) trasforma List[A] in List[B], Java8 in classe Stream<A>: Function<? super A,? extends B> Stream<B> map (Function<A,B> lambdaexpr) Stream<B> flatmap (Function<A,Stream<B>> lambdaexpr) flatmap(f:a => List[B]) trasforma List[A] in List[B] un unica lista che concatena tutti i risultati di f Function<? super A,? extends Stream<? extends B>

2 [1,2,3,4] > List.range(1,5) flatmap ( i => List.range(1,i) map (j => (j,i)) ) res:list[(int,int)]=list((1,2),(1,3),(2,3),(1,4),(2,4),(3,4)) flatmap vs for case class Person(name: String, ismale: Boolean, children: Person*) val lara = Person( Lara,false) val bob = Person( Bob,true) val julie = Person( Julie,false,lara,bob) val persons = List(lara,bob,julie) si ottiene la stessa cosa con for(i <- List.range(1,5); j <- List.range(1,i)) yield (j,i) for { i <- List.range(1,5) j <- List.range(1,i) yield (j,i) persons filter (p =>!p.ismale) flatmap (p => (p.children map (c => (p.name, c.name)))) //oppure for (p <- persons ; if p!p.ismale ; c <- p.children) compilato in yield (p.name, c.name) res:list[(string,string)] = List((Julie,Lara),(Julie,Bob)) for expressions for ( seq ) yield expr for! map,flatmap,filter for (x <- expr1) yield expr2 expr1.map(x => expr2) sequence of generators, definitions and filters with ; between them (or without it if using for{ yield ) for (p<-persons; n=p.name; if (n startswith To )) yield n for (x <- expr1 if expr2) yield expr3 is a for-expression since it returns a value expr1 filter(x => expr2) map(x => expr3) oppure for { p <- persons n = p.name if (n startswith To ) yield n for (x <- expr1; y <- expr2) yield expr3 for (x <- expr1) body expr1 flatmap(x => expr2 map(y => expr3)) is a for-loop since it just performs side-effects expr1 foreach ( x => body )

3 generalizing for for -> map,flatmap,filter the translajon of for-expr. happens before type checking, therefore it is only required that the result of the expansion type checks; there are no typing rules for the for construct! thanks to this translajon for expressions can be applied to any class of data that supports map, flatmap and filter (e.g. lists and arrays) for loops can be applied to any class of data that supports (also) foreach (e.g. lists and arrays) if a (user-defined) datatype defines a subset of these methods, then it sjll supports a subset of all possible for expressions or loops generalizing for abstract class M[A] { def map[b](f: A => B): M[B] def flatmap[b](f: A => M[B]): M[B] def filter(p: A => Boolean): M[A] def foreach(b: A => Unit): Unit unit func<on : A => M[A] return in Haskell, costrusore in Scala binding opera<on : M[A] => (A => M[B]) => M[B] >>= in Haskell, flatmap in Scala then opera<on : M[A] => (A => B) => M[B] >> in Haskell, map in Scala definibile in termini di unit f. e binding op. do-na<on in Haskell corrisponde a for-expressions in Scala together with a constructor or a factory method A => M[A] gives a MONAD (in OOP style) a Monad is a class of types (like a CollecJon is a class of types) OpJon Types e monadi Da API di Option[T]: they represent optional values. Instances of Option are either an instance :Option[String] of scala.some or the object None. val namemaybe = request getparameter "name" namemaybe match { case Some(name) => println(name.trim.touppercase) case None => println("no name value") val name = request getparameter "name" less-idiomatic most idiomatic val upper = name map { _.trim filter { _.length!= 0 map { _.touppercase println(upper getorelse "") OpJon Types e monadi Da API di Option[T]: they represent optional values. Instances of Option are either an instance :Option[String] of scala.some or the object None. val namemaybe = request getparameter "name" namemaybe match { case Some(name) => println(name.trim.touppercase) case None => println("no name value") if None is returned from getparameter, the entire expression results in None. This allows for sophisticated chaining of scala.option values without having to check for the existence of a value. val name = request getparameter "name" less-idiomatic most idiomatic val upper = name map { _.trim filter { _.length!= 0 map { _.touppercase println(upper getorelse "") treat it as a collection or monad and use map,flatmap, filter, or foreach: treat it as a collection or monad and use map,flatmap, filter, or foreach:

4 OpJon Types e monadi val namemaybe = request getparameter "name" most idiomatic val upper = namemaybe map { _.trim filter { _.length!=0 map { _.touppercase println(upper getorelse "") this is equivalent to val upper = for { name <- request getparameter "name" trimmed <- Some(name.trim) upper <- Some(trimmed.toUpperCase) if trimmed.length!= 0 yield upper println(upper getorelse " ) if None is returned from getparameter, the entire expression results in None. This allows for sophisticated chaining of scala.option values without having to check for the existence of a value. OpJon Types e monadi nella classe Option[A] sono definij final def filter(p:a => Boolean) : Option[A] returns this OpJon if it is nonempty and applying the predicate p to this OpJon s value returns true. Otherwise, return None final def map[b](f:a => B):Option[B] returns a Some containing the result of applying f to this OpJon s value if this OpJon is nonempty. Otherwise return None final def flatmap[b](f:a => Option[B]):Option[B] returns the result of applying f to this OpJon s value if this OpJon is nonempty. Returns None if this Op2on is empty. Slightly different from map in that f is expected to return an OpJon (which could be None) Try[T] Try[T] val x = obj.m1() val y = obj.m2(x) def m1():t =... def m2(x:t):s=... val x = obj.m1() val y = obj.m2(x) def m1():t =... def m2(x:t):s=... semplice ma m1 e m2 possono sollevare eccezioni def m1():try[t] =... def m2(x:t):try[s]=... Try[T] e il tipo di una computazione che può fallire Espone la possibilità di fallire a livello dei tipi abstract class Try[+T] case class Success[T](x:T) extends Try[T] case class Failure(ex:Exception) extends Try[Nothing] serious system errors are thrown as usual def m1():try[t] =... def m2(x:t):try[s]=... val x:try[t] = obj.m1() val y = obj.m2(x) NON COMPILA val x:try[t]= obj.m1() val y:try[s]= x flatmap ( _ => obj.m2(_)) Try[T] e una monade: ha definij i metodi map e flatmap

5 val x = obj.m1() val y = obj.m2(x) Try[T] codice orientato alla programmazione Fault Tolerant def m1():t =... def m2(x:t):s=... def m1():try[t] =... def m2(x:t):try[s]=... :Future[T] :T val x = future { someexpensivecomputation() val y = future { someotherexpensivecomputation() val z = for (a <- x; b <- y) yield a*b for (c <- z) println("result: " + c) println("meanwhile, the main thread goes on!") val x:try[t] = obj.m1() val y = obj.m2(x) NON COMPILA someexpensivecomp a*b val y:try[s]= for ( x <- obj.m1() y <- obj.m2(x) ) yield y NOTA: se m1 o m2 ritorna Failure, allora y ha valore Failure senza bisogno di fare il check a mano someotherexpensivecomp print( Meanwhile... ) print( Result +c) preparazione di cappuccino macinare i grani di caffè bollire l acqua fare il caffè fare la schiuma di latte preparazione di cappuccino macinare i grani di caffè bollire l acqua fare il caffè fare la schiuma di latte combinare caffè e schiuma di latte combinare caffè e schiuma di latte

6 type GraniCaffe = String type PolvereCaffe = String type Latte = String type Schiuma = String type Espresso = String type Cappuccino = String case class Acqua(temp:Int) def macina(grani:granicaffe):try[polverecaffe] =... def bollire(acqua:acqua): Acqua = def preparacappuccseqentially(): Try[Cappuccino] = for( m <- macina( arabica ) a <- bollire(acqua(25)) s <- faischiuma( latte ) ) yield mescola(e,s) Tipo di computazione che può fallire for-expr. che gestisce il caso Failure def macina(grani:granicaffe): Try[PolvereCaffe] = { println( inizia a macinare ) if(grani== orzo ) throw MacinaException( scherziamo? ) println( finito di macinare ) polvere di +grani def bollire(acqua:acqua): Acqua = { println( scalda acqua ) println( bolle! ) acqua.copy(temp = 85) def macina(grani:granicaffe): Future[PolvereCaffe] = Future { println( inizia a macinare ) if(grani== orzo ) throw MacinaException( scherziamo? ) println( finito di macinare ) polvere di +grani def bollire(acqua:acqua): Future[Acqua] = Future { println( scalda acqua ) println( bolle! ) acqua.copy(temp = 85) def preparacappucc(): Future[Cappuccino] = val macina = macina( arabica ) val acquacalda = bollire(acqua(25)) val schiuma = faischiuma( latte ) restituiscono subito un Future, che sarà completato asincronamente def preparacappuccseqentially(): Try[Cappuccino] = for( m <- macina( arabica ) a <- bollire(acqua(25)) s <- faischiuma( latte ) ) yield mescola(e,s) def preparacappucc(): Future[Cappuccino] = val macina = macina( arabica ) val acquacalda = bollire(acqua(25)) val schiuma = faischiuma( latte ) for( m <- macina a <- acquacalda s <- schiuma ) yield mescola(e,s) for( m <- macina a <- acquacalda s <- schiuma ) yield mescola(e,s)