Haskell Functions

practice.hs

--- implementation of useful haskell functions
--- http://fi.muny.cz/data/IB015/IB015-neimp-funkcie.pdf

myAll :: (a -> Bool) -> [a] -> Bool
myAll _ [] = True
myAll predicate (x:l) = if not (predicate x) then False else myAll predicate l

myAnd :: [Bool] -> Bool
myAnd = foldr1 (&&)

myAny :: (a -> Bool) -> [a] -> Bool
myAny _ [] = False
myAny p (x:l) = if p x then True else myAny p l 

myConcat :: [[a]] -> [a]
myConcat = foldl1 (++) 

myConst :: a -> b -> a
myConst x y = x

myCurry :: ((a,b) -> c) -> a -> b -> c
myCurry f a b = f (a,b)

myCycle :: [a] -> [a]
myCycle x = x ++ (myCycle x) 

myDrop :: Int -> [a] -> [a]
myDrop 0 l = l
myDrop nr (_:l) = myDrop (nr-1) l

myDropWhile :: (a -> Bool) -> [a] -> [a]
myDropWhile p (x:l) = if p x then myDropWhile p l else (x:l)

myElem :: Eq a => a -> [a] -> Bool
myElem _ [] = False
myElem e (x:l) = if x == e then True else myElem e l

myEven :: Integral a => a -> Bool
myEven nr = nr `mod` 2 == 0

myFilter :: (a -> Bool) -> [a] -> [a]
myFilter predicate list = [index | index <- list, predicate index]
myFilter' _ [] = []
myFilter' p (x:l) = if p x then x:(myFilter p l) else (myFilter p l)

myFlip :: (a -> b -> c) -> b -> a -> c
myFlip f b a = f a b

myFoldr :: (a -> b -> b) -> b -> [a] -> b
myFoldr _ acc [] = acc 
myFoldr f acc (x:l) = f x (myFoldr f acc l)

myFoldr1 :: (a -> a -> a) -> [a] -> a
myFoldr1 f (x:l) = myFoldr f x l 

myFoldl :: (b -> a -> b) -> b -> [a] -> b
myFoldl _ acc [] = acc
myFoldl f acc (x:l) = myFoldl f (f acc x) l

myFoldl1 :: (a -> a -> a) -> [a] -> a
myFoldl1 f (x:l) = myFoldl f x l

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

myHead :: [a] -> a
myHead [] = error "empty list"
myHead (x:s) = x

myId :: a -> a
myId a = a

myInit :: [a] -> [a]
myInit [x] = []
myInit (x:l) = x:(myInit l)

myIterate :: (a -> a) -> a -> [a]
myIterate f a = a : myIterate f (f a)

myLast :: [a] -> a
myLast [x] = x
myLast (_:l) = myLast l

myLength :: [a] -> Int
myLength [] = 0
myLength (_:l) = 1 + myLength l

myMap :: (a->b) -> [a] -> [b]
myMap f s = [f n | n <- s]
myMap' _ [] = []
myMap' f (x:s) = (f x):(myMap f s)

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

myMaximum :: Ord a => [a] -> a
myMaximum = foldr1 max

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

myMinimum :: Ord a => [a] -> a
myMinimum = foldr1 min

myMod :: Integer -> Integer -> Integer
myMod a b = if a - b < 0 then a else myMod (a-b) b

myNot :: Bool -> Bool
myNot True = False
myNot False = True

myNotElem :: Eq a => a -> [a] -> Bool
myNotElem _ [] = True 
myNotElem a (x:l) = if a == x then False else myNotElem a l 

myNull :: [a] -> Bool
myNull [] = True
myNull _ = False

myOdd :: Integer -> Bool
myOdd x = not (even x) 

myOr :: [Bool] -> Bool
myOr = foldr1 (||)

myProduct :: [Integer] -> Integer
myProduct = foldr1 (*)

myRepeat :: a -> [a] 
myRepeat x = x:myRepeat x

myReplicate :: Int -> a -> [a]
myReplicate 0 _ = []
myReplicate times x = x : myReplicate (times-1) x

myReverse :: [a] -> [a]
myReverse = foldr (\x acc -> acc ++ [x]) [] 

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

mySignum :: Integer -> Integer
mySignum 0 = 0
mySignum x = if x < 0 then -1 else 1

mySum :: [Integer] -> Integer
mySum = foldr1 (+)

myTail :: [a] -> [a]
myTail [] = error "empty list"
myTail (_:l) = l

myTake :: Int -> [a] -> [a]
myTake 0 _ = []
myTake nr (x:l) = x : myTake (nr-1) l

myTakeWhile :: (a -> Bool) -> [a] -> [a]
myTakeWhile _ [] = []
myTakeWhile p (x:l) = if p x then x:myTakeWhile p l else []  

myUncurry :: (a -> b -> c) -> (a, b) -> c
myUncurry f (a,b) = f a b

myUnzip :: [(a,b)] -> ([a], [b])
myUnzip [] = ([], [])
myUnzip ((x,y):l) = (x:fst z , y:snd z) where z = myUnzip l 

myZip :: [a] -> [b] -> [(a,b)]
myZip (x:xs) (y:ys) = (x,y):(myZip xs ys)
myZip _ _ = []

myZipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
myZipWith f (x:xs) (y:ys) = (f x y):(myZipWith f xs ys) 
myZipWith _ _ _ = []