Haskell & Functional Programming

Write (two versions of) a function myReplicate that given an integer n and a value v returns a list of length n initialized with v, namely all elements are equal to v.

• Goal: Warming up!
• Expected output: Two implementations of the above function: myReplicateR which uses recursion on natural numbers, and myReplicateC that uses combinators (i.e., functions like map, filter, foldl/r from the Haskell Prelude).

Write (two versions of) a function sumOdd that given a list of integers computes the sum of the values that are odd.

Hint: consider the functions odd and even of the Prelude.

• Goal: Warming up (part 2)!
• Expected output: Two implementations of the above function: sumOddR which uses recursion on lists, and sumOddC that uses combinators (i.e., functions like map, filter, foldl/r from the Haskell Prelude).

Write (two versions of) a function repl that given a list xs and a integer n returns a list containing the elements of xs replicated n times.

Hint: you can use the function myReplicate of Exercise 1.

• Goal: Playing with lists.
• Expected output: Two implementations of the above function: replR which uses recursion on lists, and replC that uses combinators (i.e., functions like map, filter, foldl/r from the Haskell Prelude).

Write a function totalLength that given a list of strings xs computes the sum of the lengths of the strings starting with the character 'A'.

• Goal: Test your skills with lists and strings.
• Expected output: Two implementations of the above function: totalLengthR which uses recursion on lists, and totalLengthC that uses combinators (i.e., functions like map, filter, foldl/r from the Haskell Prelude).

Write a function filterOdd that given a list xs returns a new list obtained from xs by removing the elements at odd positions.

Hint: Here "odd positions" means the first, third, fifth, etc position.

• Goal: Playing with lists (part 2).
• Expected output: Two implementations of the above function: filterOddR which uses recursion on lists, and filterOddC that uses combinators (i.e., functions like map, filter, foldl/r from the Haskell Prelude).

Write a function titlecase that given a string s converts it to titlecase by uppercasing the first letter of every word.

Hint: consider using the function words, unwords of the Prelude and the function toUpper of the module Data.Char. To make accessible this last function in your code use import Data.Char (toUpper).

• Goal: Experimenting with strings.
• Expected output: Two implementations of the above function: titlecaseR which uses recursion on lists, and titlecaseC that uses combinators (i.e., functions like map, filter, foldl/r from the Haskell Prelude).

Write a function countVowelPali that given a list of strings xs returns the total number of vowels in strings that are palindromes. For example,

countVowelPali ["anna", "banana", "civic", "mouse"] = 4

• Goal: Fun with strings and lists (again :P).
• Expected output: Two implementations of the above function: countVowelPali which uses recursion on lists, and countVowelPali that uses combinators (i.e., functions like map, filter, foldl/r from the Haskell Prelude).

Recall the higher-order combinator map from the Prelude. Implement it using the combinator foldl.

• Goal: Experimenting with combinators.
• Expected output: The required implementation of the map combinator.

Consider the following definition of binary trees:

data IntTree = Leaf Int | Node (Int, IntTree, IntTree)

1. Implement tmap, a "tree version" of the map combinator. More precisely, the function tmap should take a function f and a tree t and should apply f to each value in t.
2. Using tmap implement the function succTree taking a tree t and computing a tree whose elements are the successors of the values in t.
3. Write a function sumSucc taking a tree t and computing the sum of the elements of succTree t.

• Goal: Experimenting with trees.
• Expected output: An implementation of the three required functions.