presentation of gettogether on functional programming
TRANSCRIPT
Me, Myself & Functional Programming• 1991: Prolog• 1992: sociology in LLN• 1993: Haskell• 1994: paper of Hudak• 1999: paper Games provide fun(ctional programming• tasks) in Functional and declarative programming in education,
FDPE’99• 2001: finished my PhD and started at KHLim Diepenbeek• Teaching ICT in master in industrial sciences (ing.)
o Capable in Java, not so much in .NETo Bit of functional programming in master
2/72
Hudak’s Paper• Experiment in 1994
3/72
A Military Radar System Prototyped
4/72
The Results
5/72
Subjective Evaluation
6/72
Research in Functional Programming• Dia van Tom’s inaugurale• Lisp: 1958• Haskell:• Erlang• Common Lisp: 1e ANSI gestandaardiseerde taal met OO +
FP
7/72
Key Challenges
ProgrammingLanguages
Computer Science
Society
MoreSoftware
Agoria: ’9300 unfilled ICT positions'
Productivity Reliability
8
ANP: ‘Software bugs cost1.6 billion € a year’
Bug-Free Software
Meeting the ChallengesIncremental ResearchMainstream languages
Fundamental Research
A different approachto languages
Mainstream languages
9
Historical Evolution
imperativelanguages
objectorientation
mathematics
hardware
mainstream
alternative
declarativelanguages
10
1953Fortran
1958Cobol
1969CAlgol
1959 1971Smalltalk Eiffel
19851983C++
Declarative LanguagesFunctionalProgramming
Haskell
LogicProgramming
Prolog
ConstraintProgrammingMiniZinc
11
Recent Developments
imperativelanguages
objectorientation
mathematics
hardware
mainstream
declarativelanguages
research
12
Anonymous Functions
λ calculus1936
AlonzoChurch
1958Lisp
JohnMcCarthy
1973ML
RobinMilner
1987Haskell
HaskellCommittee
2014Java 8
Swift2011
C++11
Functional Languages Mainstream
2007C#
14
15/72
Early AdoptersHaskell Language + GHC Compiler
Finance Many OthersTelecom
16
Productivy and Functional Programmin• http://simontylercousins.net/does-the-language-you-use-
make-a-difference-revisited/• The problem
17/72
Solution in C#
18/72
Solution in F#
19/72
The Numbers (1)
20/72
The Numbers (2)
21/72
The Numbers (3)
22/72
Rest of the presentation• Some concepts of Functional Programming
o With examples in Haskell, F# and C#
23/72
Declarative Programming
What• Derivation from ‘input’-
values to ‘output’-values• Or expressing properties
o Often mathematically sound• (but still fun to do ;-)
• Intelligent executiono verifiable
How• What machine to use• When to use which
features of machine• What steps to set
• Programmer considered intelligento Mostly not verifiable
Describing the what instead of the how
24
Declarative Programming
What• SQL• Linq (mostly)• Logic Programming
o Constraint Programming
• Functional Programming
Different mindset!
How• Imperative programming
• Manipulation of v ariables
• What machine to useo von Neumann architecture
• When to use which features of machineo Variables = registers
• What steps to seto Order of executiono Outer loops (for, while)
Examples
= Statements= Expressions
25
Logic Programming = Prolog (1a)ancestor(x,y) :- parent(x,y).ancestor(x,y) :- ancestor(x,z), parent(z,y).
femaleAncestor(x,y) :- ancestor(x,y), female(x).
?- femaleAncestor(Kris,Lars). => no?- femaleAncestor(Celine,Lars). => yes?- femaleAncestor(x,Lars). => Celine, Liesbet
26/72
Logic Programming = Prolog (1b)female(Celine).female(Liesbet).female(Hanne).male(Kris).male(Lars).
parent(Celine,Kris).parent(Kris,Lars).parent(Liesbet,Lars).
27/72
Logic Programming = Prolog (2)evenNumber([]).even([_,_|T]):- evenNumber(T).
palindrome(L):- reverse(L,L).
reverse([],[]).reverse([H|T],R):- reverse(T,T1),append(T1,[H],R).
28/72
(Pure) Functional Programming• Much closer to “real” programming
o Logic Programming = (partial) instantation = more magico Functional Programming
• functions with parameters returning values• Much like functions and/or methodes
• Buto No side effects
• Referential transparency• An expression is a value with always the same value
• “no (hidden or far distant) state messing with things”
• Strongly typed with type inferenceo “Strongly typed programs can’t go wrong”
• Polymorf: a function can have many types
29/72
Lambda calculus• Each expression has a never-changing-value
o z = 18o y = sin(z)
• Complex expressions are calculated by evaluating and substituting subexpressionso (z + sin(z))*(y+cos(y))
• Function calls behave exactly the sameo Always call by valueo Always return valueo No pointer- or out variables
30/72
Lambda Calculus (2)• f x = g(3+x)+x• g y = y+1• z = 5
• f z + g z
31/72
How to express new state?• Never
o No mutable variables! (in pure FP-languages)• in general no side effects
o Confusing for imperative programmers• F# allows for explicit declaration of mutable variables• C# allows for explicit declaration of readonly (instance) variables
• But actually alwayso A new state is a new value
• May be stored explicitly in a variable• Or may be stored temporarily in memory
32/72
Explicit new values!let y = a + b yPlus1 = y + 1 f x = (x+y)/yPlus1in f a + f b
No confusion between x++ and ++x etc.
33/72
Advantages of having no mutable variables• Referential transparancy
o A reference always refers to the same valueo Mathematically sound
• Implicit parallellismo Order of execution can be chosen, both at compile and run
timeo Synchronisation: locking issues when dependencies
• Formal reasoningo Automated correctness and equivalence proofso More transparant codeo No underlying dependency from mutable states
34/72
Side EffectsTraditional MainstreamLanguages Oops,
unexpectedinterference
35
No Side EffectsTraditional DeclarativeLanguages
No Side-Effects,No Problem
Traditional MainstreamLanguages
No Side-Effects,No Party
Mathematical Elegance
Predictable
No Interference
✓✓✓
36
Explicit Side EffectsState-of-the-Art DeclarativeLanguages
Explicit Side-Effects,No Problem
Mathematical Elegance
Predictable
Explicit Interference
✓✓✓
37
How to return many values?• Imperative programs
o Return 1 value from functiono And others as ‘out’ parameters (using call by reference)
• OO programs using only call by valueo Define a container class for each combination of typeso Cumbersome…
• FP-languages use tuples (x,y) , (x,y,z) , (a,b,c,d), …o Flexible in number of elementso Flexible in composing types
38/72
Recursion = “looping” (1)
From definition to coden! = n*(n-1)!
With base case 1! = 1
• Haskell
o fac 1 = 1o fac n = n * fac (n-1)
• Non-recursive C#
public long fac(int n) { long value = 1; for (int i=2; i<=n; n++) { value = value * i; } return value ;}
39
Recursion = “looping” (2)
From definition to coden! = n*(n-1)!
With base case 1! = 1
• F#
let rec fact x = if x < 1 then 1 else x * fact (x - 1)
• Recursive C#
public long fac(int n) { if (n==1) return 1; return n * fac (n-1);}
40
Recursion = “looping” (3)
StackOverFlow error?•“Real” functional languages use more optimisation techniques for recursive programs
• F#
let rec fact x = if x < 1 then 1 else x * fact (x - 1)
• Recursive C#
public BigInteger fac(int n) { if (n==1) return 1; return n * fac (n-1);}
41
Tail recursion
Taking care of useless stack frames• Haskell
fac n = fac’ n 1
fac‘ 1 acc = accfac‘ n acc = fac’ (n-1) (n*acc)
• F#
let fac n = facT n 1
let rec facT n acc = if n = 1 then acc else facT (n-1) (n*acc)
42
Tail recursion (2)
Taking care of useless stack frames• C#
BigInteger Factorial(int n, BigInteger product){ if (n < 2) return product; return Factorial(n - 1, n * product);}
43
Exercises in my master class ;-)1. Hermite sum 1/n + 1/(n-1)+…1/2+1/1
2. Mysterious function (presumption of Fermat) o Reduce n to1 with the following steps
• Odd n => continue with 3n+1• Even n => continue with n/2
3. Calculate numberOfDivisors and isPriem
44/72
Solutions in Haskellherm 1 = 1herm n = 1/n + (herm (n-1))
myst 1 = [1]myst n | mod n 2 == 0 = n:(myst (div n 2)) | otherwise = n:(myst (3*n+1))
numberOfDivisors …isPrime n = (numberOfDivisors n) == 2
45/72
Recursive Programming: conclusion • Not exclusively for functional programming• But very typical for FP
o And efficient
• Interesting pattern also for non FP-languages!
46/72
Lists in Functional Programming• Omnipresent feature
o In most languageso But very strong support in FP
• Especially when combined with pattern matching• And recursive programming
• Remember basic concept of recursion:1. Define primitive/base expression(s)2. Reduce complex expression to more simple expression
• N reduces to n-1, n/2, …• List reduces to list with fewer elements
47/72
Pattern matching in Haskellfac 1 = 1fac n = n * fac (n-1)
findValue [] y = FalsefindValue (x:xs) y = if x == y then True
else findValue xs y
evenElems [] = TrueevenElems [x] = FalseevenElems (x:y:ys) = evenElems ys
48/72
Pattern matching in F#findValue [] y = FalsefindValue (x:xs) y = if x == y then True
else findValue xs y
let rec findValue list x = match list with | [] -> False | y::ys -> if x == y then True else findValue x ys
49/72
Pattern Matching in C#• Proposition for Roslyn in 8/2014
o https://roslyn.codeplex.com/discussions/560339o http://www.infoq.com/news/2014/08/Pattern-Matching
if (expr is Type v) { // code using v } // try-cast
var c = Cartesian(3, 4);if (c is Polar(var R, *)) Console.WriteLine(R);
var a = new Location(1, 2, 3); //x=1, y=2, z=3if (a is Location(1, var y, *))
50/72
Defining (recursive) types in Haskell• data Examenvorm = M | S | P• data Sexe= M | V• data Human = Mens Integer String Geslacht• data Point = Point Integer Integer• data GenericPoint a = Pt a a • data Tree a = Leaf a
| Branch (Tree a) (Tree a)
• Perfect for pattern matching!
51/72
Defining (recursive) types (2)• Comparable to structs and even classes• data Human = Human { age :: Integer,
name :: String, sexe :: Sexe }
• Creates automatically the following functionso Human :: Integer -> String -> Sexe -> Humano age :: Human -> Integero name :: Human -> Stringo sexe :: Human -> Sexe
52/72
Insert sort in Haskellisort [ ] = [ ]isort (x:xs) = insert x (isort xs)
insert x [ ] = [x]insert x (y:ys) = if (x<y) then (x:y:ys) else y:(insert x ys)
Barely new syntax needed!
53/72
Insert sort in F#let rec insert x l = match l with | [] -> [x] | y::ys -> if x <= y then x::y::ys else y::insert x ys and insertsort l = match l with | [] -> [] | x::xs -> insert x (insertsort xs)
Source: http://www.codecodex.com/wiki/Insertion_sort
54/72
Insert sort in C# (non-functional) static void InsertSort(IComparable[] array) { int i, j;
for (i = 1; i < array.Length; i++) { IComparable value = array[i]; j = i - 1; while ((j >= 0) && (array[j].CompareTo(value) > 0)) { array[j + 1] = array[j]; j=j-1; } array[j + 1] = value; } }
55/72
Type Classes and type inference• Note the explicit IComparable[] array in function type
o static void InsertSort(IComparable[] array)
• In Haskell implicit and auto-detected
56/72
Polymorfic: look at the types• Typ “:i isort” at command prompt of Haskell Interpreter
o isort :: Ord a => [a] -> [a]
• Similaro halfList :: [a] -> [a]o findValue :: Eq a => [a] -> a -> Boolo fac :: (Num a, Eq a) => a -> a
57/72
Strongly typed programs can’t go wrong• Type inference tries to find the most general type of
functiono Depending on the functions that are being used
• Programmer doesn’t need to define typeso But a type mismatch results in a compile time erroro Indicating a mistake in the reasoningo Whenever type inference succeeds most programs run
correctly
58/72
Type inference in .NET• More and more available
59/72
List Comprehensions in HaskellVery declarative constructor
-- give all even numbers of a listevens list = [x | x <- list, even x]
inBoth list1 list2 = [x | x <- list1, findValue x list2]
combine list1 list2 = [(x,y) | x <- list1, y <- list2]
60/72
List Comprehensions in HaskellVery declarative constructor
-- give all even numbers of a listevens list = [x | x <- list, even x]
inBoth list1 list2 = [x | x <- list1, findValue x list2]
combine list1 list2 = [(x,y) | x <- list1, y <- list2]
61/72
List Comprehensions in F#[for x in collection do ... yield expr]
seq { for x in 0..100 do if x*x > 3 then yield 2*x } ;;
evens list = [x | x <- list, even x]
inBoth list1 list2 = [x | x <- list1, findValue x list2]
combine list1 list2 = [(x,y) | x <- list1, y <- list2]
62/72
List Comprehensions in C#from x in Enumerable.Range(0, 100) where x * x > 3 select x * 2
63/72
Quicksort: even more beautiful ;-)• Concept of quicksort
1. Take “a” element of the list: the “spil”2. Split the list in two
1. Elements smaller than spil2. Elements bigger than spil
3. Quicksort each sublist (recursively ;-)4. Join the sorted lists together
64/72
Quicksort in Haskellqsort [] = []qsort [x] = [x]qsort (x:xs) = let smaller = qsort([y | y <- xs, y < x]) larger = qsort([y | y <- xs, y > x]) in smaller ++ (x:larger)
65/72
Quicksort in F#let rec qsort:int list -> int list = function | [] -> [] | x::xs -> let smaller = [for a in xs do if a<=x then yield a] let larger = [for b in xs do if b>x then yield b] qsort smaller @ [x] @ qsort larger
let rec qsort = function | [] -> [] | x::xs -> let smaller,larger = List.partition (fun y -> y<=x) xs qsort smaller @ [x] @ qsort larger
66/72
Higher order functions• Functions taking other functions as parameters
• Simple list functions map & filtero map fac [3,6,2,4]o filter odd [1,2,3,4,5,6,7]
• More Complex list functies foldr & foldlo Reduce a list to one value
• Using a combining function• And a starting value
o Foldr (+) 0 [1,2,3,4,5,6]
67/72
Recursion over functions
repeatFun 0 f value = valuerepeatFun n f value = repeatFun (n-1) f (f value)
bubbleSort list = repeatFun(length list) bubble listbubble [] = []bubble [x] = [x]bubble (x:y:ys) | x < y = x:(bubble (y:ys)) | otherwise = y:(bubble (x:ys))
68/72
Anonymous functions• Lambda abstractions
69/72
Currying• Functions of n arguments• Are actually functions of 1 argument
o Returning a function of (n-1) argument• Which is actually of function of 1 argument
• Returning a function of (n-2) arguments- …
• Specialisation of functionscontains2 = contains 2
70/72
Open your mind!• Become a Better Developer with Functional
Programmingo http://www.oscon.com/oscon2011/public/schedule/
detail/19191
Questions?
71/72
More info about the TETRA-project?
72/72
• http://www.vlambda.be/• Contact [email protected] or Tom Schrijvers
.NET-productiviteit verhogen met een gepast gebruikt van lambda's en F#
(en natuurlijk ook in Java ;-)
Vlaamse software vlamt met lambda’s