Rozdíly

Zde můžete vidět rozdíly mezi vybranou verzí a aktuální verzí dané stránky.

--- flp:start [25. 05. 2012, 12.33:54] – [Haskell] smazany predelane priklady pitel
+++ flp:start [02. 08. 2026, 04.21:03] (aktuální) – odstraněno - upraveno mimo DokuWiki (Neznámé datum) 127.0.0.1
@@ Řádek 1: / Řádek 1: @@
-====== Funkcionální a logické programování ======
-{{ https://cryptoanarchy.org/w/images/a/a9/Spock-uses-haskell.png?300|Haskell? Yeah, I use it to program our starship.}}
-===== Lambda kalkul =====
-[[wp>Lambda calculus]], [[wp>Church encoding]], http://safalra.com/science/lambda-calculus
-  * **α-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]]**
-<code haskell>
---Sepsal Mike T
-import IO
-{-
--- Jen pro pripomenuti:
-data IOMode =  ReadMode | WriteMode | AppendMode | ReadWriteMode
-getLine :: IO String
-putStrLn :: String -> IO ()
-type FilePath = [Char] -- tj. jméno souboru
-openFile :: FilePath -> IOMode -> IO Handle
-hIsEOF :: Handle -> IO Bool
-hGetLine :: Handle -> IO String
-hClose :: Handle -> IO ()
-hGetContents :: Handle -> IO String
-readFile :: FilePath -> IO String
-lines :: String -> [String]
-unlines :: [String] -> String
-words :: String -> [String]
-unwords :: [String] -> String
--}
--- Spocte pocet radku v souboru.
-countLines file = do
-  content <- readFile file
-  putStrLn $ show $ length $ lines content
--- Spocte pocet slov v prvnich n radcich v souboru.
-countWordsN file n = do
-    content <- readFile file
-    putStrLn $ show $ length $ words $ unlines $ take n $ lines content
--- Prokladane vypise obsah souboru na vystup.
-prokladane file1 file2 = do
-     h1 <- openFile file1 ReadMode
-     h2 <- openFile file2 ReadMode
-     c1 <- hGetContents h1
-     c2 <- hGetContents h2
-     write (lines c1) (lines c2)
-     hClose h1
-     hClose h2
-   where
-    write [] _ = return ()
-    write _ [] = return ()
-    write (x:xs) (y:ys) = do
-      putStrLn x
-      putStrLn y
-      write xs ys
--- Vypise obsah souboru s cisly radky.
-printWithLineNumber file = do
-    h <- openFile file ReadMode
-    c <- hGetContents h
-    write (lines c) 1
-    hClose h
-  where
-    write [] _ = return ()
-    write (x:xs) n = do
-      putStrLn $ (show n) ++ ". " ++ x
-      write xs (n+1)
--- Vypise radky na vystup, ktere jsou v obou souborech, ve stejnem poradi.
-copyOut file1 file2 = do
-    h1 <- openFile file1 ReadMode
-    h2 <- openFile file2 ReadMode
-    c1 <- hGetContents h1
-    c2 <- hGetContents h2
-    putStr $ unlines $ [x | x <- lines c1, y <- lines c2, x == y]
-    hClose h1
-    hClose h2
--- Nacte radek a slova vypise v opacnem poradi.
-reverseOut = do
-  line <- getLine
-  if null line
-    then return ()
-    else do
-      putStrLn $ rev line
-      reverseOut
-  where rev l = unwords $ foldl (\acc x -> x : acc) []  (words l)
-</code>
-===== 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>
-===== Prolog =====
-[[99pl]]

Kalábovi

Uživatelské nástroje

Nástroje pro tento web

Rozdíly

Nástroje pro stránku