Functional Scala II (in practice)

Functional Scaλa

… in Practice

20.10.2010
Java User Group Frankfurt / Main
Mario Gleichmann

Mario Gleichmann JUG Frankfurt / Main

Introduction

Mario Gleichmann

site: www.mg-informatik.de

blog: 'brain driven development'
gleichmann.wordpress.com

mail: mario.gleichmann@mg-informatik.de

Mario Gleichmann 2 JUG Frankfurt / Main

Summary


What is Functional Programming ?

Functional Style

val sum = fold( 1 to 10, add )

Expression based

Computation method is function application

Mario Gleichmann 4 fcn JUG Frankfurt / Main

What makes a Function ?

Function Types

val add = ( x :Int, y :Int ) => x + y

Type of add : ( Int , Int ) => Int

Mario Gleichmann 5 Obj JUG Frankfurt / Main

Closures

'closing over'
var limit = 18

val isAdult = ( age :Int ) => age >= limit

'Closed term'

Mario Gleichmann 6 appl JUG Frankfurt / Main

Algebraic Datatypes

Example - Tree

data Tree = Empty | Leaf Int | Node Int Tree Tree

abstract case class Tree()
case object Empty extends Tree
case class Leaf( value: Int ) extends Tree
case class Node( value: Int, left :Tree, right: Tree ) extends Tree

Mario Gleichmann 7 insrt JUG Frankfurt / Main

Pattern Matching

val depth :Tree => Int = _ match {

case Empty => 0

case Leaf( _ ) => 1

case Node( _, left, right ) => 1 + max( depth( left ), depth( right ) )
}

Mario Gleichmann 8 Prt isb JUG Frankfurt / Main

Partial Functions

type =>?[-A, +B] = PartialFunction[A, B]

val publisherRegionDE : Isbn =>? String = {

case Isbn( 3, pubNr, _ ) => "D" + ( pubNr.toString charAt 0 )
}

…

publisherRegionDE.isDefinedAt( Isbn( 0, 677873, 8823 ) ) )

>> false

Mario Gleichmann 9 chn JUG Frankfurt / Main

Comprehensions

val factors = ( n :Int ) => for( x <- ( 1 to n ) if n % x == 0 ) yield x

...

val prime = ( n :Int ) => factors( n ).toList == List( 1, n )

…

val primes = (n :Int) => for( x <- (1 to n) if prime( x ) ) yield x

Mario Gleichmann 10 Hgh rdr Fcn JUG Frankfurt / Main

Higher Order Functions

val filter = ( predicate: Int => Boolean , xs :List[Int] ) => {

for( x <- xs; if predicate( x ) ) yield x
}

Mario Gleichmann 11 Fcn Tp JUG Frankfurt / Main

Lambda Expressions

filter( num => num % 2 == 0, List( 1, 2, 3, 4, 5, 6 ) )

…

filter( _ > 0, List( -1, 5, 0, -3, 7 ) )

Mario Gleichmann 12 fst arg JUG Frankfurt / Main

Partial Application


Partial Application

val isPrime = (x :Int) => ( 2 to x/2 ).forall( x % _ != 0 )

Type of isPrime: Int => Boolean

Mario Gleichmann 14 def prms wthn JUG Frankfurt / Main

Partial Application

Delegation


val primesWithin = ( xs :List[Int] ) => filter( isPrime , xs )

Type of filter: ( Int => Boolean, List[Int] ) => List[Int]

Mario Gleichmann 15 fxd var JUG Frankfurt / Main

Partial Application

Delegation


val primesWithin = ( xs :List[Int] ) => filter( isPrime , xs )

fixed variable

Mario Gleichmann 16 appl nappl JUG Frankfurt / Main

Partial Application

New from Old ...


val primesWithin = filter( isPrime, _ :List[Int] )

applied unapplied


Partial Application

New from Old ...


val primesWithin = filter( isPrime, _ :List[Int] )

Type of primesWithin: List[Int] => List[Int]

Mario Gleichmann 18 Crrng JUG Frankfurt / Main

Currying


Currying

val filter = ( pred: Int => Boolean , xs :List[Int] ) => {
for( x <- xs; if pred( x ) ) yield x
}

Type of filter: ( Int => Boolean , List[Int] ) => List[Int]

Mario Gleichmann 20 Crrd fcn JUG Frankfurt / Main

Currying

'Higher Order Lambda Closures' ...

val filter = ( pred: Int => Boolean ) => ( xs :List[Int] ) => {
}

Mario Gleichmann 21 Crrd fcn Tp JUG Frankfurt / Main

Currying


}

Type of filter: ( Int => Boolean ) => ( List[Int] ) => List[Int]

Mario Gleichmann 22 sngl arg JUG Frankfurt / Main

Currying


}

Curried Function
Curried Function

Mario Gleichmann 23 sngl
xpln arg JUG Frankfurt / Main

Currying


}

... accepting one ... resulting in another
A function
(Function) Arg function

Mario Gleichmann 24 lmbd xpr JUG Frankfurt / Main

Currying



}

Type of filter: ( Int => Boolean ) => List[Int] => List[Int]

... is defined as a Lambda expession

Mario Gleichmann 25 cls ovr JUG Frankfurt / Main

Currying



}

Type of filter: ( Int => Boolean ) => List[Int] => List[Int]

... closes over to Arguments (Scope)
of surrounding Function 'filter'

Mario Gleichmann 26 Smp prms wthn JUG Frankfurt / Main

Example 1 – Extract primes


}

val primesWithin = filter( isPrime )




}


Type of primesWithin: List[Int] => List[Int]




}


...
primesWithin( List( 3, 4, 5, 6, 7 ) ) >> List( 3, 5, 7 )

Mario Gleichmann 29 Smp rc mgmt JUG Frankfurt / Main

Example 2 – Ressource Management
val initQuery =
(dataSource :DataSource) => (query :String) => ( extractor :ResultSet => Unit ) => {

try{
val conn = dataSource.getConnection
val stmt = conn.createStatement
val resultSet = stmt.executeQuery( query )
extractor( resultSet )
}
finally{
try{
if( conn != null ) conn.close
}
finally{
if( stmt != null ) stmt.close
}
}
}


Example 2 – Ressource Management
val dataSource :DataSource = ...;

...
val query = initQuery( dataSource )

…

query( "select * from User where age > 18" ) { result :ResultSet =>
while( result.next ) { .... }
}

…

query( "select * from Account where balance < 1000" ) { result :ResultSet =>
while( result.next ) { .... }
}

Mario Gleichmann 31 smmy JUG Frankfurt / Main

Combinators


Combinators

val power : Int => Int => Int =

( base :Int ) => ( exp :Int ) =>

if( exp == 1 ) base else base * power( base )( exp - 1 )

...

val square = power( _ :Int )( 2 )


Combinators




...


Type of square : Int => Int


Combinators




...


Partial Application 'in the middle'


Combinators

def flipArgs [A, B, C] ( f: A => B => C ) : B => A => C =

( x: B ) => ( y: A ) => f (y) (x)

Transforms to another Function,
expecting arguments in reversed order


Combinators

def flipArgs [A, B, C] ( f: A => B => C ) : B => A => C =

( x: B ) => ( y: A ) => f (y) (x)

…

val square = flipArgs( power )( 2 )

… now just exploit Currying


Combinators

Function Composition

f :: B => C

g :: A => B

x ∈ A

( f o g )( x ) = f ( g ( x ) )
( f o g ) :: A => C


Combinators : Function Composition

def o [A,B,C] ( f: B => C ) ( g: A => B ) : A => C =
( x :A ) => f( g( x ) )

...
val mult = ( x :Int ) => ( y: Int ) => x * y
val add = ( x :Int ) => ( y: Int ) => x + y

...
val doubleSucc = o ( mult(2) ) ( add(1) )

Type of doubleSucc : Int => Int



( x :A ) => f( g( x ) )

...

...

doubleSucc( 7 )

>> 16



( x :A ) => f( g( x ) )

...

...

doubleSucc( 7 )
Postfix ...
>> 16



class RichFunc [B, C] ( f: B => C ) {
def o[A] ( g: A => B ) = (x :A) => f( g( x ) )
}

implicit def toRichFunc[B,C]( f: B => C ) = new RichFunc( f )

...
val doubleSucc = mult(2) o add(1)

doubleSucc( 7 ) Infix !!!

>> 16



class RichFunc [B, C] ( f: B => C ) {
def o[A] ( g: A => B ) = (x :A) => f( g( x ) )
}

implicit def toRichFunc[B,C]( f: B => C ) = new RichFunc( f )

...
val doubleSucc = mult(2) o add(1)

doubleSucc( 7 ) 'Point free style' of function definition

>> 16


Example: Word Counter

Count all even words within a sentence:

“Hello World“ → 0

“The fox jumps over the lazy dog“ → 2

"This sentence contains five even words" → 5



Count all even words within a sentence:

“Hello World“ → 0

“The fox jumps over the lazy dog“ → 2

"This sentence contains five even words" → 5

Basic Functions:

parse Words → Word to length → filter even → count



Basic Functions

val words = ( sentence : String ) => sentence.split( " " ).toList

val length = ( ws :List[String] ) => for( w <- ws ) yield w.length

val filter = ( predicate: Int => Boolean ) => ( xs :List[Int] ) => ...

val even = ( i :Int ) => i % 2 == 0

val size = ( xs :List[ _ ] ) => xs.size






val even = ( i :Int ) => i % 2 == 0


val evenWordCount = size o filter( even ) o length o words

Type of evenWordCount : String => Int






val even = ( i :Int ) => i % 2 == 0


vs.
val evenWordCount = (sentence :String ) =>
size ( filter( even ) ( length( words( sentence ) ) ) )





val even = ( i :Int ) => i % 2 == 0



evenWordCount( "this sentence contains five even words" )
>> 5

Fundamental Functions



def sum ( list : List[Int] ) : Int = list match {

case Nil => 0

case x :: xs => x + sum( xs )
}



def product ( list : List[Int] ) : Int = list match {

case Nil => 1

case x :: xs => x * product( xs )
}



def allTrue ( ys : List[Boolean] ) : Boolean = ys match {

case Nil => true

case x :: xs => x and allTrue( xs )
}


Fundamental Functions : reduce

def reduce ( list : List[ T ] ) : R = list match {

case Nil => ?
case x :: xs => x ʘ reduce( xs )
}



def reduce ( list : List[ T ] ) : R = list match {

case Nil => ? 'unit'

case x :: xs => x ʘ reduce( xs )
}
'subsuming operation'



def reduce[T,R] ( fun : T => R => R ) ( unit : R ) ( list : List[T] ) : R =
list match {

case Nil => unit

case x :: xs => fun ( x ) ( reduce( fun )( unit )( xs ) )
}



def reduce[T,R] ( fun : T => R => R ) ( unit : R ) ( list : List[T] ) : R =
list match {

case Nil => unit

case x :: xs => fun ( x ) ( reduce( fun )( unit )( xs ) )
}

reduce ʘ unit t1 :: t2 :: t3 :: t4 :: Nil
=>
t1 ʘ ( t2 ʘ ( t3 ʘ ( t4 ʘ unit ) ) )


val add = (x : Int) => (y : Int) => x + y

val mult = (x : Int) => (y : Int) => x * y

...
val sum = reduce ( add ) ( 0 ) _

val product = reduce ( mult ) ( 1 ) _

...
sum( List( 1, 2, 3, 4 ) ) >> 10

product( List( 1, 2, 3, 4 ) ) >> 24



val or = ( x :Boolean ) => ( y :Boolean ) => x || y
val and = ( x :Boolean ) => ( y :Boolean ) => x && y
val not = ( x :Boolean ) => !x

...
val existOneTrue = reduce ( or ) ( false ) _
val allFalse = not o reduce ( or ) ( false ) _
val allTrue = reduce ( and ) ( true ) _

...
allTrue( List( 1 < 2, 3 == 3, 1 + 1 == 2 ) ) >> true


Example: List concatenation

def append[T] (x:T) (xs:List[ _ ]) = x :: xs

val listConcat = reduce ( append ) _

listConcat ( List( 1, 2, 3, 4 ) ) ( List( 8, 9 ) ) )
>> List( 8, 9, 1, 2, 3, 4 )

listConcat ( List( true, true, false ) ) ( List( true, false ) ) )
>> List( true, false, true, true, false )




val listConcat = reduce ( append ) _

>> List( 8, 9, 1, 2, 3, 4 ) 'unit'

>> List( true, false, true, true, false )




val listConcat = flipArgs( reduce ( append ) _ )

>> List( 1, 2, 3, 4, 8, 9 )

>> List( true, true, false, true, false )





>> List( 1, 2, 3, 4, 8, 9 ) 'unit'

>> List( true, true, false, true, false )



!



Type of result: List[Any]



def append[T] (x:T) (xs:List[ T ]) = x :: xs

def listConcat[A] ( a: List[A]) ( b: List[A] ) : List[A] =
reduce[ A, List[A] ] ( ( append[A] ) _ ) (b) (a)


Type of result: List[Int]


More



val doubleAll : List[Int] => List[Int] = _ match {
case Nil => Nil
case y :: ys => y * 2 :: doubleAll( ys )
}

doubleAll( List( 1, 2, 3, 4 ) )

>> List( 2, 4, 6, 8 )



val toLength : List[String] => List[Int] = _ match {

case Nil => Nil

case y :: ys => y.length :: toLength( ys )
}

toLength( List( "a", "ab", "abc", "abcde" ) ) )

>> List( 1, 2, 3, 5 )


Fundamental Functions : map

val map : List[T] => List[R] = _ match {

case Nil => Nil

case y :: ys => f?( y ) :: map( ys )
}



def map[T, R] ( f: T => R ) : List[T] => List[R] =

( xs : List[T] ) => xs match {

case Nil => Nil

case y :: ys => f( y ) :: map( f )( ys )
}



def map[T, R] ( f: T => R ) : List[T] => List[R] =

( xs : List[T] ) => xs match {

case Nil => Nil

case y :: ys => f( y ) :: map( f )( ys )
}

Accepting a function to Resulting in another function,
apply on every element accepting the List of elements



def map[T, R] ( f: T => R ) : List[T] => List[R] = ...

...
val mult = (x : Int) => (y : Int) => x * y

val doubleAll = map( mult( 2 ) )

...
val toLength = map( ( s :String ) => s.length )





val sumMatrix = sum o map( sum )

Type of sum : List[Int] => Int

Type of map( sum ) : List[List[Int]] => List[Int]

Type of sumMatrix : List[List[Int]] => Int





val sumMatrix = sum o map( sum )

...
val matrix = List( List( 1, 2, 3 ),
List( 4, 5, 6 ),
List( 7, 8, 9 ) )

sumMatrix( matrix ) >> 45


map via reduce

def applyAndPrepend [A, B] ( f: A => B ) =
( a :A ) => ( bs :List[B] ) => f( a ) :: bs

def map [A, B] ( f: A => B ) : List[A] => List[B] =
reduce ( applyAndPrepend( f ) ) ( Nil ) _


map via reduce

def applyAndPrepend [A, B] ( f: A => B ) =
( a :A ) => ( bs :List[B] ) => f( a ) :: bs

def map [A, B] ( f: A => B ) : List[A] => List[B] =
reduce ( applyAndPrepend( f ) ) ( Nil ) _

f :: f :: f :: f :: Nil

X1 :: X2 :: X3 :: X4 :: Nil

filter via reduce

def filter[T]( pred :T => Boolean ) : List[T] => List[T] =
reduce ( ( x :T ) => ( acc :List[T] ) =>
if( pred( x ) ) x :: acc else acc )
( Nil )


Type Classes


Type Classes

def sum( xs : List[Int] ) : Int = xs match {

case Nil => 0

case head :: tail => head + sum( tail )
}


Type Classes

def sum( xs : List[String] ) : String = xs match {

case Nil => ““

case head :: tail => head + sum( tail )
}

Concatenation !


Type Classes

def sum[A]( xs : List[A] ) : A = xs match {

case Nil => ?
case head :: tail => head ? sum( tail )
}


Type Classes

def sum[A]( xs : List[A] ) : A = xs match {

case Nil => ? 'neutral' element

case head :: tail => head ? sum( tail )
}
element composition


Type Classes

trait SemiGroup[S] {

def add( x : S, y : S ) : S element composition
}

trait Monoid[M] extends SemiGroup[M] {

def unit : M 'neutral' element
}


Type Classes

def sum [A] ( xs : List[A], m: Monoid[A] ) : A =

xs match {

case Nil => m.unit

case head :: tail => m.add( head, sum( tail, m) )

}


Type Classes

def sum [A] ( xs : List[A], m: Monoid[A] ) : A =
'type constraint'
xs match {

case Nil => m.unit

case head :: tail => m.add( head, sum( tail, m) )

}


Type Classes

object IntMonoid extends Monoid[Int]{
def add(x : Int, y : Int): Int = x + y
def unit : Int = 0
}

…

sum( List( 1, 2, 3, 4 ), IntMonoid )


Type Classes

def sum [A] ( xs : List[A] ) ( implicit m: Monoid[A] ) : A = ...

implicit object IntMonoid extends Monoid[Int]{ … }

…

import typeclasses.monoid._
...

sum( List( 1, 2, 3, 4 ) )


Example: Clock-Monoid

sealed abstract case class ClockHour( hour: Int )
case object HOUR_0 extends ClockHour( 0 )
...

…
implicit object ClockHourMonoid extends Monoid[ClockHour]{

val hours = Array( HOUR_0, HOUR_1, HOUR_2, ..., HOUR_11 )

def add(x : ClockHour, y : ClockHour) = hours( ( x.hour + y.hour ) % 12 )

def unit : ClockHour = HOUR_0
}


Example: Clock-Monoid

import typeclasses.monoid.ClockHourMonoid
...

sum( List( HOUR_5, HOUR_3, HOUR_8 ) )

>> HOUR_4


Example: Contains element ?
trait Eq[E]{
def equals( e1 :E, e2 :E ) : Boolean
}

def contains [T] ( x :T, xs : List[T] )
( implicit eq :Eq[T] ) : Boolean =
reduce
( ( y :T ) => ( acc :Boolean ) =>
if( eq.equals( x, y ) ) true else acc )
( false ) 1st Arg: 'reducing' function
( xs )
2nd Arg: 'unit'

3rd Arg: List to reduce

Example: Contains element ?
case class Person( name :String, age :Int )

implicit object PersonEq extends Eq[Person]{
def equals( p1 :Person, p2 :Person ) : Boolean =
(p1.name == p2.name) && (p1.age == p2.age)
}

...
val persons = List( Person("Hans", 22),
Person( "Helga", 32 ),
Person( "Hugo", 47 ) )

contains( Person( "Olga", 22 ), persons ) >> false
contains( Person( "Helga", 32 ), persons ) >> true

Monads


Monads

A simple Monad: Option

<< abstract >>

Option[+A]

Some[+A] None

presence absence
Handling the or of something

...as the result of a computation
(computational environment)

Monads


class CustomerDAO{

def findCustomer( custId: Long ) : Option<Customer> = {
...
if( found( customer ) ) Some( customer ) else None
}
}


Monads


class CustomerDAO{

def findCustomer( custId: Long ) : Option<Customer> = {
...
if( found( customer ) ) Some( customer ) else None
}
}
Explicit Notion, that there may be 'none' result


Monads


val customerHit = customerDAO.findCustomer( 123 );
...

customerHit match {

case Some( customer ) => println( customer.name )

case None => println( “not found“ )
}


Monads


...

customerHit match {


}

Explicit Handling the absensce of a result
Forces 'Awareness'

Monads


...

customerHit match {


}

... beside from that ... what's the deal ???


Monads


...

customerHit match {


}

'Protected' Function Composition ...

Monads

val projects = Map( "Jan" -> "IKT",
"Joe" -> "TensE",
"Luca" -> "InTA" )

val customers = Map( "IKT" -> "Hanso GmbH",
"InTA" -> "RAIA Duo" )

val cities = Map( "Hanso GmbH" -> "Stuttgart",
"Mogno" -> "Mailand" )


Monads

val projects = Map( "Jan" -> "IKT",
"Joe" -> "TensE",
"Luca" -> "InTA" )

val customers = Map( "IKT" -> "Hanso GmbH",
"InTA" -> "RAIA Duo" )

val cities = Map( "Hanso GmbH" -> "Stuttgart",
"Mogno" -> "Mailand" )

Where is Jan ?
Jan -> IKT -> Hanso GmbH -> Stuttgart

Monads
Jav
public String whereIs( String name ){

a
String project = projects.get( name );
if( project != null ){
String customer = customers.get( project );
if( customer != null ){
String city = cities.get( customer )
if( city != null ) return city;
else return “unknown“;
}
else return ''unknown'';
}
else return ''unknown'';
}


Monads
Scal

a
def whereIs( name: String ) = {

projects.get( name )
.flatMap( project => customers get project )
.flatMap( customer => cities get customer )
.getOrElse( "unknown!" )
}


Monads
Scal

a
Results in Option[String]
}


Monads
Scal

a
}

Option[A].map( A => B ) >> Option[B]


Monads
Scal

a
}
Option[A].map( A => Option[B] ) >> Option[Option[B]]


Monads
Scal

a
}
Option[A].map( A => Option[B] ) >> Option[Option[B]]
Option[A].flatMap( A => Option[B] ) >> Option[B]


Monads

Protected Composition

map( A => B ) map( B => C ) map( C => D )

None None None
...
Some[A] Some[B] Some[C] Some[D]


Monads


def whereIs( name: String ) =

( for( project <- projects get name;
customer <- customers get project;
city <- cities get customer
) yield city
).getOrElse( "unknown!" )


Summary

Scala allows for ...
● Currying

● Combinators

● Fundamental Functions

● Type classes

● Monads


Thank you !


References

Scala Home www.scala-lang.org

Dr. Erik Meijer C9 Lectures – Functional Programming Fundamentals
http://channel9.msdn.com

Graham Hutton Programming in Haskell
Cambridge

Odersky, Spoon, Venners Programming in Scala
artima


Functional Scala II (in practice)

Recommandé

Recommandé

Contenu connexe

Dernier

Dernier (20)

En vedette

En vedette (20)

Functional Scala II (in practice)