news

[Published in Open Source For You (OSFY) magazine, September 2014 edition.]

In the third article in the series, we will focus on more Haskell functions, conditional constructs and their usage.

A function in Haskell has the function name followed by arguments. An infix operator function has operands on either side of it. A simple infix add operation is shown below:

``````*Main> 3 + 5
8``````

If you wish to convert an infix function to a prefix function, it must be enclosed within parenthesis:

``````*Main> (+) 3 5
8``````

Similarily, if you wish to convert a prefix function into an infix function, you must enclose the function name within backquotes(`). The elem function takes an element and a list, and returns true if the element is a member of the list:

``````*Main> 3 `elem` [1, 2, 3]
True
*Main> 4 `elem` [1, 2, 3]
False``````

Functions can also be partially applied in Haskell. A function that subtracts ten from a given number can be defined as:

``````diffTen :: Integer -> Integer
diffTen = (10 -)``````

Loading the file in GHCi and passing three as an argument yields:

``````*Main> diffTen 3
7``````

Haskell exhibits polymorphism. A type variable in a function is said to be polymorphic if it can take any type. Consider the last function that returns the last element in an array. Its type signature is:

``````*Main> :t last
last :: [a] -> a``````

The ‘a’ in the above snippet refers to a type variable and can represent any type. Thus, the last function can operate on a list of integers or characters (string):

``````*Main> last [1, 2, 3, 4, 5]
5
*Main> last "Hello, World"
'd'``````

You can use a where clause for local definitions inside a function, as shown in the following example, to compute the area of a circle:

``````areaOfCircle :: Float -> Float
where pi = 3.1415``````

Loading it in GHCi and computing the area for radius 1 gives:

``````*Main> areaOfCircle 1
3.1415``````

You can also use the let expression with the in statement to compute the area of a circle:

``````areaOfCircle :: Float -> Float
areaOfCircle radius = let pi = 3.1415 in pi * radius * radius``````

Executing the above with input radius 1 gives:

``````*Main> areaOfCircle 1
3.1415``````

Indentation is very important in Haskell as it helps in code readability - the compiler will emit errors otherwise. You must make use of white spaces instead of tab when aligning code. If the let and in constructs in a function span multiple lines, they must be aligned vertically as shown below:

``````compute :: Integer -> Integer -> Integer
compute x y =
let a = x + 1
b = y + 2
in
a * b``````

Loading the example with GHCi, you get the following output:

``````*Main> compute 1 2
8``````

Similarily, the if and else constructs must be neatly aligned. The else statement is mandatory in Haskell. For example:

``````sign :: Integer -> String
sign x =
if x > 0
then "Positive"
else
if x < 0
then "Negative"
else "Zero"``````

Running the example with GHCi, you get:

``````*Main> sign 0
"Zero"
*Main> sign 1
"Positive"
*Main> sign (-1)
"Negative"``````

The case construct can be used for pattern matching against possible expression values. It needs to be combined with the of keyword. The different values need to be aligned and the resulting action must be specified after the ’->’ symbol for every case. For example:

``````sign :: Integer -> String
sign x =
case compare x 0 of
LT -> "Negative"
GT -> "Positive"
EQ -> "Zero"``````

The compare function compares two arguments and returns LT if the first argument is lesser than the second, GT if the first argument is greater than the second, and EQ if both are equal. Executing the above example, you get:

``````*Main> sign 2
"Positive"
*Main> sign 0
"Zero"
*Main> sign (-2)
"Negative"``````

The sign function can also be expressed using guards (‘|’) for readability. The action for a matching case must be specified after the ‘=’ sign. You can use a default guard with the otherwise keyword:

``````sign :: Integer -> String
sign x
| x > 0 = "Positive"
| x < 0 = "Negative"
| otherwise = "Zero"``````

The guards have to be neatly aligned:

``````*Main> sign 0
"Zero"
*Main> sign 3
"Positive"
*Main> sign (-3)
"Negative"``````

There are three very important higher order functions in Haskell — map, filter, and fold.

The map function takes a function and a list, and applies the function to each and every element of the list. Its type signature is:

``````*Main> :t map
map :: (a -> b) -> [a] -> [b]``````

The first function argument accepts an element of type ‘a’ and returns an element of type ‘b’. An example on adding two to every element in a list can be implemented using map:

``````*Main> map (+ 2) [1, 2, 3, 4, 5]
[3,4,5,6,7]``````

The filter function accepts a predicate function for evaluation, and a list, and returns the list with those elements that satisfy the predicate. For example:

``````*Main> filter (> 0) [-2, -1, 0, 1, 2]
[1,2]``````

Its type signature is:

``filter :: (a -> Bool) -> [a] -> [a]``

The predicate function for filter takes as its first argument an element of type ‘a’ and returns True or False.

The fold function performs cumulative operation on a list. It takes as arguments a function, an accumulator (starting with an initial value) and a list. It cumulatively aggregates the computation of the function on the accumulator value as well as each member of the list. There are two types of folds — left and right fold.

``````*Main> foldl (+) 0 [1, 2, 3, 4, 5]
15
*Main> foldr (+) 0 [1, 2, 3, 4, 5]
15``````

Their type signatures are, respectively:

``````*Main> :t foldl
foldl :: (a -> b -> a) -> a -> [b] -> a
*Main> :t foldr
foldr :: (a -> b -> b) -> b -> [a] -> b``````

The way the fold is evaluated among the two types is different and is demonstrated below:

``````*Main> foldl (+) 0 [1, 2, 3]
6
*Main> foldl (+) 1 [2, 3]
6
*Main> foldl (+) 3 [3]
6``````

It can be represented as ‘f (f (f a b1) b2) b3’ where ‘f’ is the function, ‘a’ is the accumulator value, and ‘b1’, ‘b2’ and ‘b3’ are the elements of the list. The parenthesis is accumulated on the left for a left fold. The computation looks like:

``````*Main> (+) ((+) ((+) 0 1) 2) 3
6
*Main> (+) 0 1
1
*Main> (+) ((+) 0 1) 2
3
*Main> (+) ((+) ((+) 0 1) 2) 3
6``````

With the recursion, the expression is constructed and evaluated only when the expression is finally formed. It can thus cause stack overflow or never complete when working with infinite lists. The foldr evaluation looks like this:

``````*Main> foldr (+) 0 [1, 2, 3]
6
*Main> foldr (+) 0 [1, 2] + 3
6
*Main> foldr (+) 0 [1] + 2 + 3
6``````

It can be represented as ‘f b1 (f b2 (f b3 a))’ where ‘f’ is the function, ‘a’ is the accumulator value, and ‘b1’, ‘b2’ and ‘b3’ are the elements of the list. The computation looks like:

``````*Main> (+) 1 ((+) 2 ((+) 3 0))
6
*Main> (+) 3 0
3
*Main> (+) 2 ((+) 3 0)
5
*Main> (+) 1 ((+) 2 ((+) 3 0))
6``````

There are some statements like condition checking where ‘f b1’ can be computed even without requiring the subsequent arguments, and hence the foldr function can work with infinite lists. There is also a strict version of foldl (foldl’) that forces the computation before proceeding with the recursion.

If you want a reference to a matched pattern, you can use the as pattern syntax. The tail function accepts an input list and returns everything except the head of the list. You can write a tailString function that accepts a string as input and returns the string with the first character removed:

``````tailString :: String -> String
tailString "" = ""
tailString input@(x:xs) = "Tail of " ++ input ++ " is " ++ xs``````

The entire matched pattern is represented by input in the above code snippet.

Functions can be chained to create other functions. This is called as ‘composing’ functions. The mathematical definition is as under:

``(f o g)(x) = f(g(x))``

This dot (.) operator has the highest precedence and is left-associative. If you want to force an evaluation, you can use the function application operator (\$) that has the second highest precedence and is right-associative. For example:

``````*Main>  (reverse ((++) "yrruC " (unwords ["skoorB", "lleksaH"])))
``````Prelude> reverse \$ (++) "yrruC " \$ unwords ["skoorB", "lleksaH"]
``````*Main> reverse . (++) "yrruC " . unwords \$ ["skoorB", "lleksaH"]