Guards

Guards

Guards_en311d942d1f438346889ce826292ee64b.png

min x y
    | x <= y    =  x
    | otherwise =  y

Differences from case distinction in mathematics:

Guards (2)

Syntax:

Semantics: Guard expressions are checked top-down, and the first satisfying condition is selected.

The two definitions are similar, but there are some minor differences.

Thus, the syntax is as follows.

Semantics: Guards are checked for satisfaction from the top to the bottom. The result will be the expression assigned to the first guard expression evaluating to true.

Note that otherwise is not a keyword, but a constant defined in the Prelude module.

Test>

Exercise: Uppercase-Lowercase

Define the function upperLower, which converts lowercase letters to uppercase ones and vice versa.

upperLower :: Char -> Char

Test>
'A' :: Char
Test>
't' :: Char
Test>
',' :: Char

Hint: It requires the Data.Char module to be imported.

Exercise: Data.Char.digitToInt [*]

The following function assigns numeric values to characters:

digitToInt :: Char -> Int

Test>
0 :: Int
Test>
9 :: Int
Test>
10 :: Int
Test>
15 :: Int
Test>
10 :: Int
Test>
⊥₁ :: Int
⊥₁: not a digit
CallStack (from HasCallStack):
  error, called at ./Guards_en.lhs:96:33 in main:Guards_en

Exercise: Square

sqr :: Num a => a -> a

Test>
16 :: Integer

Exercise: (Prelude.^) [*]

Redefine the (^) operator (quick exponentation).

Guards_en9cae163a7d5bb31970c06157541f303a.png

(^) :: Num a => a -> Integer -> a

Test>
1 :: Integer
Test>
27 :: Integer
Test>
True :: Bool

Exercise: Binary Numerals

Let toBin be the function that returns a non-negative integer as series of binary numerals of the same value in reversed order.

Guards_enb9495b51db8074570ffed11f2f8e1707.png

toBin :: Integer -> [Int]

Test>
[] :: [Int]
Test>
[1] :: [Int]
Test>
[0, 1] :: [Int]
Test>
[0, 1, 0, 1] :: [Int]

Guards with Pattern Matching: Prelude.drop [*]

Definition of drop:

drop :: Int -> [a] -> [a]

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

Exercise: Prelude.take

Redefine the take function from the Prelude module. Meaning of take n l: take the first n elements from the list l.

take :: Int -> [a] -> [a]

Test>
[1, 2, 3] :: [Integer]
Test>
[1, 2] :: [Integer]
Test>
[] :: [Integer]

Exercise: Data.List.insert [*]

Redefine the insert function from the Prelude module (insertion of an element to a sorted list).

insert :: Ord a => a -> [a] -> [a]

Test>
[3] :: [Integer]
Test>
[1, 2, 3, 5, 8] :: [Integer]
Test>
[1, 2, 5, 8, 10] :: [Integer]

Exercise: Sorted Merge

Define a sort merge.

sortMerge :: Ord a => [a] -> [a] -> [a]

Test>
[1, 2, 3, 4, 8, 10] :: [Integer]
Test>
[3, 4, 10] :: [Integer]

Exercise: Combinations

Generate combinations of elements for a list without repetitions. (Let us consider the elements of the list distinct.)

combinations :: Int -> [a] -> [[a]]

Test>
[] :: [[Char]]
Test>
[[]] :: [[Char]]
Test>
["a", "b", "c", "d"] :: [[Char]]
Test>
["ab", "ac", "ad", "bc", "bd", "cd"] :: [[Char]]
Test>
["abc", "abd", "acd", "bcd"] :: [[Char]]
Test>
["abcd"] :: [[Char]]
Test>
[] :: [[Char]]
Test>
["a", "a"] :: [[Char]]

Exercise: Packing

Let n a non-negative integer and xs a list of non-negative integers.

Choose elements of xs in all possible ways that the sum of the chosen integers must be n.

pack' :: Integral a => [a] -> a -> [[a]]

Test>
[[5, 7, 13], [3, 5, 17], [2, 5, 7, 11], [2, 3, 7, 13]] :: [[Integer]]