## Jamie in Programming | November 14, 2011

I’ve only been taking one class this semester. It’s an advanced programming course focusing on the functional language Haskell. While I was familiar with some functional concepts such as map, fold, and currying from using Javascript, and lazy-evaluation from dabbling with Clojure, this class has introduced a number of new, intriguing concepts.

Not necessarily a functional feature, pattern matching in Haskell is an incredible feature that has really come to make a lot of sense to me. Given a type constructor with two definitions:

```
-- Given the type below
data Shape = Rectangle Float Float Float Float | Circle Float Float Float

area :: Shape -&gt; Float
-- We can pattern match below, to change the defn depending on the constructor
area (Rectangle x1 y1 x2 y2) = (y1 - y2) * (x1 - x2) :: Float
-- Use _ to discard matches
```

In Haskell, tuples are a basic data type. You can pattern match to unpack a tuple, like this:

```tmp = (1, (2, (3, 4)))

unpackTmp1 :: (Int, (Int, (Int, Int)))
unpackTmp1 (<em>, (</em>, rtn)) = rtn
unpackTmp1 tmp
-- rtn = (3,4)

unpackTmp2 :: (Int, (Int, (Int, Int)))
unpackTmp2 (<em>, (</em>, (_, rtn))) = rtn
unpackTmp2 tmp
-- rtn = 4
```

So, pattern is something really new to me that I haven’t seen in other languages before. It makes dealing with tuples easy, and you can also use it with lists:

```x = [1..10]
secondItem (<em>:i:</em>) = i
secondItem x
-- returns 2

thirdItem (<em>:</em>:i:_) = i
thirdItem x
-- return 3

tail' (_:rest) = rest
tail' x
-- returns [2..10]
```