The Hugs 98 User Manual
top | back | next

## 3`` Hugs for beginners

This section covers the basics that you need to understand to start using Hugs. Most of the points discussed here will be familiar to anyone with experience of previous versions of Hugs or Gofer. To begin with, we need to start the interpreter; the usual way to do this is by using the command `hugs`, which produces a startup banner something like the following (On Windows 95/NT, the installation procedure normally adds Hugs to the start menu. You can also start the interpreter by double clicking on a `.hs` or `.lhs` file.): `
__ __ __ __ ____ ___ _________________________________________
|| || || || || || ||__ Hugs 98: Based on the Haskell 98 standard
||___|| ||__|| ||__|| __|| Copyright (c) 1994-1999
||---|| ___|| World Wide Web: http://haskell.org/hugs
|| || Report bugs to: hugs-bugs@haskell.org
|| || Version: September 1999 _________________________________________
Haskell 98 mode: Restart with command line option -98 to enable extensions
Reading file "/Hugs/lib/Prelude.hs":
Hugs session for:
/Hugs/lib/Prelude.hs
Type :? for help
Prelude>
` The file `/Hugs/lib/Prelude.hs` mentioned here contains standard definitions that are loaded into Hugs each time that the interpreter is started; the filename will vary from one installation to the next (If Hugs does not load correctly, and complains that it cannot find the prelude, then Hugs has not been installed correctly and you should look at the installation instructions.). You may notice a pause while the interpreter is initialized and the prelude definitions are loaded into the system.

### 3.1`` Expressions

In essence, using Hugs is just like using a calculator; the interpreter simply evaluates each expression that is entered, printing the results as it goes. `
Prelude> (2+3)*8
40
Prelude> sum [1..10]
55
Prelude>
` The `Prelude>` characters at the begining of the first, third and fifth lines here form the Hugs prompt. This indicates that the system is ready to accept input from the user, and that it will use definitions from the `Prelude` module to evaluate each expression that is entered; The Hugs prelude is a special module that contains definitions for the built-in operations of Haskell, such as `+`, `*`, and `sum`. In response to the first prompt, the user entered the expression `(2+3)*8`, which was evaluated to produce the result `40`. In response to the second prompt, the user typed the expression `sum [1..10]`. The notation `[1..10]` represents the list of integers between 1 and 10 inclusive, and `sum` is a prelude function that calculates the sum of a list of numbers. So the result obtained by Hugs is: `
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55.
` In fact, we could have typed this sum directly into Hugs: `
Prelude> 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
55
Prelude>
` Unlike many calculators, however, Hugs is not limited to working with numbers; expressions can involve many different types of value, including numbers, booleans, characters, strings, lists, functions, and user-defined datatypes. Some of these are illustrated in the following example: `
Prelude> (not True) || False
False
Prelude> reverse "Hugs is cool"
"looc si sguH"
Prelude> filter even [1..10]
[2, 4, 6, 8, 10]
Prelude> take 10 fibs where fibs = 0:1:zipWith (+) fibs (tail fibs)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
Prelude>
` You cannot create new definitions at the command prompt---these must be placed in files and loaded, as described later. The definition of `fib` in the last example above is local to that expression and will not be remembered for later use. Also, the expressions entered must fit on a single line.

Hugs even allows whole programs to be used as values in calculations. For example, `putStr "hello, "` is a simple program that outputs the string `"hello, "`. Combining this with a similar program to print the string `"world"`, gives: `
Prelude> putStr "hello, " >> putStr "world"
hello, world
Prelude>
` Just as there are standard operations for dealing with numbers, so there are standard operations for dealing with programs. For example, the `>>` operator used here constructs a new program from the programs supplied as its operands, running one after the other. Normally, Hugs just prints the value of each expression entered. But, as this example shows, if the expression evaluates to a program, then Hugs will run it instead. Hugs distinguishes programs from other expressions by looking at the type of the expression entered. For example, the expression `putStr "world"` has type `IO ()`, which identifies it as a program to be executed rather than a value to be printed.

### 3.2`` Commands

Each line that you enter in response to the Hugs prompt is treated as a command to the interpreter. For example, when you enter an expression into Hugs, it is treated as a command to evaluate that expression, and to display the result. There are two commands that are particularly worth remembering:

- `:q` exits the interpreter. On most systems, you can also terminate Hugs by typing the end-of-file character.
- `:?` prints a list of all the commands, which can be useful if you forget the name of the command that you want to use.

Like most other commands in Hugs, these commands both start with a colon, `:`.

Note that the interrupt key (control-C or control-Break on most systems) can be used to abandon the process of compiling files or evaluating expressions. When the interrupt is detected, Hugs prints `{Interrupted!}` and returns to the prompt so that further commands can be entered.

### 3.3`` Programs

Functions like `sum`, `>>` and `take`, used in the examples above, are all defined in the Hugs prelude; you can actually do quite a lot using just the types and operations provided by the prelude. But, in general, you will also want to define new types and operations, storing them in modules that can be loaded and used by Hugs. A module is simply a collection of definitions stored in a file. For example, suppose we enter the following module: `
module Fact where
fact :: Integer -> Integer
fact n = product [1..n]
` into a file called `Fact.hs`. (By convention, Hugs modules are stored in files ending with the characters `.hs`. The file name should match the name of the module it contains.) The `product` function used here is also defined in the prelude, and can be used to calculate the product of a list of numbers, just as you might use `sum` to calculate the corresponding sum. So the line above defines a function `fact` that takes an argument `n` and calculates its factorial. In standard mathematical notation, `fact n = n!`, which is usually defined by an equation: `
n! = 1 * 2 * ... * (n-1) * n
` Once you become familiar with the notation, you will see that the Hugs definition is really very similar to this informal, mathematical version: the factorial of a number `n` is the product of the numbers from 1 to `n`.

Before we can use this definition in a Hugs session, we have to load `Fact.hs` into the interpreter. One of the simplest ways to do this uses the `:load` command: `
Prelude> :load fact.hs
Reading file "fact.hs":
Hugs session for:
/Hugs/lib/Prelude.hs
Fact.hs
Fact>
` Notice the list of filenames displayed after `Hugs session for:`; this tells you which module files are currently being used by Hugs, the first of which is always the standard prelude. The prompt is now `Fact` and evaluation will take place within this new module. We can start to use the `fact` function that we have defined: `
Fact> fact 6
720
Fact> fact 6 + fact 7
5760
Fact> fact 7 `div` fact 6
7
Fact>
` As another example, the standard formula for the number of different ways of choosing `r` objects from a collection of `n` objects is n!/(r!(n-r)!). A simple and direct (but otherwise not particularly good) definition for this function in Hugs is as follows: `
comb n r = fact n `div` (fact r * fact (n-r))
` One way to use this function is to include its definition as part of an expression entered in directly to Hugs: `
Fact> comb 5 2 where comb n r = fact n `div` (fact r * fact (n-r))
10
Fact>
` The definition of `comb` here is local to this expression. If we want to use `comb` several times, then it would be sensible to add its definition to the file `Fact.hs`. Once this has been done, and the `Fact.hs` file has been reloaded, then we can use the `comb` function like any other built-in operator: `
Fact> :reload
Reading file "fact.hs":
Hugs session for:
/Hugs/lib/Prelude.hs
Fact.hs
Fact> comb 5 2
10
Fact>
`

The Hugs 98 User Manual
top | back | next
May 22, 1999