I have been intrigued by functional programming for past couple of years, but never quite prioritized it bigtime. Recently I came across this amazing talk which inspired me to go all-in to learn FP.
I chose Haskell as my preferred language and started with the book The Haskell Road to Logic, Maths and Programming. The reason was primarily because this book induces functional thinking without being too theoretical.
I started solving exercises from the book. This post and a few subsequent ones will document my solutions to some of the exercise problems. These solutions may not be most concise or efficient because I am just beginning to learn Haskell.
Define a method removeFst which removes the first instance of an element from a list
removeFst :: (Eq a) => [a] -> a -> [a] removeFst (x:xs) y = if x == y then xs else x : removeFst xs y
Define a function which counts number of instances of an element in a list
countChars :: Char -> String -> Int countChars y  = 0 countChars y (x:xs) | y == x = 1 + countChars y xs | otherwise = countChars y xs
Define a function named blowUp that takes an string and creates a new string from it by repeating ith character in i times. For example: abcdef should return abbcccddddeeeeeffffff
blowUp :: Int -> String -> String blowUp n [x] = take n [x,x..] blowUp n (x:xs) = (blowUp n [x]) ++ (blowUp (n+1) xs)
Write a function to sort a list of orderable elements
This is a translation of the famous quick sort algorithm to Haskell.
sort :: (Ord a) => [a] -> [a] sort  =  sort [x] = [x] sort (x:xs) = sort greater ++ [x] ++ sort lesser where greater = [y | y <- xs, y > x] lesser = [y | y <- xs, y < x ]
Write a function that takes a big string and a small string and tells whether the big string starts with the small string
startWith :: String -> String -> Bool startWith (x:xs) [y] = y == x startWith (x:xs) (y:ys) = y == x && startWith xs ys
Write a function that takes a big string and a small string and tells whether the big string contains the small string as a substring
I use the previously defined startWith function to solve this.
contains :: String -> String -> Bool contains (x:xs)  = True contains (x:xs) y = startWith (x:xs) y || startWith xs y