[1,2,3,4] :: Num a => [a] 

((1:[]) : (2:[]) : [])

f :: [[c]] -> ([c], c, [c], [[c]])
f (  x  :  ((  y  :  z  )  :  s)) = (x,y,z,s)
        ^                                    (:) :: a -> [a] -> [a]
    ^a^    ^^^^^^^^^^[a]^^^^^^^^
                           ^
             ^^^^^b^^^^^      ^[b]   ~> (y:z):s :: [b]
                                     substituce a = b
                  ^
              ^c^  ^[c]^             ~> (y:z) :: [c]
             ^^^^[c]^^^^^            substituce b = [c] = a

  (x:(y:z):s) :: [[c]]
   x :: [c]
   (y:z) :: [c]
   s :: [[c]]
   y :: c
   z :: [c]



:t map (take 5)
   ^^^             :: (a -> b) -> [a] -> [b]
        ^^^^       :: Int -> [c] -> [c]
             ^     :: Num d => d            d = Int
       ^^^^^^^^    :: [c] -> [c]
                                   (a -> b) = ([c] -> [c])
                                   a = [c]   b = [c]
  :: [[c]] -> [[c]]

:t map take
   ^^^             :: (a -> b) -> [a] -> [b]
       ^^^^        :: Int -> ([c] -> [c])
                      
                      (a -> b) = (Int -> ([c] -> [c]))
                      a = Int   b = ([c] -> [c])
  :: [Int] -> [ ([c] -> [c]) ]

:t map . take
   ^^^             :: (a -> b) -> ( [a] -> [b] )
         ^^^^      :: Int -> ( [c] -> [c] )
       ^           :: (e -> f) -> (d -> e) -> d -> f

                      (e -> f)  = ((a -> b) -> ( [a] -> [b] ))
                      e = (a -> b)     f = ( [a] -> [b] )

                      (d -> e) = (Int -> ([c] -> [c]))
                      d = Int     e = ([c] -> [c])

                      e = (a -> b) = ([c] -> [c])
                      a = [c]   b = [c]

                      e = [c] -> [c]
                      f = [[c]] -> [[c]]
                      d = Int
  :: Int -> ([[c]] -> [[c]])
  :: Int -> [[c]] -> [[c]]


:t flip zipWith
   ^^^^           :: (a -> b -> c) -> b -> a -> c-- flip f y x = f x y
        ^^^^^^^ :: (d -> e -> f) -> [d] -> ([e] -> [f])
                     
                 (a -> b -> c) = ((d -> e -> f) -> [d] -> ([e] -> [f]))
                 a = (d -> e -> f)
                 b = [d]
                 c = ([e] -> [f])

  :: [d] -> (d -> e -> f) -> ([e] -> [f])
  :: [d] -> (d -> e -> f) -> [e] -> [f]

:t zipWith (,)
   ^^^^^^^     :: (d -> e -> f) -> [d] -> [e] -> [f]
           ^^^ :: a -> b -> (a, b)
                 
                 (d -> e -> f) = a -> b -> (a, b)
                 d = a
                 e = b
                 f = (a, b)
    :: [a] -> [b] -> [(a, b)]

:t \x y -> fst x : snd y
               ^          :: a
                       ^  :: b
           ^^^            :: (c, d) -> c
                   ^^^    :: (e, f) -> f
                          a = (c, d)
                          b = (e, f)
           ^^^^^          :: c
                   ^^^^   :: f
                 ^        :: g -> [g] -> [g]
                          c = g
                          f = [g]
          ^^^^^^^^^^^^^   :: [g]

  :: (g, d) -> (e, [g]) -> [g]

:t getLine >>= readFile
   ^^^^^^^                :: IO String
           ^^^            :: IO a -> (a -> IO b) -> IO b
               ^^^^^^^^   :: String -> IO String
                          
                          IO a = IO String
                          a = String

                          a -> IO b = String -> IO String
                          a = String    IO b = IO String
                                           b = String
   :: IO String

                          IO a = String !! nelze
                          a = IO String -- OK

readFile "a.txt" >>= \a -> readFile "b.txt" >>= putStr . (a ++)
readFile "a.txt" >>= \a -> readFile "b.txt" >>= \b -> (putStr . (a ++)) b
readFile "a.txt" >>= \a -> readFile "b.txt" >>= \b -> putStr ((a ++) b)
readFile "a.txt" >>= \a -> readFile "b.txt" >>= \b -> putStr (a ++ b)

do  a <- readFile "a.txt"
    b <- readFile "b.txt"
    putStr (a ++ b)

comp12 g h x y = g (h x y)   g aplikovaná na 1 argument
                             h je aplikovaná na 2 argumenty

       g :: a -> b
       h :: c -> d -> e
       x :: c
       y :: d

       h x y :: e

       a = e
       g (h x y) :: b

comp12 :: (e -> b) -> (c -> d -> e) -> c -> d -> b

take 5 [ m + n | m <- [0,8..], n <- [0,4] ]
  
[ 0+0, 0+4, 8+0, 8+4, 16+0, 16+4, ... ]
  ^m = 0^   ^m = 8^

  ~> [0,4,8,12,16]

[ (x,y,z) | x <- [1,2], y <- [3,4], z <- [5,6] ]

[ (1,3,5), (1,3,6), (1,4,5), (1,4,6), (2,3,5)... ]


[0,8..] ~>* [0,8,16,24,...]


map (*2) [1,2] ~> [2,4]

foldr f z (x:y:w:[]) ~> x `f` (y `f` (w `f` z))

foldr (\x y -> (x * 2):y ) [] 

foldr (\x y -> (x * 2) : y) [] [1,2] 
    ~> (\x y -> (x*2) : y) 1 (foldr (\x y -> (x*2) : y) [2])
    ~> (\x y -> (x*2) : y) 1 ((\x y -> (x*2) : y) 2 (foldr (\x y -> (2*x) : y) [] []))
    ~> (\x y -> (x*2) : y) 1 ((\x y -> (x*2) : y) 2 []))
    ~> (\x y -> (x*2) : y) 1 (((2*2) : [])
    ~> (\x y -> (x*2) : y) 1 [4]
    ~> (1 * 2) : [4]
    ~> [2,4]


   





  









    



http://www.fi.muni.cz/~glum/vyuka/ib015/