Programming -> Haskell Intro, expanded

Well, you just sit down and take it in a little bit at a time. No one ever learns a language by just sitting down, reading straight through a book or tutorial, then claiming "I know this language!"

The tutorial does presume a basic knowledge of commandline commands, though.

to me everything was confusing

way too much at once for me to take in.

What do we have here?

Well, first of all we have to deal with the fact that Haskell code is organized into modules. Modules allow us to easily reuse code in other programs, and they allow the actual language itself to be relatively simple. The name of the file should match the name of the module. Here the module is named "Main".

Next we have the "main" function, the center of activity, as in many other programming languages. The ease of creating this function shouldn't come as any surprise given the fact that Haskell focuses on functions.

Here we simply use the putStrLn function to print a string to the screen on its own line. The similar putStr function does the same, but doesn't automatically skip to a new line.



Testing the code

So, how do we run the code in this file?

Well, open up your trusty Command Prompt window and "cd" to the directory where you saved your Main.hs file.

Once you're there, start Hugs by simply typing "hugs" and hitting enter. Again we're back to:



To load the "Main" module we simply:

The prompt has changed to indicate we're now in the Main module, rather than the Prelude module.

And to run the main function:

So, we've seen a little bit of Haskell

Is it scary?

If you say yes, that's not bad. New things can be scary. You'll get over it.

The real question, though, is: where do we go from here?

Well, since Haskell is a functional programming language, I'm thinking it might be good to see some more functions.

Expanding on Hello, world

Anyone even moderately familiar with my other tutorials will recognize the pattern of starting with a simple hello world program and then expanding upon it.

So, let's create a function "greet" which takes a name and greets that person.

Our Main.hs looked like:

Now we're going to expand it with:

Of course, what if we want just the greeting string?

Tidying the code up - Haskell tricks

Haskell by default infers the types of data being used in a program, but for documentation purposes, we can explicitly specify the types a function uses and returns.

Doing this, we write a type signature for main. The "main" function does an IO action, and returns the closest thing you can get in Haskell to nothing, so:

Double colons separate the name of a function and its signature.

Continuing, we generate a signature for the "greet" and "greeting" functions.

These signatures are saying, "greet takes a string as an argument and does an IO operation," and, "greeting takes a string as an argument and returns another string."

Here we use parentheses because otherwise this would be seen as putStrLn taking two arguments, "greeting" and "name". Since putStrLn only takes one argument, this would clearly be erroneous.

But the parentheses can get annoying, so we have the $ operator. Essentially, the $ operator takes the value on its right hand side and gives it to the function on the left hand side. So, now our greet function looks like:

So, our code now looks like:

Input as well as output

All of this greeting isn't very much good unless we can get input from the user as well, to find out their name.

IO actions aren't quite like other functions. To "chain" them together in sequence we use the keyword "do".

Probably the most immediately notiecable change is the use of indentation. Haskell uses what's referred to as "layout", so semi-colons and braces aren't necessary. They are available:

Of course, the "layout" approach is so much nicer that it'd be silly to use braces and semi-colons.

The second new bit of syntax is:

The return of getLine is a string, but an IO "tainted" string, which can't be immediately used. Using the <- syntax, "name" is a plain old string we can use elsewhere.

Conditionals

How about when the name given to the greeting function is "Haskell", the greeting is "Hey, whadda ya know? This is a Haskell program!"

This should look fairly straightforward to a programmer with basic experience in other languages. Also, again we use "layout" to signify the structure of the conditional.

Case expressions

Let's say we want our program to greet "Matz" with, "You make a good language." Using only "if":

Wow, that's ugly. Fortunately, we have the case expression that should look familiar to programmers.

As with "if", we use layout.

Overloading functions

Of course, we can do this even more cleanly by overloading the greeting function.

Loops

At this point you might be tempted to ask how Haskell handles looping, since that's a pretty basic thing for programmers to learn about in other languages.

Haskell provides no special syntax for looping. All looping is achieved via recursion, where a function calls itself.

A few questions that may come up from looking at this:

What does "return" do? This basically turns () into IO (), which is the return our main function wants.

Why is "do" repeated in the "if" expression? The "if" basically interrupts the chain of expressions we were creating. To start another "chain" we need to use "do" again.

Lists

So, we can greet a number of people. Of course, what if we want to be able to get a list of people we've greeted?

Well, we need a list. A list in Haskell can contain any number of values, as long as they're all the same type. The most basic list is an empty list:

A small list of names might look like:

Anything dealing with such structures in other programming languages, where we often use the term "array", should instantly bring to mind loops. Of course, we've already covered that. Haskell has no explicit looping syntax, but rather recursion. The solution, therefore is to find a way to define lists in a recursive manner.

Thankfully, Haskell lists are naturally recursive. The : operator adds an element to the beginning of a list. Our name list could look like:

Let's look at this in practice in a simple example. A simple range function should create a list of numbers from a start to an end.

This could look fairly cryptic until we break a sample use of it down.

Seeing a function with two arguments points out an interesting fact about Haskell. Arguments to a function are simply separated by space, rather than commas, as in many other programming languages.

So, we might as well jump right in.

Breaking it down

As always, breaking a large complex program down into small, understandable components is essential to understanding.

Our new signature for main indicates that it returns a list of strings. Of course it remains IO "tainted".

As before, if the user enters "quit", then we stop "looping". This time, though, we return an empty list, much as we did in the range function.

We can't directly use main, since it returns an IO tainted list. Instead we first extract that list.

Here we add the current name onto the list of names generated by running the main function again, then "return" that list. It may seem odd, but the last run of the main function is the last to finish.

Another function

Since this is getting fairly complex, perhaps we should break it into a separate function.

And another one

Not a lot has changed, but now we can do something with the list of strings greetMultiple returns. Let's introduce a new function to print all of the strings in a list.

Here we've overloaded the printAll function so printing an empty list just returns (). When I want to print an actual list, I use the pattern "(x:xs)". We've seen the : before. It's used when we're constructing lists. So here x is the first element in the list. The rest of the list is "xs", which can be read as the plural of "x".

Our code now looks like:

There's a simpler way

The task of applying a function to each element in a list is such a common one, you'd think there would be a function or functions already present to solve this problem.

When we're applying a normal function, we can use "map". Let's say we want to double each number in a list.

Now, when we're using IO "actions", we can't use map, but rather we use the mapM_ function.

A different greeting approach

Now, lets say we first want to gather names from a group and then greet them all. First we need a gatherNames function.

Now we can incorporate that into our program and use map to generate the appropriate greetings, then pass the result of that with $ to the "mapM_ putStrLn" we've already seen.

Of course we may look at this and think it's uglier in use than:

But previously we've seen that the definition of printAll adds quite a bit of unnecessary code. So, let's redefine printAll.

Much better. We can improve this further, though. In Haskell, if we have a function which takes two arguments, and only give it one of those arguments, we get another function which takes the final argument.

This is known as "partial application." The partial application of functions allows us to easily create new functions based on already existing functions. The printAll function can be rewritten as:

Similarly we can generate the greetings like so:

Now, our code looks like:

Combining data

In many cases, data isn't as simple as just someone's name. We often want different pieces of data grouped together into a single unit. In Haskell we accomplish his via tuples.

So, with a name, let's say we want to store an age as well, so our greeting function can come up with greetings based on age as well. An example tuple, then, might be:

But, first, we need to be able to read an integer from the user. Since everything read in is in the form of a string, we need a means to extract an integer from a string. The "reads" function steps in. Now, reads returns something along the lines of:

As a result we need to get the first element from the array, and the first item from the tuple. The !! operator and fst function will do these things quite nicely.

So, a basic getAge function might look like:

There's just one problem with this, and it's a big one. What if someone gives you bad input? Well, then reads will gives us am empty list, and that makes "reads input !! 0" cause an error.

We need a way to avoid the error in the first place. We can do so by adding in a conditional expression which checks to see if the list is empty. Of course, if it is, we should probably tell the user we didn't get their age, and ask them again. Recursion will serve us well here.

Taking as step back again

We want to not only get names, but also their ages. Where we had a gatherNames function before, let's replace that with a gatherInfo function.

The basic form looks pretty much like other recursive functions we've defined.

Now, even though we have a very different type of data here than a simple string, we can get the string from each piece of info with map and fst.

Doing something with the extra information

Now we have both name and age info for each of the people we're greeting, and we can still greet people the old way, but that seems to be missing the point of having that extra information in the first place. So, we want to get different greetings depending on age, as well as name.

So, we'll first want to remake the greeting function. Our old greeting function looked like:

The first thing we realize will have to change is the signature of this function.

Now, for the rest, if the age is less than twelve, we'll answer with: "Do your parents know where you are, <name>?" If the age is greater than eighty, we'll answer with: "Do your children know where you are, <name>?" Otherwise we'll use the same rules we applied in the previous greeting function.

To this end we'll use "guards" to define multiple versions of the function for these different conditions. The syntax should be fairly obvious.

So, our entire program is now:

Modules

So, we've seen input, output, strings, functions, conditionals, lists, tuples, and some very handy functions like map and mapM_. What's next?

Well, looking at the above program, most of it handles greeting people, and then one lonely function is the main function where everything happens. What if I want to use the functions related to greeting in another program but I want a different main?

Well, then I need to put all of those functions into their own module. Let's call the new module Greeting. Naturally, it'll be located in the file Greeting.hs.

No our Main module simply looks like:

Of course, if you want it to be explicit where the functions you're using come from, you can prepend the name of the module.

This can be encorced by using the "qualified" import modifier.

And with either we can limit the functions we import.

Introducing our own data types

Of course, at this point, we've used a new data type in the form of a tuple. However, we're counting on being able to recognize that a tuple consisting of a string and an integer is a person.

Haskell gives us the power to be more expressive, by introducing new data types. In this case it's really quite simple.

This introduces a new type called PersonInfo with a single constructor which takes a string and an int. So, let's start by simply redefining the greeting function to take advantage of this new data type.

And, modifying the rest of our code to use this new data type, we end up with:

To arrive at this, I made very few changes to the code I had previously. This should demonstrate quite nicely the expressive power of Haskell.

Greeting other things

Now, we've defined a set of functions useful for greeting a person. However, people are not the only things we may want to greet. Consider, for instance, the case where we want to greet a dog. For the purposes of our program a dog will be described by its name, build and color. Based on these things we'll formulate a greeting.

First thing's first, though. Let's define the data types we'll need.

In the build and Color data types, we have a set of constructors which take no arguments. Any one of these constructors creates a value of type Build or Color. This is somewhat analogous to the idea of enumerated types or "enums" in other languages.

The Dog constructor then uses these data types.

Let's talk about classes

For the purposes of this document, please foget what you know about classes in object-oriented languages like C++, Java, C#, Python, Ruby, Eiffel, etc. When we talk about classes in Haskell, we're talking about classifying data types, according to what functions we can use on them.

The advantage of classifying data types in this way is that we don't need to be as specific when declaring a function. Consider my current declaration of the greeting function.