A funkcionális programozás bemutatása példákon keresztűl céges önképzőkör keretében.

1. Funkcionális
programozás (FP)
kedvcsináló

2. Imperatív programozási
stílus
• Neumann elv
• Változók, ciklusok, elágazások
• Pascal, C,…
• “Bolyongás az állapottérben”

3. Deklaratív programozási
stílus
• Nem hogyan, hanem mit
• Többek közt az FP-k is
Imperativ (C) FP (Haskell)
int fact(int n){
int f=1;
while(n>1)
f*=n--;
return f;
fact 0 = 1
fact n = n * fact n-1

4. Prímszámkeresés I.
deklaratív módon
Haskell-ben programozva:
osztok :: Int-> [Int]
osztok n =[x | x<-[1..n],n `mod` x == 0]
primek n =[x | x<-[1..n],osztok x == [1,x]]

5. Funkcionális programozási
nyelvek
• Minden program egy függvény.
• A függvények first class citizen-k, azaz a függvények
használhatók bárhol, bármire a programban
• Magasabb rendű függvények: filter, map, foldr
• Lambda kifejezés
• Nincs változó, nincs sírás
• Rekurzió

6. FP nyelvek
• 1959 Lisp
• 1975-77 ML, FP, Scheme
• 1978 Smalltalk
• 1986 Standard ML
• 1990 Haskell, Erlang
• 1999 XSLT
• 2000 OCaml
• 2003 Scala, XQuery
• 2005 F#
• 2007 Clojure
• 2014 Swift

7. FP miért érdekes
• Divatos
• Könnyebb leírni bonyolult mintákat. pl async
hívások, exception-k
• Nincs változó => könnyen párhuzamosítható
• Egyre több nyelvben bukkan fel
Java8, JavaScript
• Nem ellentette az OO-nak. Lásd Scala

8. Parciális függvények
add x y = x +y //Int->Int->Int
add5 y = add 5 ??????

9. Map, filter, foldr
x=[1..10]
x1=map (x ->x+5) x
x2=filter (x ->x>5) x
szum :: [Integer] -> Integer
szum [] = 0
szum (x:xs) =x+szum xs
prod :: [Integer] -> Integer
prod [] = 1
prod (x:xs) =x*prod xs
//Csak két karakterben térnek el. Legyen a fentiek általánosítása a foldr fv.
prod2= foldr (*) 1
szum2 = foldr (+) 0

10. QuickSort megvalósítás
Ha valaki nem ismeri az algoritmust, a programkódból
megtanulhatja.
qsort :: [Int] -> [Int]
qsort [] = []
qsort(x:xs)=
qsort smaller ++ [x] ++ qsort larger
where
smaller = [a|a<-xs, a<=x]
larger = [b|b<-xs, b>=x]

11. Prímszám II.
Érdekességként, egy haladó szintű példa.
Eratoszthenész szitájának Scala megvalósítása:
def from(n: Int): Stream[Int] = n #:: from(n+1) from: from[](val n: Int) => Stream[Int]
(from(2) take 20).toList res2: List[Int] = List(2, 3, 4, 5, 6, 7, 8,
9,
def sieve(s: Stream[Int]): Stream[Int] = sieve:sieve[](val s:Stream[Int])=>
Stream[Int]
s.head #:: sieve(s.tail filter (_ % s.head != 0))
val primes = sieve(from(2)) primes: Stream[Int] = Stream(2, ?)
(primes take 20).toList res3: List[Int] = List(2, 3, 5, 7, 11, 13,

12. Irodalom
• Imperatív programozás matematikai alapjai:
Fóti - Horváth: Bevezetés a programozásba
http://www.inf.elte.hu/ekonyvtar/bevprog.pdf
• John Hughes: Why Functional Programming
Matters? (Addison-Wesley:1990)
• coursera.org: Programming Languages
Functional Programming Principles
• edx.org: FP101x Introduction to FP