Arithmetic

Now that you know a few things about Haskell language programming, let’s do some arithmetic. The following are examples of using the arithmetic operators +, -, *, and /.

Prelude> 5 + 3
8
Prelude> 175 - 23
152
Prelude> 55 * 256
14080
Prelude> 351 / 3
117.0
Prelude> 5 + 3
8
Prelude> 175 - 23
152
Prelude> 55 * 256
14080
Prelude> 351 / 3
117.0

You can combine these operators by using parenthesis. If you want to operate with a negative number, you should use the parenthesis—for example 5 * (-3); otherwise, you will get an error message. Also, there are mathematical functions such sqrt, abs, min, max, and succ.

Prelude> 133 * 18 + 5
2399
Prelude> 133 * (18 + 5)
3059
Prelude> 374 / (20 - 31)
-34.0
Prelude> 3 + sqrt(9)
6.0
Prelude> abs(25-100)
75

Boolean algebra is permitted. True and False represent the two Boolean values. As in other programming languages, && represent the Boolean and, || represents the Boolean or, and the keyword not represents negation. Also, you can test equality by using the == (equal) or /= (not equal) operators.

Prelude> True && False
False
Prelude> False || True
True
Prelude> not True
False
Prelude> (True || False) && (not True)
False
Prelude> 100 == 100
True
Prelude> 100 /= 100
False

When you use arithmetic operators or Boolean operators , the left side and the right side of the operator should have the same type; otherwise, you will get an error message .

Prelude> 2 + 2
4
Prelude> "xy" == "xy"
True
Prelude> 2 + "xyz"
<interactive>:26:1: error:
    • No instance for (Num [Char]) arising from a use of '+'
    • In the expression: 2 + "xyz"
      In an equation for ‘it’: it = 2 + "xyz"
Prelude> True && 5
<interactive>:29:9: error:
    • No instance for (Num Bool) arising from the literal '5'
    • In the second argument of '(&&)', namely '5'
      In the expression: True && 5
      In an equation for 'it': it = True && 5
Prelude> 3 == "xy"
<interactive>:30:1: error:
    • No instance for (Num [Char]) arising from the literal '3'
    • In the first argument of '(==)', namely '3'
      In the expression: 3 == "xy"
      In an equation for 'it': it = 3 == "xy"

In the preceding example, the + operator also expects a number on the right side, and the && operator expects a Boolean value on the right side. The equality can be verified only between two items of the same type. The example tests the equality between two strings, which is successful, and between a number and a string, which are different types, so there is an error message. Still, there are some exceptions when you operate with items of different types. This is when implicit conversion occurs. For example, addition using an integer value and a floating-point value is allowed because the integer can be converted to a floating-point number. The following is an example.

Prelude> 3 + 2.5
5.5

Pairs, Triples, and Much More

If you want to set a specific value or expression to a variable, use the keyword let. You do not need to declare the variable before setting a value. In Haskell, once you set a value to a variable, you cannot change that value in the same program. It is similar to a problem in mathematics—a variable cannot change its value in the same problem. The variables in Haskell are immutable. The following advanced example shows that if you set two values to a variable, you will get an error.

Prelude> let x = 4
Prelude> x
4
Prelude> let y = "abc"
Prelude> y
"abc"

Tuples are useful when you know the number of values to be combined. Tuples are marked by parenthesis. Its elements are separated by commas; they are not homogenous and they can contain different types.

Prelude> let pair = (2, "orange")
Prelude> pair
(2,"orange")

As you can see in the preceding example, our tuple is a pair with two elements of different types: a number and a string. Tuples are inflexible, because every tuple with its own size and types actually represents a type itself. Thus, general functions for tuples cannot be written. For example, if you want to add an element to a tuple, you should write a function for a tuple with two elements, a function for a tuple with three elements, and so on. You can make comparisons between tuples only if their components can be compared.

Prelude> let fstTuple = ("apple", 2, True)
Prelude> let sndTuple = ("orange", 3, True)
Prelude> fstTuple == sndTuple
False
Prelude> let trdTuple = ("green", False)
Prelude> fstTuple == trdTuple
<interactive>:53:13: error:
    • Couldn't match expected type ‘([Char], Integer, Bool)’
                  with actual type ‘([Char], Bool)’
    • In the second argument of ‘(==)’, namely ‘trdTuple’
      In the expression: fstTuple == trdTuple
      In an equation for ‘it’: it = fstTuple == trdTuple

There are two important functions, which are applied on a particular type of tuples, namely the pair: fst and snd. Intuitively, fst returns the first element of the pair and snd returns the second element of the pair. In Haskell, you call a function by writing its name, followed by parameters divided by spaces.

Prelude> fst trdTuple
"green"
Prelude> snd trdTuple
False
Prelude> fst (5, True)
5

Lists

Lists are similar to tuples. The main difference between them is that the lists are homogenous data structures; thus, all elements are of the same type. For example, you can have a list of integers, or a list of characters, but you cannot mix them in the same list. Lists are marked by brackets, and the elements are separated by commas. The strings are a list of characters, so the "Haskell" string is actually the list ['H', 'a', 's', 'k', 'e', 'l', 'l']. You can apply different functions on lists. Thus, because strings are lists of characters, you can apply many functions on them.

Prelude> [1, 2, 3] ++ [4, 5]
[1,2,3,4,5]
Prelude> "functional" ++ " programming"
"functional programming"

The ++ represents the concatenation of the left-side list with the right-side list (with elements of the same type). When two lists are concatenated, the left-side list is traversed entirely, and the elements of the right-side list are added at the end of the first list. This could take a while if the left-side list has many elements. Intuitively, adding an element to the beginning of a list is much faster. To add an element at the beginning of the list, use the cons operator ( : ).

Prelude> 1:[2,3,4]
[1,2,3,4]
Prelude> 'A':" flower"
"A flower"

If you want to extract an element on a particular index, use !!. Pay attention to the chosen index: if it is greater than the number of elements, or if it is negative, you will get an error message. The first index in a list is 0. A list can contain other lists, with the following rule : the lists can have different sizes, but they cannot contain different types.

Prelude> [2,4,6,8,10] !! 4
10
Prelude> [2,4,6,8,10] !! 6
*** Exception: Prelude.!!: index too large
Prelude> [2,4,6,8,10] !! -5
<interactive>:64:1: error:
    Precedence parsing error
        cannot mix ‘!!’ [infixl 9] and prefix `-' [infixl 6] in the same infix expression
Prelude> [[1,2], [3], [4,5,6]]
[[1,2],[3],[4,5,6]]

Lists can be compared if they contain elements that can be compared. The first element of the left-side list is compared with the first element of the right-side list. If they are equal, then the second elements are compared, and so on.

Prelude> [1,2,3] < [5,6,7]
True
Prelude> [1,2] < [-1,6,7]
False
Prelude> [1,2,3] < [-1,6,7]
False

There are many useful functions in lists , such as length , head , tail , init , last , maximum , minimum , sum , product , reverse , take , drop , elem , null , and much more. Figure 2-3 is an intuitive representation of the results of the functions head , tail , init, and last .

Figure 2-3. A visual representation of the results of functions head, tail, init and last

Prelude> length [1,2,3,4,5]
5
Prelude> head [1,2,3,4,5]
1
Prelude> tail [1,2,3,4,5]
[2,3,4,5]
Prelude> init [1,2,3,4,5]
[1,2,3,4]
Prelude> last [1,2,3,4,5]
5
Prelude> minimum [1,2,3,4,5]
1
Prelude> maximum [1,2,3,4,5]
5
Prelude> reverse [1,2,3,4,5]
[5,4,3,2,1]
Prelude> sum [1,2,3,4,5]
15
Prelude> drop 3 [1,2,3,4,5]
[4,5]
Prelude> take 2 [1,2,3,4,5]
[1,2]
Prelude> elem 6 [1,2,3,4,5]
False

Source Code Files

In practice, source code is not written in GHCi; instead, source code files are used. Haskell source code files have the extension .hs. Let’s suppose that you have a file named Main.hs with the following source code.

main = print (fibo 5)

fibo 0 = 1
fibo 1 = 1
fibo n = fibo (n-1) + fibo (n-2)

This source code represents a function that computes the Fibonacci number on a specific index. For the moment, take the function as it is; we will explain it in the next subsection. Let’s recall how to compute the Fibonacci numbers: F(0) = 0, F(1) = 1, F(n) = F(n-1) + F(n-2), where n > 1.

Now, let’s return to the source code files. The file could be saved anywhere, but if the work directory is different from the current directory, you need to change it to that directory in GHCi, using the :cd command, as follows.

Prelude> :cd C:Users

To load a file into GHCi, use the :load command.

Prelude> :load Main

After loading the module, you can observe that the prompt was changed into *Main> to indicate that the current context for expression is the Main module. Now, you can write expressions that include functions defined in Main.hs.

*Main> fibo 17
2584

When loading a module, GHC discovers the file name, which contains, for example, a module M, by looking for the file M.hs or M.lhs. Thus, usually, the name of a module should be the same as the file; otherwise, GHCi will not find it. Still, there is an exception: when you use the :load command for loading a file, or when it is specified invoking ghci, you can provide the file name instead of a module name. The specified file will be loaded if it exists, and it could comprise any number of modules. If you are trying to use multiple modules in a single file, you will get errors and consider it a bug. This is good, if there are more modules with the same M name, in the same directory; you cannot call them all M.hs.

If you forget the path where you saved a source code file, you can find it, as follows.

ghci -idir1:...:dirn

If you make changes in the current source code file, you need to recompile it. The command for recompilation is :reload, followed by the name of the file.

Functions

You have used functions since the beginning of this section; for example, all arithmetic operators are functions with two parameters or the functions applied to lists. Now, it’s time to define our functions. Let’s take the function from the previous subsection. To run a function, you need to write the function’s name, followed by the arguments, which are separated by spaces. Parentheses for arguments are not needed.

You haven’t used the return keyword. This is because Haskell does not have a return keyword; a function represents a single expression, not a succession of statements. The outcome of the function is the worth of the expression. Still, Haskell has a function called return, but it has a different meaning than in other programming languages.

Let's write a simple function that computes a power.

Prelude> pow a b = a ^ b
Prelude> pow 2 10
1024

A function has a type, which could be discovered using the :type command.

Prelude> :type pow
pow :: (Num a, Integral b) => a -> b -> a

As secondary effect , a dependence on the global state and the comportment of a function is introduced. For example, let’s think about a function that works with a global parameter, without changing its value and returning it. When a piece of code changes the value of the variable, it affects the function in a particular way, which has a secondary effect; although our function does not change the value of the global variable, which is treated as a constant. If a variable is mentioned out of scope, the value of the variable is obtained when the function is defined.

The secondary effects are usually invisible outcomes for functions. In Haskell, the functions do not have secondary effects, because they are depending only on explicit arguments. These functions are called pure. A function with side effects is called impure.

Prelude> :type writeFile
writeFile :: FilePath -> String -> IO ()

The Haskell type system does not allow combining pure and impure code.

Prelude> maximum a b = if a > b then a else b
maximum :: Ord t => t -> t -> t
Prelude> maximum 5 6
6

maximum a b = if a > b
                          then a else b

If expression then 10
              Else "abc"

fibo(4) = fibo(3) + fibo(2) = (fibo(2) + fibo(1)) + (fibo(1) + fibo(0)) = ((fibo(1) + fibo(0)) + 1) + (1 + 0) = ((1 + 0) + 1) + 1 = (1 + 1) + 1 = 2 + 1 = 3                      

Simple vs. Polymorphic Types

A simple value is a value that has only one type. This is discussed more about types in the “Data Types” section.

A polymorphic value is that value which could have multiple types. It is a very useful and used feature of Haskell. There two main types of polymorphism: parametric and ad hoc.

Identity :: a -> a

Type Classes

In Haskell, you identify the following aspects of type: strong, static, and automatically inferred.

The strong type system of Haskell assures the fact that a program does not contain errors obtained from expressions without a meaning for compiler.

When a program is compiled, the compiler knows the value of every type before the code is executed. This is assured by the static type system. Also, when you write expressions of different types, you will get an error message. By combining the strong type and the static type, the type errors will not occur at runtime.

Prelude> 2 + "5"
<interactive>:28:1: error:
    • No instance for (Num [Char]) arising from a use of '+'
    • In the expression: 2 + "5"
      In an equation for 'it': it = 2 + "5"

At compilation, each expression’s type is known. If you write an addition symbol between a number and a Boolean value, you will get an error message. In Haskell, each thing has a type. A benefit of Haskell is that it has the type inference, through which the type is implicitly inferred. So, if you write a number, you do not need to specify that it is a number.

Strong and static types bring security, while inference makes Haskell concise, so you have a safe and an expressive programming language.

Function Types

In Haskell, the functions have types. When you write functions, you can give them an explicit declaration, a fact that is helpful when you deal with complex functions. If you want to declare a function, you proceed as follows.

getMax :: [Int] -> Int

The meaning is intuitive. In the preceding example, the getMax function returns the maximum value from a list of integers. The :: symbol is followed by the domain of the definition of the function, and the -> shows the type of the result.

If you have a function with more parameters, you proceed as follows.

addition :: Int -> Int -> Int

Here, you have the addition function, which computes the sum of the two integers. The first two Ints show the type of the parameters, and they are divided by the -> symbol, and the last Int shows the result type.

It is recommended that functions be written with the explicit declaration; but if you are not sure about that, you can just write the function, and then check its type using the :t or :type commands.

Data Types

The following are some basic data types .

• Int: Integer numbers, which are signed and have fixed width. The range of values is not actually fixed; it depends on the system (32/64 bits), but Haskell assures that an Int is larger than 28 bits.

• Integer: Integer numbers with unbounded dimensions. The Integer type consumes more space and is less performant than Int, but it brings more dependably correct answers. In practice, it is used less than Int.

• Double: Floating-point numbers. Usually, the double value is represented in 64 bits, using the natural floating-point representation of the system.

• Char: Unicode character.

• Bool: A value from Boolean algebra. There are only two possible values: True and False.

Different from other programming languages , Haskell does not explicitly have the data type string. Strings are actually lists of characters.

If you want to check the type of value or an expression, you simply use the :t command, followed by the value or expression, as follows.

Prelude> :t 5.3
5.3 :: Fractional t => t
Prelude> :t "abcd"
"abcd" :: [Char]
Prelude> :t (5 < 2)
(5 < 2) :: Bool

:load/:reload

As you already know, the default module of Haskell is Prelude. You can change it by importing another module using the :load command. When it is appended, it automatically imports into the scope corresponding to the last loaded module. To be certain that GHCi imports the interpreted version of a module, you can add an asterisk when you load it, such as :load *modulename.

Prelude> :load Main.hs
Compiling Main             ( Main.hs, interpreted )
*Main>

Now, you can use expressions that involve elements from the loaded module. The star that accompanies the name of the module shows that the module represents the full top-level scope of the expressions from the prompt. In the absence of the asterisk, only the module’s exports are observable.

:module

The :module command also permits scope manipulation. If the module keyword is accompanied by +, then the modules are added; if it is accompanied by -, then the modules are removed. If there is no + or -, the actual scope is substituted by the modules after the :module command.

The use of module brings more benefits than using the import command. The main facilities are

• the full top-level of a scope is opened through the * operator.

• the unneeded modules can be removed.

:import

The :import command is used to add modules.

Prelude> import Data.Char
Prelude> toUpper 'a'
'A'

To see all imported modules, use the :show imports command.

Prelude> import System.IO
Prelude> :show imports
import Prelude -- implicit
import Data.Char
import System.IO

As you can see, Prelude is imported implicitly, but it could be replaced with the explicit Prelude import.

When there are more modules in the scope, it name conflicts could rise. In this case, Haskell will alert you.

As you have seen, there are two ways to get a module in the scope: by using :module/import or by using :load/:reload. Still, there are significant differences between the two approaches in the collection of the modules.

• The collection of modules that are loaded. changed using :load/:reload and viewed using :show modules.

• The collection of modules in the scope at the prompt. changed using :module/import, and instantaneous after :load/:reload, and viewed using :show imports.

A module can be added into the scope (through :module/import) if

• the module is loaded.

• the module belongs to a package known by GHCi.

In any other cases, it will be an error message.

Operators Used as Sections and Infix

In Haskell, there are two types of notations used for function calling: prefix notation and infix notation. Usually, prefix notation is used: the name of the function, followed by the arguments. The infix notation is where the name of the function stands between its arguments. Note that the infix notation can be used for functions with two parameters. If the function has more than two parameters, then the infix notation becomes inconvenient and difficult to follow.

The best-known infix functions are operators. As you well know, the arithmetic operators take two arguments, so they are by default infix. However, if you begin the line with an arithmetic operator in parenthesis, followed by the two arguments, then it becomes a prefix function.

Prelude> (+) 4 5
9
Prelude> (*) 10 10
100

Anyway, there is a way to use infix notation for an ordinary function. This is done by putting the name of the function between the ` symbol, as follows.

Prelude> let concatPrint x y = putStrLn $ (++) x y
 Prelude> concatPrint "a" "b"
 ab
 Prelude> "a" `concatPrint` "b"
 ab

There is a particular language structure for an incomplete application on infix operators. Broadly, when you use an operator, it behaves like a function that receives one of the arguments, and the other is put in the place of the misplaced side of the operator.

• (4^): the left side is the same to (^) 4, or more formal a -> 4 ^ a

• (^4): the right side is the same to flip (^) 4, or more formal a -> a ^ 4

Sectioning a function is very useful because it allows you to write a function, without giving a particular name to that function; for example:

• (1+): the function which increments by one a value

• (2*): the function which doubles a value

• (' ':): the “tab” function

The minus operator cannot make a right section, since it would be deciphered as unary invalidation in the Haskell language. The Prelude capacity “subtract” is accommodated this reason.

Local Declarations

In Haskell, local declarations can be used. This is done by using the let keyword, which binds a particular value to a variable; for example:

Prelude> let a = -5 + 1 in a + 10
6

This is equivalent to

{
 int a = -5 + 1;
 ... a + 10 ... ;
 }

In Haskell , the variable receives a value that cannot be changed.

Partial Application

When a function is called with some arguments missing, you actually obtain another function. This can be seen as something like “underloading,” but the specific term is partial application. For example, let’s think about the power function. It takes two arguments: namely, the base and the exponent. If you have a program in which only the irrational number e is used as a base, you could define a new function that takes one argument— namely, the exponent, as follows.

Prelude> powE x = (exp 1) ^ x
powE :: (Integral b, Floating a) => b -> a
Prelude> powE 5
148.41315910257657

This is very useful when you have complex functions with many parameters, but most of the time, you do not use all parameters.

You need to pay attention to an important aspect: the functions are not partial; you only partially apply a function.

Pattern Matching

In pattern matching , you need to specify patterns in which the data could fit, then check which patterns fit, and then manipulate the data as the pattern indicates. A function could have many implementations for various patterns, an approach that leads to organized, clean, and easy-to-read code. Pattern matching could be used with any data type. The following is an example of a function that tests if a number is zero (it was written in a file called Main.hs).

main = testInteger 5

testInteger 0 = print "zero"
testInteger x = print "not zero"

And in GHCi, after changing the work directory.

Prelude> :load Main
[1 of 1] Compiling Main             ( Main.hs, interpreted )
Ok, modules loaded: Main.
Prelude> testInteger 0
"zero"
Prelude> testInteger 6
"not zero"

When a function contains patterns, they are checked from top to bottom. When a match is found, the corresponding implementation is chosen. The “-5” argument fits in the second pattern, so a corresponding message is printed. You could use the if-else statement, but let’s think about how a function would look if it contains a branched if-else. Let’s say that you write a function that prints the name of a color according to a number as an argument, as shown in the following. If you did not use patterns, the branched if-else would become difficult to follow.

color 1 = print "green"
color 2 = print "blue"
color 3 = print "red"
color 4 = print "orange"
color x = print "any color"

Here are some arguments.

Prelude> color 1
"green"
Prelude> color 5
"any color"
Prelude> color (-100)
"any color"

You need to pay attention to the order of patterns. If you put the last pattern on the first place, then, always would be typed “any color”, because any number would fit in x.

If the function does not contain a general pattern, and you call it with an argument that does not fit in any pattern, then you will get an error message (after removing the last line of the function).

Prelude> color (-100)
*** Exception: Main.hs:(3,1)-(6,24): Non-exhaustive patterns in function color

You can use patterns in function that have tuples as parameters; for example, you have two points in the xOy axis system and you want to compute the distance between them. First, let’s remember the formula for the Euclidean distance: given two points, A(x ₁, y ₁), B(x ₂, y ₂), the distance AB is given by the formula . You would do it like this:

distance x y = sqrt((fst x - fst y)^2 + (snd x - snd y)^2)

Or, if involving patterns, it would be

distance2 (x1,y1) (x2, y2) = sqrt((x1 - x2)^2 + (y1 - y2)^2)

In Haskell, there are already defined functions that return the first or the second component of a pair. But what if you would work with triples? You can write your own functions.

firstElement :: (a, b, c) -> a
firstElement (x, _, _) = x
secondElement :: (a, b, c) -> b
secondElement (_, y, _) = y
thirdElement :: (a, b, c) -> c
thirdElement (_, _, z) = z

The underscore ( _ ) means that you can put anything on that index.

Guards

You use guards when you want to test if a property for one or more values is true or false. Of course, you could use the if statement, which is similar to guards, but guards are easy to read and they fit well with patterns. The following is an example in which the name of the weekday is typed according to a number as parameter.

dayOfWeek day
 | day == 1 = print "Monday"
 | day == 2 = print "Tuesday"
 | day == 3 = print "Wednesday"
 | day == 4 = print "Thurday"
 | day == 5 = print "Friday"
 | day == 6 = print "Saturday"
 | day == 7 = print "Sunday"
 | otherwise = print "The week has only 7 days. Please, choose an integer between [1, 7]."

The guard is represented by the pipes symbol (|). In essence, it is a Boolean expression. The expressions are evaluated one at a time, in order of appearance. If the result is True, then the corresponding instructions are used; else, the next expression follows, until it finds the expression whose result is True. For example, if you call the preceding function with 3, first, it is evaluated as day == 1 (which is False); then, day == 2 (also False); then, day == 3 (which is True), so the corresponding instruction is used.

The guards are useful when there is a long-branched if-else statement. Imagine how the code would look if you used if-else. Usually, the end guard is otherwise, which covers all the possibilities that are not found explicitly in the previous guard. For example, what if you gave the number 8 as a parameter to our function? Of course, an eighth day of the week does not exist, so the result is "The week has only 7 days. Please choose an integer between [1, 7] . " What about 100 as an argument? Or 0? Or –5? Of course, they are included in the last guard. If all guards are evaluated as False (this is the case when you do not include otherwise), then you will get an error message (after removing the last line).

Prelude> dayOfWeek 10
*** Exception: Main.hs:(7,1)-(14,28): Non-exhaustive patterns in function dayOfWeek

The guard could be written on the same line, but it would be difficult to follow. Also, a function that uses a guard could have as many parameters as you want.

Instance Declarations

A declaration of an instance has the following form.

instance (asserion_1, ..., assertion_n) => class type_1 ... type_m where ...

An instance declaration has two parts.

• context: the left side of =>

• head: the right side of =>

When GHCi resolves a constraint, each instance declaration tries to be matched with the constraint through initialization of the head of instance declaration. Let’s say you have the following statements:

instance ctx1 => C Int a     where ...
instance ctx2 => C a   Bool  where ...

Implicitly, GHCi knows that exactly one instance should fit the constraint on which it tries to resolve.

Type Pt x = (x, x)
Instance C (Pt x) where ...

Other Lists

In the previous section, you used only finite lists, but in Haskell, lists can be infinite because of the lazy evaluation property. The following list represents an infinite list of integer numbers, which starts with 10.

[10..]

If you want a list of the first 50 integers, you would not write all of them; you would do like this:

Prelude> [1..50]

This approach is called ranges, which enumerates the elements of a list (it has an enumeration rule!) in a compact manner.

Prelude> ['a'..'e']
"abcde"
Prelude> [5,10..50]
5,10,15,20,15,30,35,40,45,50

Still, the enumeration rule should be intuitive. You cannot write [1,3,9,27..50] to get all powers of 3 less than 50. In order for elements to be in decreasing order, it is not enough to write [50..1]; you should write [50,49..1].

Haskell allows ranges in floating-point numbers, but it is imprecise; often the results are not the expected ones.

In the next example, you write two ways to retrieve the first five multiples of 2.

Prelude> [2,4..5*2]
2,4,6,8,10
Prelude> take 5 [2,4..]

Three functions create infinite lists: cycle, repeat, and replicate.

Prelude> take 4 (cycle [1, 2])
[1,2,1,2]
Prelude> take 2 (cycle "Haskell")
"HaskellHaskell"
Prelude> take 5 (repeat 2)
2,2,2,2,2
Prelude> replicate 5 2
2,2,2,2,2

You know that in mathematics , the sets could be defined using predicates. A simple example is . For this set, 3x is called the output; x represents the variable; N represents the positive numbers set; and x < 7 represents the predicate. A simple way to get this set is to write take 7 [0,3..], but you could also proceed as follows.

Prelude> [3*x | x <- [0..6]]
0,3,6,9,12,15,18

This representation of lists is known as list comprehension.

Now, let’s use more predicates. If you want numbers that are multiples of 5, in the range 100 to 150, you would proceed as follows.

Prelude> [x| x <- [100, 150], x `mod` 5 == 0]
100,105,110,115,120,125,130,135,140,145,150

Arrays

Haskell permits the use of an array, which has only one constructor, Array. As any data structure, they are immutable, so they cannot change the value. Still, it exists to “modify” an array, but this means that it created a new array with extra features, without altering the original array.

import Data.Array.IO
main = do myArray <- newArray (1,5) 20 :: IO (IOArray Int Int)
           a <- readArray myArray 1
           writeArray myArray 1 25
           b <- readArray myArray 1
           print (a,b)

import Control.Monad.ST
import Data.Array.ST

 oldNewValue = do myArray <- newArray (1,5) 20 :: ST s (STArray s Int Int)
                a <- readArray myArray 1
                writeArray myArray 1 25
                b <- readArray myArray 1
                return (a,b)

 main = print $ runST oldNewValue

Finite Maps

Finite maps (or simple, maps) represent lookup tables for functional programming. In imperative programming, hash tables are equivalent to maps in Haskell. There are a couple of forms (key and value). When you work with maps, you need to import the Data.Map module.

import Data.Map
daysOfWeek = fromList
        [ ("M",  "Monday")
        , ("T",  "Tuesday")
        , ("W",  "Wednesday")
        , ("Th",  "Thursday")
        , ("F",  "Friday")
        , ("S",  "Saturday")
        , ("Su",  "Sunday") ]

A map could be converted to a list by using toList.

 Prelude> toList daysOfWeek
    [("F","Friday"),("M","Monday"),("S","Saturday")
    ,("Su","Sunday"),("Th","Thursday"),("T","Tuesday")
    ,("Wed","Wednesday")]

As you can see, the order is not kept.

If you need only the keys, then use the keys command; if you need only the elements, then use the elems command.

Prelude> keys daysOfWeek
    ["F","M","S","Su","Th","T","W"]
*Main> elems daysOfWeek
    ["Friday","Monday","Saturday","Sunday","Thursday","Tuesday","Wednesday"]

You could also search a value in the map by using the lookup function, as follows.

 Prelude> Data.Map.lookup "W" daysOfWeek
    "Wednesday"

You use the long version of the lookup function because there also exists a lookup function in Prelude, and you need to disambiguate so that GHCi knows what function to use.

Layout Principles and Rules

This section briefly talks about xmonad and wxHaskell.

fr <- frame [text := "Main Window", clientSize := sz 600 600]
pnl <- panel f []

mainMenu <- menuPane [text := "File"]
openItem <- menuItem timerMenu [text :="Open..."]
saveItem <- menuQuit timerMenu [help := “Save"]

The Final Word on Lists

Pattern matching is a very important aspect of lists.

Prelude> let xs = [(-1, 0), (54,-23), (2,1), (15,-8), (5,12), (0,1)]
xs :: (Num t1, Num t) => [(t, t1)]
Prelude> [x+y | (x,y) <- xs]
[-1,31,3,7,17,1]

If pattern matching breaks down, then it moves to the next component.

The list itself could be utilized in pattern matching. Something could be matched with the empty list [], or whatever pattern that includes []. The [1,2,3] is actually a representation for 1:2:3:[], because you first add 3 to the empty list, and then 2, and then 1, obtaining [1,2,3], so you have used the former pattern. This represents the pattern x:xs, which adds the x element as the head of the xs list. The x:xs pattern is widely utilized, especially in the recursive functions. Note that when you use the : symbob in patterns, it is applied to lists that have at least one element.

If you want to link, for example, the first two components to variables and the remaining elements to another variable, you can use x:y:ys. The matching will be applied only to lists with at least two components.

Let’s implement our own function that retrieves the head of a list.

headFunction :: [x] -> x
headFunction [] = error "The list in empty."
headFunction (a:_) = aChecking if it works:

And some arguments.

Prelude> headFunction [1,2,3,4]
1
Prelude> headFunction ['a', 'b']
'a'

Let’s look at our example. It uses the function error, which has a parameter and a string. When this error arises, the program crashes and the message is the string given as a parameter.

Now, let’s display the first two elements of a list.

elements :: (Show a) => [a] -> String
elements [] = "The list has no elements."
elements (a:[]) = "The only element of the list is " ++ show a
elements (a:b:[]) = "The only two elements of the list are " ++ show a ++ " and " ++ show b
elements (a:b:_) = "The list has more than 2 elements, but the first are " ++ show a ++ " and " ++ show b

The function covers all cases: an empty list and a list with one or more elements. Remember that a:[] is equivalent to [a], and a:b:[] is equivalent to [a,b], but you cannot write a:b:_ with squared braces.

Now let’s write our length function, using patterns and recursion.

lengthFunction [] = 0
lengthFunction (_:xs) = 1 + lengthFunction xs

Let’s test the function.

Prelude> lengthFunction []
0
Prelude> lengthFunction [1,2,3]
3
Prelude> lengthFunction "abc"
3

A special pattern is as pattern. It represents a way to split an element according to a pattern, and links it to names, but it is retained as a reference to the whole element. This is done using an @ in front of the pattern; for example, ys@(y:z:zs). This matches the same element that y:z:zs matches, but the entire list ys could be obtained.

map, filter, takeWhile

The map function has a function and a list as parameters. It applies the function over each element of the list.

map _ [] = []
map f (x:xs) = f x : map f xs
Prelude> map snd [('a', 'b'), ('c', 'd')]
"bd"

Another useful function is filter. It has functions as parameters, which return a Boolean value (i.e., a predicate), and a list. It returns the elements that are satisfying the conditions of the predicate.

filter _ [] = []
filter p (x:xs)
| p x       = x : filter p xs
| otherwise = filter p xs

The map and filter functions could be replaced by list comprehension.

The takeWhile function has a predicate and a list as parameters. It returns the elements while the predicate stays True. It stops at the first element where the predicate becomes False.

Prelude> sum (takeWhile (<5000) [n^3 | n <- [1..], even (n^3)])

The preceding code computes the sum of even cubes smaller than 5000.

Lambdas

In essence, lambdas are unnamed functions, created to be used once. In general, they are used in functions of higher order, and they stay between parentheses. Also, you can use pattern matching inside of them. The distinction is that one parameter cannot have more than one pattern.

The following is an example.

Prelude> addNo a b c = a + b + c
Prelude> addNo 3 4 5
12