Haskell 101

January 27, 2008

Checking for a value in a list

Filed under: Functional programming, Haskell, List comprehensions, Pattern matching, Ruby — Haskell 101 blogger @ 9:24 pm

Once we have a list, how do we check whether that list contains a certain value? This is sort of like the Ruby method “include?”.

We want to provide the value we are looking for, and the list in which we would like to look for it.

(1) includes::Int->[Int]->Bool

Let’s first try using pattern matching and recursion.

(2) includes x (y:ys)
      | x==y = True
      |otherwise = includes x ys

In other words, take the head of the provided list and compare it to the desired value. If equal, return true. We don’t need to look anymore, because we know the value is there. If not equal, then we need to keep looking, so recurse, using the tail of the provided list for the next evaluation.

(3) includes x [] = False

We will only get to this step if we have not matched the value before we get to the empty list. if that is the case, then we want to return False.

We’ll look next time at some other, perhaps more elegant, but perhaps slower, way to do this.


January 26, 2008

Our first function

Filed under: Haskell, Pattern matching, Recursion — Haskell 101 blogger @ 4:23 pm

Part of what we will be doing throughout these blog entries is to create Haskell functions. Our first function is a simple one. In fact, it already exists. But half of the fun (at least) is going to be creating functions to learn the language. Building up basic code (even if it replicates a higher-order existing function) is one of the ways I have found to best learn a new language.So, today’s function is one that will take two lists and concatenate them. In the Haskell 98 Report, this is known as ++. I’ll call the function “union.”Let’s set the type signature first. We want to take two lists and return a third. So:

(1) union::[a]->[a]->[a]

How do we define the function? Let’s do it using recursion. We’ll add each item in the first list to an empty list [], and then add each element of the first list after that, and then, once the first list is empty, we’ll add the second list. So, we know we want to stop recursing when the first list is empty:

(2) union [] y = y

How about adding each item to the initial list? We’ll cons the item on using the : operator.

(3) union (x:xs) y = x:(union xs y)

Note the splitting of the first list into x and xs. This is a handy way of getting access to the first element of the list x, and assigning the remainder, or tail, of the list to xs (with the “s” indicating a plural number of elements). You can also see that we grab the first element and then call our union function again. We then grab the second element, call the function again, and so on. The pattern in (3) will no longer match when the first list is empty, and then the pattern in (2) will match, ending the recursion.  So, in summary, here is our function:

union [] y = y
union (x:xs) y = x:(union xs y)

 If you want, you can take a look at the aforementioned Haskell 98 Report and see how our function compares to the official definition of ++. 

January 25, 2008

Welcome to Haskell 101

Filed under: Functional programming, Haskell, List comprehensions, Pattern matching, Ruby — Haskell 101 blogger @ 4:32 am

Welcome to Haskell 101, a blog where I will walk through my own learnings with the functional programming language known as Haskell. How did I decide to do this? Well, I like to program as a hobby. Of all the languages that I have programmed in (Java, PHP, Visual Basic, and Ruby), Ruby is by far the one I enjoy most. I started to read about the roots of the Ruby programming language and learned of its functional programming roots. I then started looking into the various functional programming languages out there (especially Erlang, Haskell, and Lisp). The one that for some reason drew most of my attention was Haskell. I love the concept of pattern matching, which is not related much at all to regular expressions, by the way. I also like the elegance of list comprehensions, which feel much like the power and succinctness of some Ruby structures, like


Welcome aboard!

Blog at WordPress.com.