Functional Programming First class functions, lambdas and...

Paradigms Pure Rec Delegates Lambdas Closures More Quiz JS Java

Functional ProgrammingFirst class functions, lambdas and closures

Radu NicolescuDepartment of Computer Science

University of Auckland

23 July 2018

1 / 61

1 Programming paradigms

2 Pure FP

3 Recursion

4 C# Delegates

5 Lambda expressions

6 Closures

7 More Lambdas

8 Quiz – Simple scenarios

9 Lambdas in Javascript

10 Lambdas in Java

2 / 61

Outline

2 Pure FP

3 Recursion

4 C# Delegates

6 Closures

7 More Lambdas

10 Lambdas in Java

3 / 61

Programming paradigms

• Object-oriented: develop complex objects starting with simpleobjects (using inheritance, aggregation, delegation, ...)

• Functional: develop complex functions starting with simplefunctions (using function composition, Kleisli, ...)

• Object-oriented or functional?

• Object-oriented and functional! More dimensions, more tools!

• Most modern languages evolve towards a multi-paradigm style

• Object-first: C#, Java, C++, ...

• Functional-first: F#, Javascript (Lisp in Java syntax), ...

• Object-functional: Scala, ...

4 / 61

Side-bar: functions and methods

• In classical OOP, functions only appear as methods:

• Static/class methods

• Instance methods (cf. this pointer)

• Other languages, including FP, have standalone, eventop-level, functions

• Problem: how to represent anonymous inline functions (suchas lambdas) in OOP?

• Solution: embed these in the current object, if possible, orinside hidden automatically constructed objects – more atclosures

5 / 61

Basic ingredients of FP

• first-class and higher order functions (aka, functionals)

• informally, you can work with functions as with any otherobjects – and compose them!

• you can have functions that take functions as parameters andreturn functions (functions which may be dynamicallycomposed)

• currying or partial application of functions

• memoization (or caching) of function results

• no side effects and immutable values (next slide)

6 / 61

Outline

2 Pure FP

3 Recursion

4 C# Delegates

6 Closures

7 More Lambdas

10 Lambdas in Java

7 / 61

Pure FP

• Function results should only depend on parameter values

• No side effects: Functions should not change the global stateor any persistent state (unlike object methods which changethe object’s state)

• Immutable values: Ideally, functions should not change anyvalue at all! – This is possible if we use recursion instead ofclassical loops...

• As one of the advantages, programs will be easier to provecorrect, to optimize or to parallelize

8 / 61

Pure FP

8 / 61

Pure FP

8 / 61

Pure FP

8 / 61

Pure FP

• For example, if f and g don’t change any global variable norany of their parameters (i.e., a, b, c , d), the following twostatements can run in parallel, on a dual-core machine:

1 x = f ( a , b ) ; — function f could be evaluated on core #123 y = g ( c , d ) ; — function g could be evaluated on core #2

• However, many practical languages, including C# (and F#),do accept side effects, although some of them will try toexplicit or localize these (e.g., via so-called monads)

9 / 61

Pure FP

• For example, if f and g don’t change any global variable norany of their parameters (i.e., a, b, c , d), the following twostatements can run in parallel, on a dual-core machine:

1 x = f ( a , b ) ; — function f could be evaluated on core #123 y = g ( c , d ) ; — function g could be evaluated on core #2

• However, many practical languages, including C# (and F#),do accept side effects, although some of them will try toexplicit or localize these (e.g., via so-called monads)

9 / 61

Variables and mutability in C#

• Class fields and properties : vast topic, but not much of ourconcern here...

• var or normal declarations are mutable

1 var x = 1 0 ; x = x + 1 ;2 i n t x = 1 0 ; x = x + 1 ;

• const defines compile-time immutable values

1 const x = 1 0 ;

• readonly defines run-time immutable fields – maybe differentlyinitialised in constructors, but then is frozen

1 readonly i n t x ;

10 / 61

Variables and mutability in C#

• Shallow vs deep immutability

• Shallow immutable complex objects such as arrays

1 c l a s s C {2 pub l i c s t a t i c readonly i n t [ ] A3 = new in t [ ] { 10 , 20 , 30 , } ;4 }56 void Main ( ) {7 var B = new in t [ ] { 100 , 200 , 300 , } ;8 // C . A = B ; // NOT allowed9 C . A [ 1 ] = 2 0 0 ; // allowed!

10 C . A . Dump ( ) ;11 }

• Conclusions: flexible but porous

11 / 61

Variables and mutability in F#

• Class fields and properties : vast topic, but not much of ourconcern here...

• let declarations are immutable – not “variables” but values

1 l e t x = 10

• x = x + 1 is legal (!) but does NOT mean what one wouldthink: it is a boolean equality test that returns false !

• Mutable variables must be explicitly declared so

1 l e t mutable x = 102 x <− x + 1

• Increased awareness: the assignment to a mutable variableuses a distinct op sign <−

12 / 61

Variables and mutability in F#

• Still shallow immutable arrays (but not other objects)

1 l e t A = [ | 1 0 ; 2 0 ; 3 0 ; | ] // A itself is immutable2 A . [ 1 ] <− 200 // allowed!3 A . Dump ( )

• Why this exception for arrays? Because of the HUGE body ofscientific algorithms, which have been developed andoptimised for FORTRAN mutable arrays

• F# encourages a more pure style, and promotes increasedawareness of mutability – but still allows one the choice to useother styles

13 / 61

Variables and mutability in JS

• var declarations are mutable with global scope or function“global” scope

1 var x = 10

• let declarations are mutable with block local scope

1 i f ( b ) {2 l e t x = 103 x = x + 14 }

• const declarations are immutable with block local scope

1 i f ( b ) {2 const x = 103 // x = x + 1 // not allowed4 }

• More in part (M) 14 / 61

Outline

2 Pure FP

3 Recursion

4 C# Delegates

6 Closures

7 More Lambdas

10 Lambdas in Java

15 / 61

Imperative factorial

• F#

1 l e t f a c t n : i n t =2 l e t mutable m = n3 l e t mutable f = 14 whi le (m >= 1) do5 f <− f ∗ m6 m <− m − 17 f89 p r i n t f n ” I m p e r a t i v e : %A” ( f a c t 5)

16 / 61

Naive recursive factorial

• F#

1 l e t rec f a c t ’ n =2 i f n <= 0 then 13 e l s e ( f a c t ’ ( n−1)) ∗ n45 p r i n t f n ” Naive R e c u r s i v e : %A” ( f a c t ’ 5)

• Performance issues, stack overflow

17 / 61

Tail recursive factorial

• F#

1 l e t f a c t ’ ’ n =2 l e t rec f a c t t a i l r e c n acc =3 i f ( n <= 0) then acc4 e l s e f a c t t a i l r e c ( n−1) ( n∗ acc )5 f a c t t a i l r e c n 167 p r i n t f n ” T a i l R e c u r s i v e : %A” ( f a c t ’ ’ 5)

• F# : TCO = Tail Call Optimisation

• NO performance issues, NO stack overflow

18 / 61

Tail recursive factorial – reverse engineered

• C# : recursion ⇒ while loop!

1 s t a t i c i n t f a c t t a i l r e c ( i n t n , i n t acc ) {2 whi le ( n > 0) {3 acc = n ∗ acc ;4 n = n − 1 ;5 }6 return acc ;7 }8 pub l i c s t a t i c i n t f a c t ( i n t n ) {9 return f a c t t a i l r e c ( n , 1 ) ;

• NO performance issues, NO stack overflow

19 / 61

Outline

2 Pure FP

3 Recursion

4 C# Delegates

6 Closures

7 More Lambdas

10 Lambdas in Java

20 / 61

C# Delegates in a nutshell

• Consider this scenario

1 c l a s s C {2 pub l i c i n t F ( i n t x ) { return x +1; }3 pub l i c i n t G ( i n t y ) { return y+y ; }4 pub l i c s t a t i c i n t H ( i n t z ) { return z∗ z ; }5 }

• What do these three methods have in common?

• Their signature: int→int

• Usage (assuming using static System.Console)

1 W r i t e L i n e ($”{ c1 . F ( 3 )} { c2 . G( 3 )} {C .H( 3 )} ” ) ;2 // 4 6 9

21 / 61

C# Delegates in a nutshell

• Same scenario

1 c l a s s C {2 pub l i c i n t F ( i n t x ) { return x +1; }3 pub l i c i n t G ( i n t y ) { return y+y ; }4 pub l i c s t a t i c i n t H ( i n t z ) { return z∗ z ; }5 }

• More flexible usage using typed function pointers!

1 Func <int , int> f = c1 . F ;2 Func <int , int> g = c2 . G ;3 Func <int , int> h = C .H;4 W r i t e L i n e ($”{ f ( 3 )} {g ( 3 )} {h ( 3 )} ” ) ;5 // 4 6 9

• The same pointer, e.g. f, could point in turn to all thesemethods!

22 / 61

C# Delegates

• A delegate is a .NET type-safe pointer to a function, i.e. to aclass or instance method

• To call an instance method: obj .F (...)

• To call a static method: Class .H (...)

• Technically, a delegate is an object with two properties

• Method: a pointer to the instance or class method (F, H)

• Target – for instance methods: pointer to actual object (obj)

• instance method calls depend on the actual target object

• Target – for static methods: null (usually)

• static methods can be fully resolved by the compiler (so theactual class is not needed at runtime)

23 / 61

C# Delegates

23 / 61

C# Delegates

23 / 61

C# Delegates

23 / 61

C# Delegates

23 / 61

C# Delegates

23 / 61

Predefined delegate types in C# – Function types in F#

1 Func<T1 , T2 , . . . , Tn , TResult> (n ∈ {0, 1, 2, . . . , 16}) // C#23 f : T1∗T2 ∗ . . . ∗Tm − > un i t // F#

• functions taking T1,T2 ,..., Tn and returning TResult, i.e.

• f : T1× T2× . . .Tn→ TResult – maths notation.

1 Act ion<T1 , T2 , . . . , Tm> (m ∈ {0, 1, 2, . . . , 16}) // C#23 f : T1∗T2 ∗ . . . ∗Tm − > un i t // F#

• “functions” taking T1,T2 ,..., Tm and returning void , i.e.

• f : T1× T2× . . .Tm→ void – maths-like notation.

• unit is the F# “void” type, with one single value ()

24 / 61

Predefined delegate types in C# – Function types in F#

1 Func<T1 , T2 , . . . , Tn , TResult> (n ∈ {0, 1, 2, . . . , 16}) // C#23 f : T1∗T2 ∗ . . . ∗Tm − > un i t // F#

• functions taking T1,T2 ,..., Tn and returning TResult, i.e.

• f : T1× T2× . . .Tn→ TResult – maths notation.

1 Act ion<T1 , T2 , . . . , Tm> (m ∈ {0, 1, 2, . . . , 16}) // C#23 f : T1∗T2 ∗ . . . ∗Tm − > un i t // F#

• “functions” taking T1,T2 ,..., Tm and returning void , i.e.

• f : T1× T2× . . .Tm→ void – maths-like notation.

24 / 61

Delegates – visualisation

To visualise the target of a delegate to a method, consider thefollowing scenario (Linqpad)

• a class C – nested in the outer Linqpad class, UserQuery

1 c l a s s C {2 pub l i c i n t X { get ; set ; }3 pub l i c i n t F ( i n t v ) { return v + X ; }4 pub l i c s t a t i c i n t G( i n t v ) { return v + 1 0 0 ; }5 }

• two instances of C, o1 and o2

1 var o1 = new C { X = 10 , } ;2 var o2 = new C { X = 20 , } ;34 W r i t e L i n e ($”{o1 . F ( 1 )} , {o2 . F ( 1 )} , {C . G( 1 )} ” ) ;5 // 11 , 21 , 101

25 / 61

To visualise the target of a delegate to a method, consider thefollowing scenario (Linqpad)

• a class C – nested in the outer Linqpad class, UserQuery

1 c l a s s C {2 pub l i c i n t X { get ; set ; }3 pub l i c i n t F ( i n t v ) { return v + X ; }4 pub l i c s t a t i c i n t G( i n t v ) { return v + 1 0 0 ; }5 }

• two instances of C, o1 and o2

1 var o1 = new C { X = 10 , } ;2 var o2 = new C { X = 20 , } ;34 W r i t e L i n e ($”{o1 . F ( 1 )} , {o2 . F ( 1 )} , {C . G( 1 )} ” ) ;5 // 11 , 21 , 101

25 / 61

• three pointers to functions (delegates)

1 Func<int , int> f 1 = o1 . F ;2 Func<int , int> f 2 = o2 . F ;3 Func<int , int> g = C . G ;4 W r i t e L i n e ($”{ f 1 ( 1 )} ,{ f 2 ( 1 )} ,{ g ( 1 )} ” ) ; //11 ,21 ,101

• visualise their target objects

1 f 1 . Target . Dump( ” f 1 ” ) ;23 f 2 . Target . Dump( ” f 2 ” ) ;45 g . Target . Dump( ”g” ) ;

26 / 61

• three pointers to functions (delegates)

1 Func<int , int> f 1 = o1 . F ;2 Func<int , int> f 2 = o2 . F ;3 Func<int , int> g = C . G ;4 W r i t e L i n e ($”{ f 1 ( 1 )} ,{ f 2 ( 1 )} ,{ g ( 1 )} ” ) ; //11 ,21 ,101

• visualise their target objects

1 f 1 . Target . Dump( ” f 1 ” ) ;23 f 2 . Target . Dump( ” f 2 ” ) ;45 g . Target . Dump( ”g” ) ;

26 / 61

Outline

2 Pure FP

3 Recursion

4 C# Delegates

6 Closures

7 More Lambdas

10 Lambdas in Java

27 / 61

λ-expressions

• Ideas originate from an early theoretical model: λ-calculus(introduced by Alonzo Church, 1930s).

• λ-expression example (lambda in red):

1 l e t f := (λs.suv)

• Let f is “syntactic sugar”, our external denotation to ananonymous (unnamed) λ-expression of one parameter, s.

• Sample invocation: (f x) = ((λs.suv) x) = xuv .

• Pure λ-expressions have only names for the parameters –although these could also be eliminated and replaced bynumbers which indicate the position (De Brujin).

28 / 61

λ-expressions

• Pure λ-calculus has NO variables, NO loops/recursion (butthese can simulated by way of Y combinators).

• Still, λ-calculus is an universal model of computationequivalent to Turing machines!

• Historical note: why “lambdas”? “Raging” debate...

• Church’s manuscript used hats to designate parameters

1 ( s . t )

• Typographer’s solution

1 (ˆ s . t )

• Adjustment (according to the original cursive script)

1 (λs . t )

29 / 61

λ-expressions

• Pure λ-calculus has NO variables, NO loops/recursion (butthese can simulated by way of Y combinators).

• Still, λ-calculus is an universal model of computationequivalent to Turing machines!

• Historical note: why “lambdas”? “Raging” debate...

• Church’s manuscript used hats to designate parameters

1 ( s . t )

• Typographer’s solution

1 (ˆ s . t )

• Adjustment (according to the original cursive script)

1 (λs . t )

29 / 61

Lambdas as anonymous inline functions

• C# examples:

1 Func<s t r ing , int> f = (string s) => s.Length ;

3 Func<s t r ing , int> f = s => s.Length ;

• f is a delegate (pointer) to an anonymous (unnamed)function of one string parameter, s, return its length

• sample invocation: f(”abc”)

• F# examples:

1 l e t f = fun (s: string) − > s.Length ;

3 l e t f ’ : s t r i ng −> i n t = fun s − > s.Length

30 / 61

Lambdas as anonymous inline functions

• C# examples:

1 Func<s t r ing , int> f = (string s) => s.Length ;

3 Func<s t r ing , int> f = s => s.Length ;

• f is a delegate (pointer) to an anonymous (unnamed)function of one string parameter, s, return its length

• sample invocation: f(”abc”)

• F# examples:

1 l e t f = fun (s: string) − > s.Length ;

3 l e t f ’ : s t r i ng −> i n t = fun s − > s.Length

30 / 61

Lambdas — Other examples

• C#, F#

1 Func<int> g = () => 2 ; // C#2 l e t g = fun () − > 2 ; // F# un i t −> i n t

• g is a function without parameters, returning int constant 2

• sample invocation: g()

• C#, F#

1 Func<int , int , int> h = (x, y) => x + y ; // C#2 l e t h = fun (x, y)− > x + y ; // F# ( i n t ∗ i n t ) −> i n t

• h is a function of an int pair, x , y , returning their sum

• sample invocation: h(10, 20)

31 / 61

• C#, F#

31 / 61

• C#, F#

31 / 61

• C#, F#

31 / 61

• C#, F#

31 / 61

• C#, F#

31 / 61

• C#, F#

31 / 61

Lambdas have two faces!

Janus, from Wikipedia

1 Anonymous inline functions

2 Expression trees

32 / 61

Lambdas have two faces!

Janus, from Wikipedia

1 Anonymous inline functions

2 Expression trees

32 / 61

Lambdas as Expression trees!

• The other face of lambdas (≈ compilation arrested atintermediate tree structures)

• Consider the following scenario, where the same lambda canbe assigned to different left-handside type!