Add the haskell book

Haskell-book/10/Db.hs

@@ -0,0 +1,52 @@
+module Db where
+
+import Data.Time
+
+data DatabaseItem = DbString String
+                  | DbNumber Integer
+                  | DbDate UTCTime
+                  deriving (Eq, Ord, Show)
+
+theDatabase :: [DatabaseItem]
+theDatabase =
+    [ DbDate (UTCTime (fromGregorian 1911 5 1) (secondsToDiffTime 34123))
+    , DbNumber 9001
+    , DbString "Hello, world!"
+    , DbDate (UTCTime (fromGregorian 1921 5 1) (secondsToDiffTime 34123))
+    ]
+
+filterDbDate :: [DatabaseItem] -> [UTCTime]
+filterDbDate xs = foldr f1 [] (filter f2 xs)
+    where f1 (DbDate d) acc = d : acc
+          f2 (DbDate d) = True
+          f2 _          = False
+
+filterDbNumber :: [DatabaseItem] -> [Integer]
+filterDbNumber xs = foldr f1 [] (filter f2 xs)
+    where f1 (DbNumber d) acc = d : acc
+          f2 (DbNumber d) = True
+          f2 _            = False
+
+mostRecent :: [DatabaseItem] -> UTCTime
+mostRecent xs = maximum (filterDbDate xs)
+
+sumDb :: [DatabaseItem] -> Integer
+sumDb xs = foldr (+) 0 (filterDbNumber xs)
+
+avgDb :: [DatabaseItem] -> Double
+avgDb xs = (fromIntegral (sumDb xs)) / (fromIntegral (length (filterDbNumber xs)))
+
+fibs :: [Integer]
+fibs = 1 : scanl (+) 1 fibs
+
+fibs20 :: [Integer]
+fibs20 = take 20 (1 : scanl (+) 1 fibs)
+
+fibs100 :: [Integer]
+fibs100 = takeWhile (\x -> x < 100) fibs
+
+fibsN :: Int -> Integer
+fibsN x = fibs !! x
+
+factorial :: [Integer]
+factorial = scanl (*) 1 [1..]

Haskell-book/10/Exercise.hs

@@ -0,0 +1,53 @@
+module Exercise where
+
+stops :: String
+stops = "pbtdkg"
+
+vowels :: String
+vowels = "aeiou"
+
+stopVowelStop :: [(Char, Char, Char)]
+stopVowelStop = filter p [(x, y, z) | x <- stops, y <- vowels, z <- stops]
+    where p (a, _, _) = a == 'p'
+
+seekritFunc :: String -> Double
+seekritFunc x = (/) (fromIntegral (sum (map length (words x)))) (fromIntegral (length (words x)))
+
+myAnd :: [Bool] -> Bool
+myAnd = foldr (&&) True
+
+myOr :: [Bool] -> Bool
+myOr = foldr (||) False
+
+myAny :: (a -> Bool) -> [a] -> Bool
+myAny f = myOr . map f
+
+myElem :: Eq a => a -> [a] -> Bool
+myElem x = foldr (\y z -> z || (y == x)) False
+
+myElem' :: Eq a => a -> [a] -> Bool
+myElem' needle = any (\x -> x == needle)
+
+myReverse :: [a] -> [a]
+myReverse = foldl (flip (:)) []
+
+myMap :: (a -> b) -> [a] -> [b]
+myMap f = foldr (\x y -> (f x) : y) []
+
+myFilter :: (a -> Bool) -> [a] -> [a]
+myFilter f = foldr (\x xs -> if f x then x : xs else xs) []
+
+squish :: [[a]] -> [a]
+squish = foldr (++) []
+
+squishMap :: (a -> [b]) -> [a] -> [b]
+squishMap f xs = foldr (++) [] (map f xs)
+
+squishAgain :: [[a]] -> [a]
+squishAgain = squishMap id
+
+myMaximumBy :: (a -> a -> Ordering) -> [a] -> a
+myMaximumBy f (z:zs) = foldl (\x y -> if (f x y) == GT then x else y) z zs
+
+myMinimumBy :: (a -> a -> Ordering) -> [a] -> a
+myMinimumBy f (z:zs) = foldl (\x y -> if (f x y) == LT then x else y) z zs