Expressions and Types

Number Types

Some number types:

Integer integer
Int bounded integer (-2147483648..2147483647)
Rational rational
Float single-precision floating-point number
Double double-precision floating-point number
Test>
1162261467 :: Int
Test>
3486784401 :: Int
Test>
3486784401 :: Integer
Test>
88817841970012523233890533447265625 :: Integer
Test>
1 :% 3 :: Rational

Ad-hoc Polymorphism

(+) :: Num a => a -> a -> a

Num a means that a is replaceable with Int, Integer, Rational, Float, Double, …

(+) :: Int      -> Int      -> Int
(+) :: Integer  -> Integer  -> Integer
(+) :: Rational -> Rational -> Rational
(+) :: Double   -> Double   -> Double

Basic Arithmetic Operations

(-) :: Num a => a -> a -> a
(*) :: Num a => a -> a -> a
(/) :: Fractional a => a -> a -> a

Fractional a means that a is replaceable with Rational, Float, Double, …

Test>
0.3333333333333333 :: Double
div :: Integral a => a -> a -> a
mod :: Integral a => a -> a -> a

Integral a means that a is replaceable with Int and Integer.

Test>
3 :: Integer
Test>
10 :: Integer

Exercises

How many seconds are there in a normal year?

Solution>

Calculate the area of the circle with radius 1.01.
(Use pi instead of π.)

Test>

Decide whether 23 divides 532253373 or not.

Test>

Raising to a Power

(^) :: (Integral b, Num a) => a -> b -> a
(^^) :: (Fractional a, Integral b) => a -> b -> a
(**) :: Floating a => a -> a -> a

Floating a means that a is replaceable with Float, Double, …

Test>
2.718282043475248 :: Double
Test>
0.5 :: Double
Test>
1.4142135623730951 :: Double

Polymorphic Literals and Constants

Test>
1230 :: Num p => p
Test>
1.1 :: Fractional p => p
Test>
pi :: Floating a => a

Specializing the type of a polymorphic expression:

Test>
1230 :% 1 :: Rational

Exercises:

  1. Why is 1 + 1.1 type-correct?
  2. What is the type of 3 in the expression (1 + 3) / 4?

Prelude Type Class Hierarchy

FL_Expressions_en9ede53b64e93797291e1e05f90693bac.png

You can specialize expressions like

(+) :: Fractional a => a -> a -> a

The Two Boolean Values

Boolean values:

Test>
True :: Bool
Test>
False :: Bool

Equality and Ordering

Test>
(==) :: Eq a => a -> a -> Bool
Test>
(<) :: Ord a => a -> a -> Bool

Exercises

Test>
Test>
Test>
Test>
Solution>

Boolean Operators

Test>
False :: Bool
Test>
True :: Bool
Test>
False :: Bool
Test>
(&&) :: Bool -> Bool -> Bool

Functions and Operators

Operator names may contain graphic characters: +, **, <=, !?.#$%@&*+-~^/|\<=>, etc.

Function names may begin with lower letter and may contain further alphanumeric characters, for example sin, mod, isAlpha, etc.

Functions with two parameters can be used with infix notation:

Test>

Operators can be used with prefix notation:

Test>

Note that negation is denoted with - (the minus symbol), just like subtraction.
However, writing 3 + -11 is erroneous, one should write 3 + (-11) instead (note the parenthesis).

Precedences

Precedences from stronger to weaker:

functions (sqrt, div, mod, etc.) left: ((.).)
^, ^^, ** right: (.(.))
*, /, `div`, `mod` left: ((.).)
+, - (subtraction and negation) left: ((.).)
==, /=, <, <=, >, >= -
&& right: (.(.))
|| right: (.(.))

Example. 3 - 3 ^ 3 ^ 3 - 3 with parentheses added:

Test>

Note that the function application has the strongest precedence.

sin pi + 1 is (sin pi) + 1.

Exercises

Add parentheses.

Test>
33.4 :: Double
Test>
False :: Bool

Lists

Test>
Test>
Test>

Sometimes list may be used as sets, but an important different between them is that order and multiplicity matter for lists.

Test>
True :: Bool
Test>
True :: Bool

Lists are homogeneous, that is, all elements should have the same type.

Test> 
<interactive>:1:2: error:
    • No instance for (Num Bool) arising from the literal ‘1’
    • In the expression: 1
      In the expression: [1, True]

A string is a list of characters.

Test>
"abc" :: [Char]

String a synonym for [Char].

Dotdot Expressions

There are four different forms:

Test>
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] :: [Integer]
Test>
[1, 3, 5, 7, 9] :: [Integer]
Test>
Test>

This is also possible:

Test>
"abcdefghijklmnopqrstuvwxyz" :: [Char]

Exercise

List the numbers from 10 to -10.

Solution>

Exercises

Guess the type of the following expressions:

Test>
Test>
Test>
Test>
Test>

Some Basic Operations on Lists

The length function returns the number of elements in a list.

length :: [a] -> Int
Test>
3 :: Int

The !! operator selects an element from a list with the given index. The first element of the list has the index 0. Passing negative indexes results an error.

(!!) :: [a] -> Int -> a
Test>
'b' :: Char

The ++ (concatenate) operator combines two lists. Note that both lists must be of the same type.

(++) :: [a] -> [a] -> [a]
Test>
"hello" :: [Char]

The : (cons) operator adds exactly one element to the head of the list. Note that the types must be the same.

(:) :: a -> [a] -> [a]
Test>
[11, 12, 13, 14] :: [Integer]

Exercise

What is the 113th element of the arithmetic sequence whose first two elements are 11 and 32?

Solution>

Sum and Product

sum :: (Foldable t, Num a) => t a -> a
Test>
product :: (Foldable t, Num a) => t a -> a
Test>

Exercise

How many ways can 100 different items be sorted?

Solution>

Exercise

How many ways can 30 elements be chosen from 70 different elements?

Solution>

Hint: Use the div function instead of (/).

Exercise

What is easier: get 5 elements out of 90 or get 6 elements out of 45?

Test>
Test>

List Comprehensions

List comprehensions provide a convenient syntactical mechanism to create lists. The syntax is similar to the mathematical set notation.

In Math: { 2 × n | n ∈ N }

In English: for all n in the naturals, two times n

In Haskell:

Test>
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, ……] :: [Integer]

The members of the input list can be selectively tested with Bool-typed expressions, separated by commas.

In Math: { n2 | n ∈ N, n even }

In Haskell:

Test>
[4, 16, 36, 64, 100, 144, 196, 256, 324, 400, 484, 576, 676, 784, 900, 1024, 1156, 1296, 1444, 1600, 1764, 1936, 2116, 2304, 2500, 2704, 2916, 3136, 3364, 3600, 3844, 4096, 4356, 4624, 4900, 5184, 5476, 5776, 6084, 6400, 6724, 7056, 7396, 7744, 8100, 8464, 8836, 9216, 9604, 10000, 10404, 10816, 11236, 11664, 12100, 12544, 12996, 13456, 13924, 14400, 14884, 15376, 15876, 16384, 16900, 17424, 17956, 18496, 19044, 19600, 20164, 20736, 21316, 21904, 22500, 23104, 23716, 24336, 24964, 25600, 26244, 26896, 27556, 28224, 28900, 29584, 30276, 30976, 31684, 32400, 33124, 33856, 34596, 35344, 36100, 36864, …, ……] :: [Integer]

Exercise

List powers of 2 from 1 to 210.

Solution>

Exercise

Generate a list of length 10 whose elements are False, True, False, True, … (alternating)

Solution>

Exercise

Construct the least power of 2 which is bigger than 1020.

Solution>

Hint: xs !! 0 == head xs.

Exercise

List the divisors of 60.

Solution>

Exercise

How many divisors does 60 have?

Solution>

Exercise

Is 123457 a prime number?

Solution>

Exercise

Generate the following list: [1,1,2,1,2,3,1,2,3,4,…].

Solution>

Exercise

Generate the following sequence (as a list): 0,1,0,-1,0,1,2,1,0,-1,-2,-1,0,1,2,3,2,1,0,-1,…

Solution>

Hint: Use concat.

concat :: Foldable t => t [a] -> [a]

Pairs

Pairs may have two elements with different types:

Test>
(True, 'a') :: (Bool, Char)

A list comprehension which produces a list of pairs:

Test>
[('a', 1), ('a', 2), ('b', 1), ('b', 2), ('c', 1), ('c', 2)] :: [(Char, Integer)]

Exercise

Generate a list that contains all (hour, minute) pairs in a day.

Solution>

Exercise

List “dominoes”:

[(0,0),(0,1),(1,1),(0,2),(1,2),(2,2),...,(9,9)]

Domino (1,0) is not in the list because it is already in it as (0,1).

Solution>

More generally, tuples may contain an arbitrary number of elements of different types.

Test>
(True, "hello", 3.4) :: (Bool, [Char], Double)

Exercise

Find all Boolean values a, b, and c such that

(a || (b && c)) /= ((a || b) && c)
Solution>

The type of the result should be [(Bool,Bool,Bool)].

Exercise

Generate a list that contains all (month, day) pairs in a 365-day year.

Solution>

Hint: It is easier with the elem function.

Zipping

The function zip zips two lists together. The result is a list of tuples, where the first element of each tuple is taken from the first list, and the second element of each tuple is taken from the corresponding element of the second list.

zip :: [a] -> [b] -> [(a, b)]
Test>
[('a', 1), ('b', 2)] :: [(Char, Integer)]

Zipping is finished if one of the lists ends.

Exercise

Construct the list [(1,'a'),(2,'b'),…(…,'z')].

Solution>

Hint. Use two dotdot expressions!

Further Exercises with List Comprehensions

Exercise

Generate the following list: [1,2,2,3,3,3,4,4,4,4, …]. The ith number appears i times in the list.

Solution>

Exercise

Test the concat function. concat will combine two lists.

Test>
concat :: Foldable t => t [a] -> [a]

Generate the following sequence: 1,2,1,2,3,2,1,2,3,4,3,2,1,2,3,4,5,4,3,2,1,2,3,4,5,6,5,4,3,2,1,…

Solution>

Exercise

Test the unwords function.

Test>
unwords :: [String] -> String

Generate the following infinite string: "* ** *** **** *****…

Solution>

Exercise

Generate a list that is derived from the set of natural numbers by omitting the square numbers.

Solution>