Rebuilding listsEdit
Exercises 

Write the following functions and test them out. Don't forget the type signatures.
take , drop , and sum . 
1.
takeInt :: Int > [a] > [a]
takeInt 0 _ = []
takeInt _ [] = []
takeInt n (x:xs) = x : takeInt (n1) xs
2.
dropInt :: Int > [a] > [a]
dropInt 0 list = list
dropInt _ [] = []
dropInt n (x:xs) = dropInt (n1) xs
3.
sumInt :: [Int] > Int
sumInt [] = 0
sumInt (x:xs) = x + sumInt xs
4.
 USING Helper function 
scanSum :: [Int] > [Int]
scanSum = scanSum' 0
scanSum' :: Int > [Int] > [Int]
scanSum' tot [] = []
scanSum' tot (x:xs) = x + tot : scanSum' (x + tot) xs
 USING takeInt, dropInt and sumInt 
scanSum :: [Int] > [Int]
scanSum [] = []
scanSum (x:[]) = [x]
scanSum (x:xs) = x : scanSum ((x + sumInt (takeInt 1 xs)) : dropInt 1 xs)
 USING (a:b:as) 
scanSum :: [Int] > [Int]
scanSum [] = []
scanSum (a:[]) = a:[]
scanSum (a:b:as) = a : scanSum ((a+b):as)
5.
diffs :: [Int] > [Int]
diffs [] = []
diffs (x:[]) = []
diffs (x:y:xs) = (yx) : diffs (y:xs)
 alternative with the auxiliary function:
diffsAlt :: [Int] > [Int]
diffsAlt [] = []
diffsAlt (x:xs) = diffsAlt' (x:xs) xs
where
diffsAlt' :: [Int] > [Int] > [Int]
diffsAlt' _ [] = []
diffsAlt' [] _ = []
diffsAlt' (x:xs) (y:ys) = (yx): diffsAlt' xs ys
The map
functionEdit
Exercises 


1.
In one block of code. In addition to the variations here, you can also replace Int by Integer:
negateList, negateList2 :: [Int] > [Int]
negateList = map negate
negateList2 list = map negate list
factorList, factorList2 :: [Int] > [[Int]]
factorList = map factors
factorList2 list = map factors list
 There are a few possible variations for this one. If yours is different, check with a Haskell interpreter to see if it's correct.
 The dots are just another higherorder trick. (g . f) x = g(f(x))
negateFactorList, negateFactorList2, negateFactorList3, negateFactorList4 :: [Int] > [[Int]]
negateFactorList = map (negateList . factors)
negateFactorList2 = map negateList . factorList
negateFactorList3 list = map (negateList . factors) list
negateFactorList4 list = map (map negate) (map factors list)
2.
Here's my Run Length Encoding, although I don't see how I'm supposed to use map
. (Maybe if the text explained group
?)
encode :: Eq a => [a] > [(Int,a)]
encode [] = []
encode [x] = [(1,x)]
encode (x:y:xs)  x == y = succHead (encode (y:xs))
 otherwise = (1,x) : encode (y:xs)
succHead :: [(Int,a)] > [(Int,a)]
succHead [] = []  this should never be called by encode on any input
succHead ((n,x):ps) = (n+1,x):ps
decode :: [(Int,a)] > [a]
decode [] = []
decode ((n,x):ps) = (repetition n x) ++ decode ps
repetition :: Int > a > [a]
repetition 0 _ = []  this should never be called by decode on a properly formatted input
repetition n x = x:(repetition (n1) x)
Here is my version which uses group
and map
in a single function with a anonymous helper function (I only included the solution for encode because in my opinion there are a few very useful functions that need to be introduced prior to going through the other functions. concatMap
, which can be used as an inverse of map and replicate
, which can be used for repetition.):
import Data.List
encode :: [Char] > [(Int, Char)]
encode list = map go (group list)
where
go (x:xs) = (length (x:xs), x)
And here is mine using map
. To understand what the group
command did, I visited hayoo. If you aren't familiar with hayoo yet, take a couple of minutes to try it now. It's very useful.
import Data.List
lenwhat :: [Char] > (Int, Char)
lenwhat x = (length x, head x)
encode :: [Char] > [(Int, Char)]
encode "" = []
encode x = map lenwhat (group x)
decode :: [(Int, Char)] > [Char]
decode [] = ""
decode ((l, w):xs) = (replicate l w) ++ decode xs
toRleString :: [(Int, Char)] > [Char]
toRleString [] = ""
toRleString ((l, w):xs) = show l ++ w : rlestring xs
This is a version I made to learn to use map and group.
import Data.List
count_tuple (x:xs) = (length (x:xs) , x)
map count_tuple (group "aaaaaabbbbbcccccccaaaaaaaaaaaaaaa")
Here's my (Zevras) solution:
import Data.List
encode :: (Eq a) => [a] > [(Int, a)]
encode x = map helper $ group x
where
helper x = (length x, head x)
decode :: [(Int, a)] > [a]
decode xs = concat $ map rep xs
where
rep (n, x) = take n $ repeat x
N.B., the RLE example is inspired from a blog post by Don Stewart on the same subject. See Don's post for a more elegant solution (which might not be immediately understandable; see Haskell/Understanding arrows for a discussion on &&&
).
Here’s my solution to the “bonus” problem. The function is called extract
here.
 Takes a string like "2a4c11b" and turns it into its encoded
 counterpart; in this case: [(2, 'a'), (4, 'c'), (11, 'b')].
extract :: String > [(Int, Char)]
extract [] = []
extract (x:xs) = extract' [x] xs
 helper function to keep track of the numbers.
 ns : List of digits ("1234").
extract' :: String > String > [(Int, Char)]
extract' _ [] = []
extract' ns [x] = [(read ns, x)]  the last element of the string
 is assumed to be a nondigit.
extract' ns (y:z:zs) =
if y `elem` ['0','1','2','3','4','5','6','7','8','9']
then extract' (ns ++ [y]) (z:zs)
else (read ns, y) : extract' [z] zs
A possible answer to the question "How would you convert the list of tuples (e.g. [(4,'a'), (6,'b')]) into a string (e.g. "4a6b")?"
 Convert a list of tuples into a string.
 For example, [(4, 'a'), (6, 'b')] becomes "4a6b".
 I begin with a function that converts a single tuple into a string two characters long.
 The intToDigit function converts a interger into a character. For example: intToDigit 1 = '1'.
 If intToDigit isn't used, GHCi will throw a type error.
import Data.Char
tupleToString :: (Int, Char) > [Char]
tupleToString x = (intToDigit.fst) x:(snd x):[]
 Now we'll map this function to a list of tuples. We get back a list of strings.
 For example: tuplesToStrings [(1, 'a'), (2, 'b')] = ["1a", "2b"].
tuplesToStrings [] = []
tuplesToStrings (x:xs) = tupleToString x : tuplesToStrings xs
 A little concat and we're done.
tuplesToString xs = (concat . tuplesToStrings) xs
Test with the function call
tuplesToString [(4,'a'), (6,'b')] ==> "4a6b"
Tips and tricksEdit
Exercises 


1. Both scanSum (takeInt 10 [1..])
and takeInt 10 (scanSum [1..])
have the same value. This is possible because Haskell is a lazy language, thus in both cases the result is only evaluated as needed.
2.
 this is just like the Prelude function last
lastOf :: [a] > a
lastOf [] = error "Empty list"
lastOf (x:[]) = x
lastOf (_:xs) = lastOf (xs)
 this is just like the Prelude init
dropLast :: [a] > [a]
dropLast [] = error "Empty list"
dropLast (x:[]) = []
dropLast (x:xs) = x : (dropLast xs)