day01bootstrap.hs

mySucc :: Int -> Int
mySucc a = a + 1

mySucc' :: Int -> Int
mySucc' = \a -> a + 1

myIsNeg'''' :: Int -> Bool
myIsNeg'''' a = 0 <= a

myIsNeg''' :: Int -> Bool
myIsNeg''' a = (<=) 0 a

myIsNeg'' :: Int -> Bool
myIsNeg'' = (<=) 0

myIsNeg' :: Int -> Bool
myIsNeg' a = if a < 0 then False else True

myIsNeg :: Int -> Bool
myIsNeg a
    | a < 0 = False
    | otherwise = True

myAbs :: Int -> Int
myAbs a = if a < 0 then (0 - a) else (0 + a)

myAbs' :: Int -> Int
myAbs' a
    | a < 0 = 0 - a
    | otherwise = a

myMin :: Int -> Int -> Int
myMin a b = if a < b then a else b

myMin' :: Int -> Int -> Int
myMin' a b
    | a < b = a
    | otherwise = b

myMin'' :: Int -> Int -> Int
myMin'' a = \b -> if a < b then a else b

myMax :: Int -> Int -> Int
myMax a b = if a > b then a else b

myMax' :: Int -> Int -> Int
myMax' a b
    | a > b = a
    | otherwise = b

myMax'' :: Int -> Int -> Int
myMax'' a = \b -> if a > b then a else b

myTuple :: a -> b -> (a, b)
myTuple a b = (a, b)

myTuple' :: a -> b -> (a, b)
myTuple' = (,)

myTruple :: a -> b -> c -> (a, b, c)
myTruple a b c = (a, b, c)

myFst :: (a, b) -> a
myFst (a, _) = a

myFst' :: (a, b) -> a
myFst' = fst

mySnd :: (a, b) -> b
mySnd (_, b) = b

mySnd' :: (a, b) -> b
mySnd' = snd

mySwap :: (a, b) -> (b, a)
mySwap (a, b) = (b, a)

mySwap' :: (a, b) -> (b, a)
mySwap' x = (mySnd x, myFst x)

mySwap'' :: (a, b) -> (b, a)
mySwap'' x = 
    let f = myFst x
    in let s = mySnd x
    in (s, f)

mySwap''' :: (a, b) -> (b, a)
mySwap''' x = (s, f)
    where
        s = msnd x
        f = myFst x
        msnd (a, b) = b

myHead :: [a] -> a
myHead = head

myHead' :: [a] -> a
myHead' [] = undefined
myHead' (x:xs) = x

myTail :: [a] -> [a]
myTail = tail

myTail' :: [a] -> [a]
myTail' [] = undefined
myTail' (x:xs) = xs

myLength :: [a] -> Int
myLength [] = 0
myLength (x:xs) = 1 + myLength xs

myLength' :: [a] -> Int
myLength' xs = f 0 xs
    where
        f result [] = result
        f result (x:xs) = f (result + 1) xs

myLength'' :: [a] -> Int
myLength'' xs = myFoldl f 0 xs
    where
        f result x = result + 1

myNth :: [a] -> Int -> a
myNth [] _ = undefined
myNth (x:xs) n
    | n == 0 = x
    | n < 0 = undefined
    | otherwise = myNth xs (n - 1)

myNth' :: [a] -> Int -> a
myNth' = (!!)

myTake :: Int -> [a] -> [a]
myTake 0 _ = []
myTake n [] = []
myTake n (x:xs) = x : (myTake (n - 1) xs)

myTake' :: Int -> [a] -> [a]
myTake' 0 _ = []
myTake' n [] = []
myTake' n xs = f [] xs n
    where
        f result (x:xs) n
            | n <= 0 = result
            | otherwise = f (result ++ [x]) xs (n - 1)

myDrop :: Int -> [a] -> [a]
myDrop 0 xs = xs
myDrop n [] = []
myDrop n (x:xs) = myDrop (n - 1) xs

myAppend :: [a] -> [a] -> [a]
myAppend = (++)

myAppend' :: [a] -> [a] -> [a]
myAppend' [] ys = ys
myAppend' xs [] = xs
myAppend' (x:xs) ys = x : (myAppend' xs ys)

myReverse :: [a] -> [a]
myReverse [] = []
myReverse (x:xs) = myAppend' (myReverse xs) [x]

myReverse' :: [a] -> [a]
myReverse' = f []
    where
        f result [] = result
        f result (x:xs) = f (x:result) xs

myInit :: [a] -> [a]
myInit [] = undefined
myInit xs = myTake n xs
    where
        n = (myLength xs) - 1

myInit' :: [a] -> [a]
myInit' [] = undefined
myInit' (x:[]) = []
myInit' (x:xs) = x : (myInit' xs)

myInit'' :: [a] -> [a]
myInit'' xs = myReverse $ tail $ myReverse xs

myInit''' :: [a] -> [a]
myInit''' = myReverse . tail . myReverse

myLast :: [a] -> a
myLast = myHead . myReverse

myLast' :: [a] -> a
myLast' [] = undefined
myLast' (x:[]) = x
myLast' (x:xs) = myLast' xs

myZip :: [a] -> [b] -> [(a, b)]
myZip [] _ = []
myZip _ [] = []
myZip (a:as) (b:bs) = (a, b) : (myZip as bs)

myUnzip :: [(a,b)] -> ([a], [b])
myUnzip [] = ([], [])
myUnzip ((a, b):xs) = let (as, bs) = myUnzip xs in (a:as, b:bs)

myMap :: (a -> b) -> [a] -> [b]
myMap f [] = []
myMap f (x:xs) = (f x) : (myMap f xs)

myFilter :: (a -> Bool) -> [a] -> [a]
myFilter p [] = []
myFilter p (x:xs) =
    let ys = myFilter p xs
    in
        if p x
            then x:ys
            else ys

myFoldl :: (b -> a -> b) -> b -> [a] -> b
myFoldl f b [] = b
myFoldl f b (x:xs) = myFoldl f (f b x) xs

myFoldr :: (a -> b -> b) -> b -> [a] -> b
myFoldr _ x0 [] = x0
myFoldr f x0 (y:ys) = f y (myFoldr f x0 ys)

mySpan :: (a -> Bool) -> [a] -> ([a], [a])
mySpan f xs = (are True, are False)
    where
        are b = myFilter (\x -> (f x) == b) xs

myQuickSort :: (a -> a -> Bool) -> [a] -> [a]
myQuickSort cmp [] = []
myQuickSort f (x:xs) =
    let (upper, lower) = mySpan (f x) xs
    in (myQuickSort f lower) ++ ([x]) ++ (myQuickSort f upper)