Weekend Haskell with Steven - Week 5

data List a = Empty | Entry a (List a)
-- ^^^ Custom list.

-- elem, last, head, tail, length, map, filter, etc.

myList :: [Integer]
myList = [1, 2, 3, 4, 5, 6, 7, 100, 300, 823]

myHead :: [Integer] -> Integer
myHead list = case list of
    []    -> error "No head for empty lists"
    x : _ -> x

myTail :: [Integer] -> [Integer]
myTail list = case list of
    []     -> error "No tail for empty lists"
    _ : xs -> xs

myLast :: [Integer] -> Integer
myLast list = case list of
    []     -> error "No last element for empty lists"
    x : [] -> x
    _ : xs -> myLast xs

myLength :: [Integer] -> Integer
myLength list = case list of
    []     -> 0
    _ : xs -> 1 + myLength xs

myElem :: Integer -> [Integer] -> Bool
myElem a list = case list of
    []     -> False
    x : xs
        | x == a    -> True
        | otherwise -> myElem a xs

addTwoToEverythingIn :: [Integer] -> [Integer]
addTwoToEverythingIn list = case list of
    []     -> []
    x : xs -> (x + 2) : addTwoToEverythingIn xs

doSomethingToEverythingIn :: (Integer -> Integer) -> [Integer] -> [Integer]
doSomethingToEverythingIn f list = case list of
    []     -> []
    x : xs -> (f x) : doSomethingToEverythingIn f xs

getEvenNumbersOutOf :: [Integer] -> [Integer]
getEvenNumbersOutOf list = case list of
    []     -> []
    x : xs
        | even x    -> x : getEvenNumbersOutOf xs
        | otherwise -> getEvenNumbersOutOf xs

myFilter :: (Integer -> Bool) -> [Integer] -> [Integer]
myFilter f list = case list of
    []     -> []
    x : xs
        | f x       -> x : myFilter f xs
        | otherwise -> myFilter f xs

contains :: String -> String -> Bool
contains s1 s2 = case s2 of
    []     -> True
    x : xs
        | head s1 == x && elem x (tail s1) -> contains (truncateString x (tail s1)) xs
        | head s1 == x -> contains (truncateString x s1) xs
        | otherwise    -> False
    where
        truncateString :: Char -> String -> String
        truncateString c string = case string of
            []     -> []
            x : xs
                | x == c    -> xs
                | otherwise -> truncateString c xs

maybeFactorial :: Integer -> Maybe Integer
maybeFactorial a
    | a < 0 = Nothing
    | otherwise = Just (doFactorial a)
    where
        doFactorial :: Integer -> Integer
        doFactorial x
            | x == 0 = 1
            | otherwise = x * (doFactorial (x - 1))