FP / Jazyk Lambda

Čo to je?

Motivácia

• Čo sa dá vypočítať?
• Čo je to algoritmus?
• Aké má vlastnosti?

Entscheidungs­problem

Formálna definícia algoritmu

1. Kurt Gödel
   Čiastočne rekurzívne funkcie (1933)
2. Alonzo Church
   λ kalkul (1936)
3. Alan Turing
   Turingov stroj (1936)

Všetky sú ekvivalentné — Churchova–Turingova téza

Turingov stroj

$$ {\displaystyle M=\langle Q,\Gamma ,b,\Sigma ,\delta ,q_{0},F\rangle } $$

• $ Q $ — konečná množina stavov
• $ \Gamma $ — konečná množina symbolov na páske
• $ b \in \Gamma $ — prázdny symbol
• $ \Sigma \subseteq \Gamma \setminus \{b\} $ — vstupná abeceda
• $ \delta : (Q \setminus F) \times Γ \rightharpoonup Q \times Γ \times \{L, R\} $ — prechodová funkcia
• $ q_0 \in Q $ — počiatočný stav
• $ F \subseteq Q $ — množina akceptačných stavov

Alebo radšej vizuálne

• A Turing Machine (in the classic style)

Hierarchia výpočtových modelov

• Končné automaty
• Zásobníkové automaty
• Turingove stroje

Výraz λ

expression ::= name                     variable
            |  expression expression    application
            |  λ name . expression      abstraction
            |  ( expression )           grouping

Aplikácia

• f a
• f (g b)
• f a b ≡ (f a) b

Abstrakcia

• λa.b
• λa.f x
• λa.λb.a ≡ λa.(λb.a)
• Aplikácia:
  • (λa.b) x
  • (λa.λb.a) x y ≡ ((λa.(λb.a)) x) y

Haskell

• \a -> b
• \a -> f x
• \a -> \b -> a ≡ \a -> (\b -> a)
• Aplikácia:
  • (\a -> b) x
  • (\a -> \b -> a) x y ≡ ((\a -> (\b -> a)) x) y

Automatický currying

add :: Int -> Int -> Int
add x y = x + y

-- Je v skutočnosti:
add :: Int -> (Int -> Int)
add = \x -> (\y -> x + y)

Premenné

• Viazané premenné — definované v rámci abstrakcie
• Voľné premenné — mimo abstrakcie
• λa.a b
  • a – viazaná
  • b – voľná
• λa.(λb.a b c)
  • a, b – viazané v rámci celej abstrakcie
  • a – voľná v rámci λb.a b c
  • c – voľná

Transformácie

1. Zámena alfa (α) — premenovanie premennej
   λa.a b $\leftrightarrow$ λy.y b
2. Zámena beta (β) — „dosadenie“
   (λa.a b) f $\leftrightarrow$ f b
3. Zámena eta (η) — zjednodušenie
   (λa.f a) $\leftrightarrow$ f

Iba pre viazané premenné. Voľné premenné musia zostať voľnými.

Konflikt mien

(λa.λb.a b) b c $\rightarrow^\beta$ (λb.b b) c — nesprávne

(λa.λb.a b) b c
$\rightarrow^\alpha$ (λa.λx.a x) b c
$\rightarrow^\beta$ (λx.b x) c
$\rightarrow^\beta$ b c

Redukcia

• Normálne poradie redukcie — vonkajšia redukcia zľava
  • vyhodnotenie na základe požiadavky

(λa.λb.a b) (λc.c) d
$\rightarrow^\beta$ (λb.(λc.c) b) d
$\rightarrow^\beta$ (λc.c) d
$\rightarrow^\beta$ d

Eta redukcia v praxi

Eta redukcia: (λa.f a) $\leftrightarrow$ f

double x = 2 * x
double = (2 *)          -- point-free (eta redukcia)

sum xs = foldl (+) 0 xs
sum = foldl (+) 0       -- point-free

A čo hodnoty?

Iba funkcie!

Church encoding

True & False

• Používané na rozhodovanie — vyber medzi dvoma možnosťami
• true = λx.λy.x
• false = λx.λy.y

if then else

• ifThenElse = λp.λt.λe.p t e
• ifThenElse = λp.p

Operátory

• and = λa.λb.a b False = λa.λb.a b a
• or = λa.λb.a True b = λa.λb.a a b
• not = λp.λa.λb.p b a

Kombinátory

Kombinátor — abstrakcia lambda bez voľných premenných.

• I = λa.a — funkcia id
• M = D = λf.f f
• K = λa.λb.a — funkcia const
• KI = λa.λb.b
• C = λf.λa.λb.f b a — funkcia flip

K I → (λa.λb.a) (λa.a) → λb.(λa.a) → λa.(λb.b) → KI

Boolovské operácie pomocou kombinátorov

• true = λx.λy.x = K
• false = λx.λy.y = KI
• ifThenElse = λp.p = I
• not = λp.λa.λb.p b a = C

Pozrime sa na to inák

data Bool = True | False

not :: Bool -> Bool
not True  = False
not False = True

type CBool = forall a. a -> a -> a

cTrue :: CBool
cTrue = \ifTrue ifFalse -> ifTrue

cFalse :: CBool  
cFalse = \ifTrue ifFalse -> ifFalse

cNot :: CBool -> CBool
cNot p = p cFalse cTrue

Čísla

Čísla

• 0 = λf.λx.x
• 1 = λf.λx.f x
• 2 = λf.λx.f (f x)
• 3 = λf.λx.f (f (f x))
• 4 = λf.λx.f (f (f (f x)))

0 = false

Ďalšie čísla

• succ = λn.λf.λx.f (n f x)

succ 2
$M\equiv$ (λn.λf.λx.f (n f x)) (λf.λx.f (f x))
$\rightarrow^\alpha$ (λn.λf.λx.f (n f x)) (λa.λb.a (a b))
$\rightarrow^\beta$ λf.λx.f ((λa.λb.a (a b)) f x)
$\rightarrow^\beta$ λf.λx.f ((λb.f (f b)) x)
$\rightarrow^\beta$ λf.λx.f (f (f x)) = 3

Operátory

• add = λn.λk.n succ k
• mult = λn.λk.λf.n (k f)
• pow = λn.λk.k n

Ďalší kombinátor

• B = λf.λg.λa.f (g a) — kompozícia (.)

• succ = λn.λf. B f (n f)
• mult = B

Dvojica

• pair = λa.λb.λf.f a b
• fst = λp.p K
• snd = λp.p KI

type CPoint = forall r. (Double -> Double -> r) -> r

cPoint :: Double -> Double -> CPoint
cPoint x y = \f -> f x y

movePoint :: CPoint -> Double -> Double -> CPoint
movePoint p dx dy = p (\x y -> cPoint (x + dx) (y + dy))

type CShape = forall r. (CPoint -> Double -> r)  -- Circle
                      -> (CPoint -> CPoint -> r) -- Rectangle
                      -> r
cCircle :: CPoint -> Double -> CShape
cCircle c r = \fCircle fRectangle -> fCircle c r

cRectangle :: CPoint -> CPoint -> CShape
cRectangle p1 p2 = \fCircle fRectangle -> fRectangle p1 p2  

cArea :: CShape -> Double
cArea shape = shape areaCircle areaRectangle
    where
        areaCircle :: CPoint -> Double -> Double
        areaCircle center radius = pi * radius^2
        areaRectangle :: CPoint -> CPoint -> Double
        areaRectangle p1 p2 = 
            p1 (\x1 y1 -> 
            p2 (\x2 y2 -> abs((x2 - x1) * (y2 - y1))))

Pattern matching

• Pattern matching — vetvenie na základe konštruktora dátového typu
• Church encoding — hodnota je funkciou realizujúcou pattern matching
  • prijíma funkcie pre každý konštruktor
  • vracia výsledok aplikácie príslušnej funkcie

Algebraický dátový typ

data List a = Nil | Cons a (List a)

-- Pattern matching:
length :: List a -> Int
length Nil = 0                    -- prvá vetva
length (Cons x xs) = 1 + length xs -- druhá vetva

type CList a = forall r. r -> (a -> r -> r) -> r

cNil :: CList a
cNil = \nil cons -> nil

cCons :: a -> CList a -> CList a
cCons x xs = \nil cons -> cons x (xs nil cons)

cLength :: CList a -> Int
cLength list = list 0 (\x rec -> 1 + rec)

Rekurzia?

Faktoriál

• fact = λn. (isZero n) 1 (mult n (fact (pred n)))
• priradenie mien nie je súčasťou jazyka λ
• preto nemôžeme použiť fact v jeho vlastnej definícii

Faktoriál

• fact' = λf.λn. (isZero n) 1 (mult n (f (pred n)))
• fact = fact' fact – fact je pevný bod funkcie fact'
• fact = Y fact'

Y combinator

Y = (λh.(λx.h (x x)) (λx.h (x x)))

Y g = … = g (Y g)

Haskell

import Data.Function (fix)

fact = fix (\f n -> if n == 0 then 1 else n * f (n-1))

Kombinátory

Kombinátory

• jednoduchší spôsob vyjadrenia výpočtu
• bez abstrakcie (λ)
• iba aplikácia
• jeden zo spôsobov implementácie fukncionálnych jazykov

S K I

Všetky funkcie je možné vyjadriť pomocou troch kombinátorov:

• S = λf.λg.λa.f a (g a)
• K = λa.λb.a
• I = λa.a

Alebo dokonca dvoch, lebo I = S K K

Haskell

• Haskell je nadstavba kalkulu lambda
• λa.a ≡ \a -> a
• id = \a -> a ≡ id a = a
• const = \a -> \b -> a ≡ const a b = a
• Všetky matematické vlastnosti platia aj pre programy
• Teória typov
  • Typed lambda calculus
  • Hindley-Milner type inference

GHC

• „Odcukrenie“ (desugaring) kódu do polymorfného kalkulu λ – System F
• Transformácia lambda výrazov do strojového kódu

Iné jazyky

• Anonymné funkcie
• Voľné premenné — uzávery (closure)