Haskell Book Chapter 10 exercise

chapter10.hs

module Test where

import Data.Time
import Data.Maybe (catMaybes)

data DatabaseItem = DbString String
                  | DbNumber Integer
                  | DbDate   UTCTime
                  deriving (Eq, Ord, Show)

theDatabase :: [DatabaseItem]
theDatabase =
  [
    DbDate (UTCTime (fromGregorian 1911 5 1) (secondsToDiffTime 34123))
    , DbNumber 8000
    , DbString "Hello, world!"
    , DbDate (UTCTime (fromGregorian 1921 5 1) (secondsToDiffTime 34123))
    , DbNumber 4000
  ]

filterDbDate :: [DatabaseItem] -> [UTCTime]
filterDbDate =
  foldr keepUTCTime []
    where keepUTCTime a b =
            case a of
              (DbDate date) -> date : b
              _ -> b

filterDbNumber :: [DatabaseItem] -> [Integer]
filterDbNumber =
  foldr f []
    where f (DbNumber a) b = a : b
          f _ b = b

getDate :: DatabaseItem -> Maybe UTCTime
getDate (DbDate t) = Just t
getDate _ = Nothing

filterDbDate' :: [DatabaseItem] -> [UTCTime]
filterDbDate' db = catMaybes xs
  where xs = fmap getDate db

mostRecent :: [DatabaseItem] -> UTCTime
mostRecent = maximum . filterDbDate

sumDb :: [DatabaseItem] -> Integer
sumDb = sum . filterDbNumber

avgDb :: [DatabaseItem] -> Double
avgDb = average . filterDbNumber
  where average [] = 0
        average xs = fromIntegral (sum xs) / fromIntegral (length xs)


myAnd :: [Bool] -> Bool
myAnd = foldr (&&) True --and

myOr :: [Bool] -> Bool
myOr = foldr (||) False --or

myAny :: (a -> Bool) -> [a] -> Bool
myAny p = myOr . map p

myElem :: Eq a => a -> [a] -> Bool
myElem e = myAny (\a -> e == a)

myReverse :: [a] -> [a]
myReverse = foldl (flip (:)) []

myMap :: (a -> b) -> [a] -> [b]
myMap f = foldr ((:) . f) []

myFilter :: (a -> Bool) -> [a] -> [a]
myFilter p = foldr f []
  where f a b = if p a then a : b else b

squish :: [[a]] -> [a]
squish = foldr (++) [] --concat

squishMap :: (a -> [b]) -> [a] -> [b]
squishMap f = foldr ((++) . f) []

squishAgain :: [[a]] -> [a]
squishAgain = squishMap id --using squishMap