These notes discuss the Haskell syntax for function definitions. Given the central role that functions play in Haskell, these aspects of Haskell syntax are fundamental.

Pattern matching consists of specifying patterns to which some data should conform, then checking to see if it does and de-constructing the data according to those patterns.

When defining functions, you can define separate function bodies for different patterns. You can pattern match on any data type â€“ numbers, characters, lists, tuples, etc. This leads to very expressive code that is also simple and readable.

Letâ€™s make a really trivial function that checks if the number we supplied to it is a 7 or not

```
ghci 1> let {lucky :: (Integral a) => a -> String;
lucky 7 = "LUCKY NUMBER SEVEN!";
lucky x = "Sorry, youâ€™re out of luck, pal!"}
```

When you call lucky, the patterns will be checked from top to bottom and when the argument of the function conforms to a pattern, the corresponding function body will be used.

The only way a number can conform to the first pattern here is if it is 7. If itâ€™s not, it falls through to the second pattern, which matches anything and binds it to x.

```
ghci 2> lucky 7
"LUCKY NUMBER SEVEN!"
```

```
ghci 3> lucky 19
"Sorry, youâ€™re out of luck, pal!"
```

This function could have also been implemented by using an if statement.

But what if we wanted a function that says the numbers from 1 to 5 and says â€œNot between 1 and 5â€? for any other number? Without pattern matching, weâ€™d have to make a pretty convoluted if then else tree. However, with pattern matching:

```
ghci 4> let {sayMe :: (Integral a) => a -> String;
sayMe 1 = "One!";
sayMe 2 = "Two!";
sayMe 3 = "Three!";
sayMe 4 = "Four!";
sayMe 5 = "Five!";
sayMe x = "Not between 1 and 5"}
```

```
ghci 5> sayMe 1
"One!"
ghci 6> sayMe 5
"Five!"
ghci 7> sayMe 6
"Not between 1 and 5"
```

Note that if we moved the last pattern (the catch-all one) to the top, it would always say â€œNot between 1 and 5â€?, because it would catch all the numbers and they wouldnâ€™t have a chance to fall through and be checked for any other patterns.

The Haskell syntax for functions is much cleaner when weâ€™re not in ghci. For example, you could create a file sayMe.hs in your working ghci directory (run the command `:!pwd in ghci`

to determine that directory if youâ€™re using a Linux or Mac machine) and type the following code in:

```
sayMe':: (Integral a) => a -> String
sayMe' 1 = "One!"
sayMe' 2 = "Two!"
sayMe' 3 = "Three!"
sayMe' 4 = "Four!"
sayMe' 5 = "Five!"
sayMe' x = "Not between 1 and 5"
```

Note that we do not use a let keyword, semicolons or curly braces; white space (block indentation) is however significant. To load the function in ghci, just run the following command:

```
ghci 8> : l sayMe
```

```
ghci 9> sayMe0 5
"Five!"
```

```
ghci 10> sayMe0 6
"Not between 1 and 5"
```

Remember the factorial function we implemented previously? We defined the factorial of a number n as product [1 . . n].

```
ghci 11> let factorial0 n = product [1 . . n]
```

```
ghci 12> factorial0 3
6
```

```
ghci 13> factorial0 6
720
```

We can also define a factorial function recursively, the way it is usually defined in mathematics. We start by saying that the factorial of 0 is 1. Then we state that the factorial of any positive integer is that integer multiplied by the factorial of its predecessor

Hereâ€™s what that looks like translated in Haskell terms.

```
ghci 14> let {factorial :: (Integral a) => a -> a;
factorial 0 = 1;
factorial n = n âˆ— factorial (n âˆ’ 1)}
```

```
ghci 15> factorial 0
1
```

```
ghci 16> factorial 3
6
```

```
ghci 17> factorial 53
4274883284060025564298013753389399649690343788366813724672000000000000
```

This is the first time weâ€™ve defined a function recursively. Recursion is important in Haskell and weâ€™ll take a closer look at it later.

But in a nutshell, this is what happens if we try to get the factorial of, say, 3:

- ghci tries to compute
`3 * factorial 2`

- factorial 2 is
**2 * factorial 1**, so for now we have`3 * (2 * factorial 1)`

- factorial 1 is
**1 * factorial 0**, so we have`3 * (2 * (1 * factorial 0))`

- now here comes the trick: weâ€™ve defined factorial 0 to be just 1 and because it encounters that pattern before the catch-all one, it just returns 1
- so the final result is equivalent to
`3 * (2 * (1 * 1))`

Had we written the second pattern on top of the first one, it would catch all numbers, including 0 and our calculation would never terminate.

That's why order is important when specifying patterns and itâ€™s always best to specify the most specific ones first and then the more general ones later.

Pattern matching can also fail. If we define a function like this:

```
ghci 18> let {charName :: Char -> String;
charName â€™aâ€™ = "AntMan";
charName â€™bâ€™ = "Black Widow";
charName â€™câ€™ = "Captain America"}
```

And then try to call it with an input that we didnâ€™t expect, this is what happens:

```
ghci 19> charName â€™aâ€™
"AntMan"
```

```
ghci 20> charName â€™bâ€™
"Black Widow"
```

```
ghci 21> charName â€™hâ€™
```

ghci complains that we have non-exhaustive patterns, and rightfully so. When making patterns, we should always include a catch-all pattern so that our program doesnâ€™t crash if we get some unexpected input.

```
ghci 22> let {charName' :: Char -> String;
charName' â€™aâ€™ = "AntMan";
charName' â€™bâ€™ = "Black Widow";
charName' â€™câ€™ = "Captain America";
charName' = "I am not sure of this Avenger, he must be from DC""}
```

```
ghci 23> charName0 â€™aâ€™
"AntMan"
```

```
ghci 24> charName' â€™bâ€™
"Black Widow"
```

```
ghci 25> charName0 â€™hâ€™
"I am not sure of this Avenger, he must be from DC"
```

What if we wanted to make a function that takes two vectors in a 2D space (that are in the form of pairs) and adds them together?

To add two vectors together, we add their x components and their y components separately

Hereâ€™s how we would have done it if we didnâ€™t know about pattern matching:

```
ghci 26> let {addVectors' :: (Num a) => (a, a) -> (a, a) -> (a, a);
addVectors' a b = (fst a + fst b,snd a + snd b)}
```

```
ghci 27> addVectors' (1, 2.3) (1, 1)
(2.0, 3.3)
```

Well, that works, but thereâ€™s a better way to do it. Letâ€™s modify the function so that it uses pattern matching.

```
ghci 28> let {addVectors :: (Num a) => (a, a) -> (a, a) -> (a, a);
addVectors (x1, y1) (x2, y2) = (x1 + x2, y1 + y2)}
```

Note that this is already a catch-all pattern. The type of addVectors (in both cases) is `addVectors :: (Num a) => (a, a) -> (a, a) -> (a, a)`

, so we are guaranteed to get two pairs as parameters.

```
ghci 29> : t addVectors
addVectors :: Num a => (a, a) -> (a, a) -> (a, a)
```

```
ghci 30> addVectors (1, 2) (3, 4.2)
(4.0, 6.2)
```

fst and snd extract the components of pairs. But what about triples? There are no provided functions that do that but we can make our own.

```
ghci 31> let {first :: (a, b, c) -> a;
first (x, , ) = x;
second :: (a, b, c) -> b;
second ( , y, ) = y;
third :: (a, b, c) -> c;
third ( , , z) = z}
```

The means the same thing as it does in list comprehensions: we donâ€™t care what that part is.

```
ghci 32> first (1, 2, 3)
1
```

```
ghci 33> second (1, 2, 3)
2
```

```
ghci 34> third (1, 2, 3)
3
```

Note the error if we apply these functions to pairs:

```
ghci 35> first (1, 2)
```

```
ghci 36> let xs = [ (1, 3),(4, 3),(2, 4),(5, 3),(5, 6),(3, 1)]
```

```
ghci 37> [a + b | (a, b) â†? xs]
[4, 7, 6, 8, 11, 4]
```

Should a pattern match fail, we just move on to the next element in the input list. Consider this example:

```
ghci 38> let xs = [ ("abc", "def"),("ghi", ""),("ABC", "DEF"),("", "GHI"),("the", "end")]
```

```
ghci 39> [[y] ++ ". " ++ [z] ++ "." | ((y : ys),(z : zs)) â†? xs]
["a. d.", "A. D.", "t. e."]
```

Lists themselves can be used in pattern matching. We can match with the empty list [ ] or any pattern that involves : and the empty list, but since [1, 2, 3] is just syntactic sugar for 1 : 2 : 3 : [ ], we can also use this pattern.

A pattern like x : xs will bind the head of the list to x and the rest of it to xs, even if thereâ€™s only one element so xs ends up being an empty list.

The x : xs pattern is used a lot, especially with recursive functions. But patterns that have : in them only match against lists of length 1 or more.

If you want to bind, say, the first three elements to variables and the rest of the list to another variable, you can use something like x : y : z : zs. It will only match against lists that have three elements or more.

We canâ€™t use ++ in pattern matches (ambiguous patterns).

Now that we know how to pattern match against lists, letâ€™s make our own implementation of the **head function.**

```
ghci 40> let {head' :: [a] -> a;
head' [ ] = error "Canâ€™t call head on an empty list, dummy!";
head' (x: _) = x}
```

```
ghci 41> head' [4, 5, 6]
4
```

```
ghci 42> head' "Hello"
â€™Hâ€™
```

```
ghci 43> head' [ ]
* * * Exception : Can't call head on an empty list, dummy!
```

Note that if you want to bind to several variables (even if one of them is just and doesnâ€™t actually bind at all), we have to put them in parentheses.

Also note the error function that we used: it takes a string and generates a runtime error, using that string as information about what kind of error occurred.

```
ghci 44> : t error
error :: [Char] -> a
```

```
ghci 45> : i error
error :: [Char] -> a -- Defined in â€˜GHC.Errâ€™
```

```
ghci 46> :! hoogle -- info error
Prelude error :: [Char] -> a
error stops execution and displays an error message.
From package base error :: [Char] -> a
```

Note that

Letâ€™s make a trivial function that tells us some of the first elements of the list in (in)convenient English form.

```
ghci 47> let {tell :: (Show a) => [a] -> String;
tell [ ] = "The list is empty";
tell (x : [ ]) = "The list has one element: " ++ show x;
tell (x : y : [ ]) = "The list has two elements: " ++ show x ++ " and " ++ show y;
tell (x : y: _) = "This list is long. The first two elements are: "
++ show x ++ " and " ++ show y}
```

```
ghci 48> tell [ ]
"The list is empty"
```

```
ghci 49> tell "h"
"The list has one element: â€™hâ€™"
```

```
ghci 50> tell "he"
"The list has two elements: â€™hâ€™ and â€™eâ€™"
```

```
ghci 51> tell "hello"
"This list is long. The first two elements are: â€™hâ€™ and â€™eâ€™"
```

This function is safe because it takes care of the empty list, a singleton list, a list with two elements and a list with more than two elements.

Note that `(x : [ ]) and (x : y : [ ])`

could be rewriten as `[x] and [x, y]`

â€“ we donâ€™t need parentheses in this case.

We canâ€™t rewrite (x : y: _) with square brackets because it matches any list of length 2 or more.

We already implemented our own length function using list comprehension. Now weâ€™ll do it by using pattern matching and a little recursion:

```
ghci 52> let {length' :: (Num b) => [a] -> b;
length' [ ] = 0;
length' ( : xs) = 1 + length0 xs}
```

This is similar to the factorial function we wrote earlier. First we defined the result of a known input â€“ the empty list. This is also known as the edge condition (a.k.a. the base condition).

Then in the second pattern we take the list apart by splitting it into a head and a tail. We say that the length is equal to 1 plus the length of the tail. We use to match the head because we donâ€™t actually care what it is.

Also note that weâ€™ve taken care of all possible patterns of a list: the first pattern matches an empty list and the second one matches anything that isnâ€™t an empty list.

```
ghci 53> length' [ ]
0
```

```
ghci 54> length' "hello"
5
```

```
ghci 55> length' "hello world"
11
```

Letâ€™s see what happens if we call length' on "ham".

```
ghci 56> length' "ham"
3
```

- first, it will check if itâ€™s an empty list; because it isnâ€™t, it falls through to the second pattern
- it matches on the second pattern and there it says that the length is 1 + length0 "am", because we broke it into a head and a tail and discarded the head
- length0 "am" is similarly 1 + length0 "m"; so right now we have 1 + (1 + length0 "m")
- length' "m" is 1 + length' "" (equivalently, 1 + length' [ ]), and weâ€™ve defined length' [ ] to be 0
- so in the end we have
`1 + (1 + (1 + 0))`

Assume that the sum of an empty list is 0. We write that down as a pattern. And we also know that the sum of a list is the head plus the sum of the rest of the list.

```
ghci 57> let {sum' :: (Num a) => [a] -> a;
sum' [ ] = 0;
sum' (x : xs) = x + sum' xs}
```

```
ghci 58> sum' [ ]
0
```

```
ghci 59> sum' [1 .. 10]
55
```

```
ghci 60> sum' [1 . . 100]
5050
```

As-patterns are a useful way of breaking something up according to a pattern and binding it to names while still keeping a reference to the whole thing. We do that by putting a name and an @ in front of a pattern.

For instance, the pattern `xs@(x : y : ys)`

will match exactly the same thing as `x : y : ys`

, but you can easily get the whole list via xs instead of repeating yourself by typing out `x : y : ys`

in the function body again.

```
ghci 61> let {firstLetter :: String -> String;
firstLetter "" = "Empty string, whoops!";
firstLetter all@(x : xs) = "The first letter of " ++ all ++ " is " ++ [x]}
```

```
ghci 62> firstLetter "Dracula"
"The first letter of Dracula is D"
```

```
ghci 63> firstLetter "Tonsil"
"The first letter of Tonsil is T"
```

```
ghci 64> firstLetter "tonsil"
"The first letter of tonsil is t"
```

```
ghci 65> firstLetter ""
"Empty string, whoops!"
```

```
ghci 66> firstLetter [ ]
"Empty string, whoops!"
```

Myself KarthiQ, I am the author of this blog, I know ways to write a good article but some how I donot have the skills to make it to reach people, would you like help me to reach more people By sharing this Article in the social media.

You can attend first 3 classes for free, the total

The course time would be 8.00 PM(IST) for the first three classes

The course time would be 8.00 PM(IST) for the first three classes

If you are interested to learn then you can join the course by sending email to

| |||||