Funkcionální programování

funkce jsou základním stavebním kamenem
neexistují proměnné, třídy, objekty, ...
funkce nemají vedlejší efekty — nemění stav mimofunkčních věcí
funkce se mohou předávat jako parametry
funkce mohou vracet funkce

Funkce

Ukázka

#lang racket

; (define (jmenoFunkce parametry...)
;   teloFunkce)

(define (add x y)
  (+ x y))

Zavolání funkce

#lang racket

(define (add x y)
  (+ x y))

(add 1 2)

(add (add 1 2) 3)

Ukázka podmínky

#lang racket

(define (abs x)
  (if (< x 0)
      (- x)
      x))

Rekurze

#lang racket

(define (factorial n)
  (if (= n 0)
      1
      (* n (factorial (- n 1)))))

Práce s listy

#lang racket

(define (sum list)
  (if (null? list)
      0
      (+ (car list) (sum (cdr list)))))

(sum '(1 2 3 4 5 6 7 8 9 10))

(define (second list)
  (car (cdr list)))

(second '(1 2 3 4 5 6 7 8 9 10))
(second '(1))

(define (makeList n)
  (if (= n 0)
      '()
      (cons n (makeList (- n 1)))))

Let

#lang racket

(define (f x)
  (let ([y (+ x 1)])
    (+ (* x y) y)))

Cond

#lang racket

(define (fib n)
    (cond
        [(= n 0) 0]
        [(= n 1) 1]
        [else (+ (fib (- n 1)) (fib (- n 2)))]))

Koncová rekurze

#lang racket

; recursion normal
(define (factorial n)
  (if (= n 0)
      1
      (* n (factorial (- n 1)))))

(factorial 5)


; recursion tail recursive
(define (factorialTail n)
  (factorialTailInner n 1))

(define (factorialTailInner n acc)
    (if (= n 0)
        acc
        (factorialTailInner (- n 1) (* n acc))))

(factorialTail 5)

Anonymní funkce

#lang racket

; calculate damage for entity type
(define (damage calc type)
  (calc type))

(damage
    (lambda (type)
        (cond
            [(eq? type 'fire) 10]
            [(eq? type 'water) 5]
            [(eq? type 'grass) 15]
            [else 0]))
    'fire)

map

Aplikuje funkci na každý prvek seznamu a vrátí seznam výsledků.

#lang racket

(map (lambda (x) (* x x))
     '(1 2 3 4 5))

filter

Vrátí seznam prvků, které splňují podmínku.

#lang racket

(filter (lambda (x) (not (zero? x))) '(1 2 0 3 0 4 5 0 6 0 7))

foldr a foldl

Prochází seznam a vrací jednu hodnotu. Foldr prochází seznam zprava doleva, foldl zleva doprava.

#lang racket

(foldr (lambda (x y) (+ x y)) 0 '(1 2 3 4 5))

(foldr (lambda (x y) (cons x y)) '() '(1 2 3 4 5))

(foldr (lambda (x y) (cond [(even? x) (cons x y)] [else y])) '() '(1 2 3 4 5))

(foldr (lambda (x y) (ceiling (/ x y))) 1 '(1 2 3 4 5))
(foldl (lambda (x y) (ceiling (/ x y))) 1 '(1 2 3 4 5))