module Exercises where

-- direct recursion, not using (&&)
myAnd :: [Bool] -> Bool
myAnd [] = True
myAnd (x:xs) =
  if x == False
  then False
  else myAnd xs

-- direct recursion, using (&&)
myAnd' :: [Bool] -> Bool
myAnd' [] = True
myAnd' (x:xs) = x && myAnd' xs

-- 1
myOr :: [Bool] -> Bool
myOr [] = False
myOr (x:xs) = x || myOr xs

-- 2
myAny :: (a -> Bool) -> [a] -> Bool
myAny f xs = myOr $ map f xs

-- 3
myElem :: Eq a => a -> [a] -> Bool
myElem _ [] = False
myElem y (x:xs) = (x == y) || (myElem y xs)

-- 4
myReverse :: [a] -> [a]
myReverse [] = []
myReverse (x:xs) = (myReverse xs) ++ [x]

-- 5
squish :: [[a]] -> [a]
squish = squish' []
    where squish' acc [] = acc
          squish' acc (x:xs) = x ++  (squish' acc xs)

-- 6
squishMap :: (a -> [b]) -> [a] -> [b]
squishMap _ [] = []
squishMap f (x:xs) = (f x) ++ (squishMap f xs)

-- 7
squishAgain :: [[a]] -> [a]
squishAgain x = squishMap id x

-- 8
myMaximumBy :: (a -> a -> Ordering)
            -> [a] -> a
myMaximumBy f (x:xs) = myMaximumBy' x xs
    where myMaximumBy' m [] = m
          myMaximumBy' m (y:ys)
            | f y m == GT = myMaximumBy' y ys
            | otherwise = myMaximumBy' m ys

-- 9
myMinimumBy :: (a -> a -> Ordering)
            -> [a] -> a
myMinimumBy f (x:xs) = myMinimumBy' x xs
    where myMinimumBy' m [] = m
          myMinimumBy' m (y:ys)
            | f y m == LT = myMinimumBy' y ys
            | otherwise = myMinimumBy' m ys

-- 10
myMaximum :: (Ord a) => [a] -> a
myMaximum = myMaximumBy compare

myMinimum :: (Ord a) => [a] -> a
myMinimum = myMinimumBy compare