CSc 372 - Comparative Programming Languages
3 : Haskell -- Introduction

Christian Collberg

Department of Computer Science

University of Arizona

1 What is Haskell?

Haskell is a functional programming language.
We study Haskell because, compared to other functional languages
1. Haskell is statically typed (the signature of all functions and the types of all variables are known prior to execution);
2. Haskell uses lazy rather than eager evaluation (expressions are only evaluated when needed);
3. Haskell uses type inference to assign types to expressions, freeing the programmer from having to give explicit types;
4. Haskell is pure (it has no side-effects).

2 What is Haskell?...

Haskell implementations are also interactive which means that the user interface is like a calculator; you enter expressions, the Haskell interpreter checks them, evaluates them, and prints the result. This is called the ``read-eval-print'' loop:

ReadEvalPrint

$\begin{gprogram} \redtxt{> hugs} \\ Prelude> (2*5)+3 \\ 13 \end{gprogram}$

3 What is Haskell?...

$\begin{gprogram} \redtt{> hugs} \\ Prelude> :load /usr/lib64/hugs/demos/Eliza.h... ... \redtt{i'm bored!} \\ Did you come to me because you are bored? \end{gprogram}$

4 What is Haskell?...

eliza = interact (writeStr hi $ session initial [])
 where hi = "\n\
             \Hi! I'm Eliza. I am your personal therapy computer.\n\
             \Please tell me your problem.\n\
             \\n"
 
session rs prev
       = readLine "> " (\l ->
         let ws             = words (trim l)
             (response,rs') = if prev==ws then repeated rs else answer rs ws
         in  writeStr (response ++ "\n\n") $ session rs' ws)

5 `commaint` - A Haskell Program

Real functional programs are, naturally, a bit more complex. They make heavy use of
1. higher-order functions, functions which take functions as arguments.
2. function composition, which is a way to combine simple functions into more powerful ones.
3. function libraries, collections of functions that have proven useful. The standard.prelude that you've seen that the Haskell interpreter loads on start-up, is one such collection.

6 `commaint` - A Haskell Program...

So what does a ``real'' functional Haskell program look like? Let's have a quick look at one simple (?) function, commaint.
commaint works on strings, which are simply lists of characters.
You are not supposed to understand this! Yet...

From the commaint documentation:

[commaint] takes a single string argument containing a sequence of digits, and outputs the same sequence with commas inserted after every group of three digits, $\cdots$

7 `commaint` - A Haskell Program...

Sample interaction:
$\begin{gprogram} \redtxt{? commaint ''1234567''} \\ \x 1,234,567 \end{gprogram}$

commaint in Haskell:
$\begin{gprogram} commaint = \= reverse . foldr1 ($\backslash$x y->x++'',''++y) .... ...= takeWhile (not.null) . \\ \x \x map (take n).iterate (drop n) \end{gprogram}$

8 `commaint` - A Haskell Program...

CommaInt

9 `commaint` - A Haskell Program...

commaint in Haskell:
$\begin{gprogram} commaint = \= reverse . foldr1 ($\backslash$x y->x++'',''++y) .... ...= takeWhile (not.null) . \\ \x \x map (take n).iterate (drop n) \end{gprogram}$

commaint in English:

``First reverse the input string. Take the resulting string and separate into chunks of length 3. Then append the chunks together, inserting a comma between chunks. Reverse the resulting string.''

10 `commaint` - A Haskell Program...

$\begin{gprogram} commaint = \= reverse . foldr1 ($\backslash$x y->x++'',''++y) .... ...= takeWhile (not.null) . \\ \x \x map (take n).iterate (drop n) \end{gprogram}$

group n is a ``local function.'' It takes a string and an integer as arguments. It divides the string up in chunks of length n.
reverse reverses the order of the characters in a string.
drop n xs returns the string that remains when the first n characters of xs are removed.

11 `commaint` - A Haskell Program...

$\begin{gprogram} commaint = \= reverse . foldr1 ($\backslash$x y->x++'',''++y) .... ...= takeWhile (not.null) . \\ \x \x map (take n).iterate (drop n) \end{gprogram}$

iterate (drop 3) s returns the infinite (!) list of strings
$\begin{gprogram}[s, drop 3 s, drop 3 (drop 3 s),\\ \x drop 3 (drop 3 (drop 3 s)), $\cdots$] \end{gprogram}$
take n s returns the first n characters of s.

12 `commaint` - A Haskell Program...

$\begin{gprogram} commaint = \= reverse . foldr1 ($\backslash$x y->x++'',''++y) .... ...= takeWhile (not.null) . \\ \x \x map (take n).iterate (drop n) \end{gprogram}$

map (take n) s takes a list of strings as input. It returns another list of strings, where each string has been shortened to n characters. (take n) is a function argument to map.
takeWhile (not.null) removes all empty strings from a list of strings.

13 `commaint` - A Haskell Program...

$\begin{gprogram} commaint = \= reverse . foldr1 ($\backslash$x y->x++'',''++y) .... ...= takeWhile (not.null) . \\ \x \x map (take n).iterate (drop n) \end{gprogram}$

foldr1 (x y->x++","++y) s takes a list of strings s as input. It appends the strings together, inserting a comma inbetween each pair of strings.

14 `commaint` - A Haskell Program...

Since Haskell is an interactive language, we can always try out (parts of) functions that we don't understand.

$\begin{gprogram} \redtxt{? reverse ''1234567''} \\ \x 7654321\\ \redtxt{? take... ... [''7654321'', ''4321'', ''1'', [], [], $\cdots$ \{interrupt!\} \end{gprogram}$

Christian S. Collberg
2007-08-21

CSc 372 - Comparative Programming Languages 3 : Haskell -- Introduction

CSc 372 - Comparative Programming Languages
3 : Haskell -- Introduction