Haskell: Lists in Haskell

  --Find the maximum element in a List
--e.g. maxi [1,2,-1,100,3,4] -> 100
maxi :: [Int] -> Int
maxi [] = 0
maxi (x:xs) = foldl (\x acc -> if (x > acc) then x else acc) x (xs)
  

  --Find the minimum element in a List
--e.g. mini [1,2,-1,100,3,4] -> -1
mini :: [Int] -> Int
mini [] = 0
mini (x:xs) = foldl (\x acc -> if (x < acc) then x else acc) x (xs)
  

  --Calculates the length of a list of integers
--e.g. len [1,2,3,4,100] -> 5
len :: [Int] -> Int
len [] = 0
len (x:xs) = 1 + len (xs)
  

  --Calculates the length of a string
--e.g. lenStr "abcfd" -> 5
lenStr :: [char] -> Int
lenStr [] = 0
lenStr (x:xs) = 1 + lenStr (xs)
  

  --calculates the sum of a list
--e.g. sumLst [1,2,3,4] -> 1+2+3+4 = 10
sumLst :: [Int] -> Int
sumLst [] = 0
sumLst (x:xs) = x + sumLst xs
  

  --calculates the alternating sum of a list
--e.g. altSum [1,2,3,4,4,6,-2,-3] -> 1-2+3-4+4-6+(-2)-(-3) = -3
altSum :: [Int] -> Int
altSum [] = 0
altSum (x:xs) = x + (-1 * altSum xs)
  

  --Removes an element in a list  
--e.g. removeElt [1,2,3,2,2,3,4] 2 -> [1,3,3,4]  
removeElt :: (Eq a) => [a] -> a -> [a]  
removeElt [] a = []  
removeElt list a = filter (\x -> (x /= a)) list
  

  --get the last element in a list  
--getLast [1,2,3,30,40,22] -> [22]  
getLast :: (Eq a) => [a] -> [a]  
getLast [] = []  
getLast (x:xs) = if (xs == []) then [x] else getLast (xs)
  

  --compares if two lists are equals
--e.g. compareList [1,2,3] [1,2,3] -> True
compareList :: (Eq a) => [a] -> [a] -> Bool
compareList [] [] = True
compareList x [] = False
compareList [] y = False
compareList (x:xs) (y:ys) = (x == y) && compareList (xs) (ys)
  

  --prepend an element in a List  
--prependElt 1 [2,3,4] -> [1,2,3,4]  
prependElt :: a -> [a] -> [a]  
prependElt a lst = a:lst
  

  --appends an element at the end of a list  
--e.g. lastAppend [1,2,3] 4 -> [1,2,3,4]  
lastAppend [] a = [a]  
lastAppend (x:xs) a = x:lastAppend xs a
  

  --appends two lists together  
--appendLists [1,2,3] [4,5,6] -> [1,2,3,4,5,6]  
appendLists :: [a] -> [a] -> [a]  
appendLists [] lst' = lst'  
appendLists lst [] = lst  
appendLists (x:xs) lst = x:(appendLists (xs) lst)
  

  --reverse a list order  
--e.g. reverseList [1,2,3,4] -> [4,3,2,1]  
reverseList :: [a] -> [a]  
reverseList [] = []  
reverseList (x:xs) = (reverseList xs) ++ [x]
  

  --Makes out of all odd numbers a even number by adding 1 to the odd numbers  
--e.g. makeAllEven [1,2,3,4,5] -> [2,2,4,4,6]  
makeAllEven list = map (\x -> if (mod x 2 /= 0) then x+1 else x) list
  

  --Checks if an element is in a list  
--e.g. contain [1,2,3,4,40] 4 -> True  
contain :: (Eq a) => [a] -> a -> Bool  
contain [] a = False  
contain (x:xs) a = if (a == x) then (True) else (if (contain (xs) a) then True else False)
  

  --checks if an element already exists in a list then keep just the last one and remove all duplicates  
--the contain function is the function above this one  
--e.g. removeDup [1,2,3,4,3,3,3,3] -> [1,2,4,3]  
removeDup :: (Eq a) => [a] -> [a]  
removeDup [] = []  
removeDup (x:xs) = if (contain xs x) then (removeDup xs) else (x:(removeDup xs))
  

  --remove all negative numbers  
--e.g. removeNeg [1,2,-4,3,-6,4] -> [1,2,3,4]  
removeNeg :: [Int] -> [Int]  
removeNeg list = filter (\x -> (x > 0)) list
  

  --makes all negative numbers positive  
--e.g. posNeg [1,2,-3,4,-5,6] -> [1,2,3,4,5,6]  
posNeg list = map (\x -> if (x < 0) then (x * (-1)) else x) list