Kalábovi

Tato stránka je pouze pro čtení. Můžete si pouze prohlédnout zdrojový kód, ale ne ho měnit. Zeptejte se správce, pokud si myslíte, že něco není v pořádku.
====== Funkcionální a logické programování ======
{{ https://www.verifyrecruitment.com/blog/wp-content/uploads/2014/08/haskell-spock-jpg.jpg?300|Haskell? Yeah, I use it to program our starship.}}
===== Lambda kalkul =====
[[wp>Lambda calculus]], [[wp>Church encoding]]
  * **α-konverze** -- λ//x//.//xy// →<sub>α</sub> λ//z//.//zy//, substituce((Bacha na volné a vázané proměnné!))
  * **β-konverze** -- (λ//xz//.//xz//)(//xy//) →<sub>β</sub> λ//z//.//xyz//, aplikace funkce
  * **η-konverze** -- λ//x//.(//uv//)//x// →<sub>η</sub> //uv//

^  ''T''  ^  λ//xy//.//x//  ^  λ//xy//.//xy//  ^  λ//xy//.//x//  ^  λ//xy//.//x//  ^
^  ''F''  ^  λ//xy//.//y//  ^  λ//xy//.//y//  ^  λ//xy//.//yx//  ^  λ//xy//.//xy//  ^
^  ''NOT''  |  λ//x//.//x''FT''//  |  λ//x//.//x//(λ//z//.//''F''//)//''T''//  |  λ//p//.//p''F''//(λ//r//.//''T''//)  |  λ//x//.//x''FT''//  |
^  ''AND''  |  λ//xy//.//xy''F''//  |  λ//xy//.//y//(λ//z//.//x//)//''F''//  |  λ//ab//.//ab//(λ//r//.//''F''//)  |  λ//xy//.//xy''F''//  |
^  ''OR''  |  λ//xy//.//x''T''y//  |  λ//xy//.//y//(λ//z//.//''T''//)//x//  |  λ//ab//.//a''T''//(λ//r//.//b//)  |  λ//xy//.//x''T''y//  |
^  ''XOR''  |  λ//xy//.//x//(//''NOT'' y//)//y//  |  λ//xy//.//x//(λ//z//.(//''NOT'' y//))//y//  |  λ//xy//.//x//(//''NOT'' y//)(λ//z//.//y//)  |  λ//xy//.//x//(//''NOT'' y//)//y//  |
^  ''EQ''  |  λ//xy//.//xy//(//''NOT'' y//)  |  λ//xy//.//x//(λ//z//.//y//)(//''NOT'' y//)  |  λ//xy//.//xy//(λ//z//.(//''NOT'' y//))  |  λ//xy//.//xy//(//''NOT'' y//)  |

  <Presci> Pitel: no ne vsechny, ale kdyz ti true nebo false budou vracet dve hodnodty (LET TRUE = \a b.b a, tak tu jednu musis nejak zabit (treba v notu)
  <Presci> a zabijes ji tam, ze ji nahradis \a.False treba, takze "a" se zahodi a zbyte False

^  0, 1, 2, 3, ...  |λ//fx//.//x//\\ λ//fx//.//fx//\\ λ//fx//.//f//(//fx//)\\ λ//fx//.//f//(//f//(//fx//))\\ λ//fx//.//fⁿx//|
^  succ  |  λ//nfx//.//f//(//nfx//)  |
^  add  |  λ//mnfx//.//mf//(//nfx//)  |
^  mult  |  λ//mnf//.//m//(//nf//)  |
^  //mⁿ//  |  λ//mn//.//nm//  |
^  iszero  |  λ//m//.//m//(λ//v//.//''FALSE''//)//''TRUE''//  |
^  if then else  |  λ//ctf//.//ctf//  |
^  tuple  |  λ//fse//.//efs//  |
^  first  |  λ//p//.//p//(λ//ab//.//a//)((''TRUE''))  |
^  second  |  λ//p//.//p//(λ//ab//.//b//)((''FALSE''))  |
===== Haskell =====
  * [[http://learnyouahaskell.com|Learn You a Haskell for Great Good!]]
  * **[[https://gist.github.com/2634678|Gist]]**
===== Strukturální indukce =====
[[wp>Structural induction]], [[http://www.haskell.org/onlinereport/standard-prelude.html|Standard Prelude]]

<code haskell>
foldr            :: (a -> b -> b) -> b -> [a] -> b
foldr f z []     =  z
foldr f z (x:xs) =  f x (foldr f z xs)
</code>
<code haskell>
foldl            :: (a -> b -> a) -> a -> [b] -> a
foldl f z []     =  z
foldl f z (x:xs) =  foldl f (f z x) xs
</code>
<code haskell>
map :: (a -> b) -> [a] -> [b]
map f []     = []
map f (x:xs) = f x : map f xs
</code>
<code haskell>
(++) :: [a] -> [a] -> [a]
[]     ++ ys = ys
(x:xs) ++ ys = x : (xs ++ ys)
</code>
<code haskell>
take                   :: Int -> [a] -> [a]
take n _      | n <= 0 =  []
take _ []              =  []
take n (x:xs)          =  x : take (n-1) xs
</code>
<code haskell>
drop                   :: Int -> [a] -> [a]
drop n xs     | n <= 0 =  xs
drop _ []              =  []
drop n (_:xs)          =  drop (n-1) xs
</code>
<code haskell>
head             :: [a] -> a
head (x:_)       =  x
head []          =  error "Prelude.head: empty list"
</code>
<code haskell>
tail             :: [a] -> [a]
tail (_:xs)      =  xs
tail []          =  error "Prelude.tail: empty list"
</code>
<code haskell>
last             :: [a] -> a
last [x]         =  x
last (_:xs)      =  last xs
last []          =  error "Prelude.last: empty list"
</code>
<code haskell>
init             :: [a] -> [a]
init [x]         =  []
init (x:xs)      =  x : init xs
init []          =  error "Prelude.init: empty list"
</code>
<code haskell>
length           :: [a] -> Int
length []        =  0
length (_:l)     =  1 + length l
</code>
<code haskell>
filter :: (a -> Bool) -> [a] -> [a]
-- filter p xs = [x | x <- xs, p x]
filter p []                 = []
filter p (x:xs) | p x       = x : filter p xs
                | otherwise = filter p xs
</code>
<code haskell>
takeWhile               :: (a -> Bool) -> [a] -> [a]
takeWhile p []          =  []
takeWhile p (x:xs) 
            | p x       =  x : takeWhile p xs
            | otherwise =  []
</code>
<code haskell>
dropWhile               :: (a -> Bool) -> [a] -> [a]
dropWhile p []          =  []
dropWhile p xs@(x:xs')
            | p x       =  dropWhile p xs'
            | otherwise =  xs
</code>
<code haskell>
zipWith          :: (a->b->c) -> [a]->[b]->[c]
zipWith z (a:as) (b:bs)
                 =  z a b : zipWith z as bs
zipWith _ _ _    =  []
</code>
===== Prolog =====
[[99pl]]
Kalábovi

Uživatelské nástroje

Nástroje pro tento web

Nástroje pro stránku
