7. gyakorlat

\x -> x+1

\alma körte -> alma + 2 * körte

f :: Int -> (Int -> Int)
f alma = \körte -> alma + 2 * körte

-- Ez ugyanaz, mint a ...

f :: Int -> Int -> Int
f alma körte = alma + 2 * körte

-- És a...
f :: (Int -> (Int -> Int))
f = \alma -> \körte -> alma + 2 * körte

-- :t ((\alma körte -> alma + 2 * körte) 1)
-- Int -> Int
-- ez egy parciálisan applikált függvény

addAll1 :: Num a => [a] -> [a]
addAll1 [] = []
addAll1 (x:xs) = (x + 1) : addAll1 xs

toUpperAll :: String -> String
toUpperAll [] = []
toUpperAll (x:xs) = toUpper x : toUpperAll xs

-- This is where the fun begins c:
map' :: (a -> b) -> [a] -> [b]
map' _ [] = []
map' f (x:xs) = f (x) : map f xs

g :: Num a => a -> a
g x = x + 1

-- működik lambdával, currying, másik függvényekkel
map' (+1) [1,2,3] == [2,3,4] -- epic
map' (\x -> x+1) [1,2,3] == [2,3,4] -- also works
map' g [1,2,3] == [2,3,4] -- also works

filter' :: (a -> Bool) -> [a] -> [a]
filter' _ [] = []
filter' f (x:xs)
    | f x       = x : filter' f xs
    | otherwise =     filter' f xs

takeWhile :: (a -> Bool) -> [a] -> [a]
takeWhile _ [] = []
takeWhile p (x:xs)
    | p x = x : takeWhile p xs
    | otherwise = []

dropWhile :: (a -> Bool) -> [a] -> [a]
dropWhile _ [] = []
dropWhile p l@(x:xs)
    | p x = dropWhile p xs
    | otherwise = l

span :: (a -> Bool) -> [a] -> ([a], [a])
span _ [] = ([], [])
span f list@(x:xs)
    | f x = (x:as, bs) -- elem hozzáadása az első listához, ha arra teljesül a `p`
    | otherwise = ([], list) -- más esetben második listához hozzáfűzés
    where 
        (as, bs) = span f xs

break :: (a -> Bool) -> [a] -> ([a], [a])
break f xs = span (\x -> not (p x)) xs
break f = span (\x -> not (p x))
break f = span (not . p) -- chad move

(.) :: (b->c) -> (a->b) -> (a->c)
(.) f g x = f ( g x )

iterate :: (a -> a) -> a -> [a]
iterate f a = a:iterate f (f a)

infixr 0 $
($) :: (a->b) -> a -> b
($) f a = f a

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith f (a:as) (b:bs) = f a b : zipWith f as bs
zipWith _ _ _           = []

differences :: Num a => [a] -> [a]
-- shift values to the right once, then do the funny
differences xs = zipWith' (-) (tail xs) xs