8. (mókás) gyakorlat

numbersMadeOfOnes :: [Integer]
numbersMadeOfOnes = iterate ( (+ 1) . (* 10) ) 1

numbersMadeOfThrees :: [Integer]
numbersMadeOfThrees = iterate ( (+ 3) . (* 10) ) 3
-- vagy
numbersMadeOfThrees = map (*3) numbersMadeOfOnes

numbersMadeOfThreesAndOne :: [Integer]
numbersMadeOfThreesAndOne = iterate ((+1) . (*10) . (+2)) 1
-- epic, imagine having maths skills

dropSpaces :: String -> String
dropSpaces = dropWhile (== ' ')

trim :: String -> String
trim = reverse . dropSpaces . reverse . dropSpaces

maximumOfMinimums :: Ord a => [[a]] -> a
maximumOfMinimums = maximum . map minimum

mapMap :: (a -> b) -> [[a]] -> [[b]]
mapMap f xs = map (\x -> map f x) xs
-- vagy
mapMap f xs = map (map f) xs
-- vagy
mapMap f    = map (map f)
-- vagy
mapMap      = map . map

firstLetters :: String -> String
firstLetters = unwords . map ((:[]) . head) . words
-- vagy
firstLetters = unwords . map (take 1) . words
-- vagy
import Data.List
firstLetters = intersperse ' ' . map head . words

monogram :: String -> String
monogram = unwords . map ((:".") . head) . words
-- vagy
import Data.List
monogram = (++ ".").(intercalate ". " . map (take 1) . words)

reduce :: Eq a => [a] -> [a]
reduce = map head . group

uniq :: Ord a => [a] -> [a]
uniq = reduce . sort
-- vagy
uniq = nub . sort -- a `nub` az megjelenési sorrendben szedi ki az ismételt elemeket
-- vagy
uniq = sort . nub

repeated :: Ord a => [a] -> [a]
repeated = map head . filter ((>1) . genericLength) . group . sort
repeated = map head . filter (longerThan 1) . group . sort
    where
        longerThan :: Integral i => i -> [a] -> Bool
        longerThan n [] = n < 0
        longerThan n (x:xs) = n <= 0 || longerThan (n-1) xs

until :: (a -> Bool) -> (a -> a) -> a -> a
until p f a = head $ dropWhile (not . p) $ iterate f a
-- vagy
until p f   = head . dropWhile (not . p) . iterate f
-- vagy
until p     = ((head . dropWhile (not . p)) .) . iterate -- AAAAAAAAAAAAA

flip' :: (a -> b -> c) -> (b -> a -> c)
flip' f b a = f a b

uncurry' :: (a -> b -> c) -> ((a, b) -> c)
-- **jobb** zárójel elhagyható:
uncurry' :: (a -> b -> c) -> (a, b) -> c
uncurry' f (a, b) = f a b

curry' :: ((a, b) -> c) -> (a -> b -> c)
-- itt is
curry' :: ((a, b) -> c) -> a -> b -> c
curry' f a b = f (a,b)

all :: (a -> Bool) -> [a] -> Bool
all p xs = and $ map p xs
-- vagy
all p = and . map p
-- vagy
all = (and . ) . map

any :: (a -> Bool) -> [a] -> Bool
any p xs = or $ map p xs
-- vagy
any p = or . map p
-- vagy
any = (or . ) . map

elem :: Eq a => a -> [a] -> Bool
elem e = any (== e)
elem   = any . (==)