The prebuilt binary packages of GHC should work on versions of Windows as old as ME, and on all newer versions (NT, 2000, XP, and Vista). We have installed GHC 6.6.1 under Windows XP Service Pack 2; here are the steps we followed.

	Note
	On Windows, GHC requires almost 340MB of disk space.

Our first step is to visit the GHC download page, and follow the link to the current stable release. Scroll down to the section entitled “Binary packages”, and then again to the subsection for Windows. Download the installer; in our case, it's named ghc-6.6.1-i386-windows.exe.

After the installer has downloaded, double-clicking on it starts the installation process. This simply involves stepping through a normal Windows installer wizard.

Once the installer has finished, the Start Menu's “All Programs” submenu should have a GHC folder, inside of which you'll find an icon that you can double-click on to run ghci.

Clicking on the ghci icon brings up a normal Windows console window, running ghci.

	Note
	The GHC installer automatically modifies your user account's PATH environment variable so that commands like ghc will be present in the command shell's search path (i.e. you can type a GHC command name without typing its complete path). This change will not take effect until you log out and back in again.

Installing GHC on Mac OS X takes several steps, as GHC does not yet have a standard OS X installer. We have installed GHC 6.6.1 under Mac OS X 10.4, on an Intel-based MacBook. We're not regular Mac users, and had never tried installing GHC on OS X before, and everything worked for us on the first try, so take heart if these instructions seem daunting. The process is neither difficult nor especially time-consuming.

Our first step is to visit the GHC download page, and follow the link to the current stable release. Scroll down to the section entitled “Binary packages”, and then again to the subsection for Mac OS X. There are four components to download, all of which are necessary.

The Xcode software installer may have come bundled on a DVD with your Mac. If not (or you can't find it), you can download it from Apple and install it. Once you've finished installing Xcode, continue on to download the remaining three packages.

After these downloads complete, you'll have three archive icons on your desktop.

Double click on each one to unpack it, giving you three folders.

Open a Finder window with command-n. In the left sidebar, click on your system's main hard disk icon (often named “Macintosh HD”). In the main portion of the window, double click on System to open that folder, then on Library. Select the GMP.framework and GNUreadline.framework folders on your desktop, and drag them onto the Frameworks folder in the Finder window that is visiting /System/Library. If the Finder refuses to install them because you don't have permission, it will probably display an “Authenticate” button in the alert it displays. Click it, enter your password, and installation can proceed.

With the prerequisites in place, you can turn to installing GHC. You'll need to open a Terminal window (you can find it in /Applications/Utilities).

	Note
	Since most of your interactions with GHC will be through a Terminal window, this might be a good time to add the Terminal application to your dock, if you haven't already done so.

Inside the Terminal window, change directory to Desktop/ghc-6.6.1, and run ./configure to set up the command line installer. This configures GHC to install to /usr/local. When the configure script finishes, run sudo make install, and type your password when you are prompted for it.

The installation process should take a minute or two. If you don't already have /usr/local/bin in your shell's search path, add it.

Finally, you should be able to successfully run the ghci command from your shell prompt.

FIXME: actual content.

GHC is packaged for Fedora. From a shell, all you need to do is run sudo yum -y install ghc ghc-doc ghc661-prof. The base package, containing the ghc and ghci commands and libraries, is ghc. The ghc-doc package contains the GHC user guide, and command and library documentation. The ghc661-prof package contains profiling-capable versions of the standard libraries (note: its version number may have changed by the time you read this).

Once installation has finished, you should be able to run ghci from the shell immediately. You won't need to change your shell's search path, or set any environment variables.

On most systems, ghci has some amount of command line editing ability. On Unix-like systems, it uses the GNU readline library, which is powerful and customisable. On Windows, ghci's command line editing capabilities are provided by the doskey command.

If you haven't used command line editing before, it's a huge time saver. The basics are common to both Unix-like and Windows systems. Pressing the up arrow key on your keyboard recalls the last line of input you entered; pressing up repeatedly cycles through earlier lines of input. You can use the left and right arrow keys to move around inside a line of input.

Just knowing this much will save you a lot of repeated typing. If you want to learn more about command line editing on your system, consult the readline or doskey documentation.

We can immediately start typing expressions, to see what ghci will do with them. Basic arithmetic works as we'd expect.

ghci> 2 + 2
4
ghci> 31337 * 101
3165037
ghci> 7/2
3.5
ghci> 2 + 2
4
ghci> 31337 * 101
3165037
ghci> 7/2
3.5

As the expressions above imply, Haskell has a notion of integers and floating point numbers. In fact, it allows us to use arbitrarily large integers. Here, the (^) is the exponentiation operator.

ghci> 31337 ^ 15
27596961266048865189478071639245914618921288733595362747095073723993
ghci> 31337 ^ 15
27596961266048865189478071639245914618921288733595362747095073723993

Like other languages that use infix notation to write mathematical expressions, Haskell has a notion of operator precedence. This allows us to get rid of a few parentheses. For example, the multiplication operator has a higher precedence than the addition operator, so Haskell treats the two following expressions as equivalent.

ghci> (4 * 4) + 1
17
ghci> 4 * 4 + 1
17
ghci> (4 * 4) + 1
17
ghci> 4 * 4 + 1
17

Note

As in other languages, it's often better to leave at least some parentheses in place, even when Haskell allows us to omit them. Their presence can help future readers (including ourselves) to understand what we intended. Even more importantly, complex expressions that rely on operator precedence are notorious sources of bugs. A compiler and a human can easily end up with different notions of what a long, parenthesis-free expression is supposed to do.

Haskell presents us with one peculiarity in how we must write numbers: it's often necessary to enclose a negative number in parentheses. This affects us as soon as we move past writing the simplest of expressions.

ghci> -3
-3
ghci> 2 + -3

<interactive>:1:0:
    precedence parsing error
	cannot mix `(+)' [infixl 6] and prefix `-' [infixl 6] in the same infix expression
ghci> 2 + (-3)
-1
ghci> -3
-3
ghci> 2 + -3

<interactive>:1:0:
    precedence parsing error
	cannot mix `(+)' [infixl 6] and prefix `-' [infixl 6] in the same infix expression
ghci> 2 + (-3)
-1

Later on, we'll be seeing how Haskell lets us devise entirely new infix operators. Now that we've been forewarned, the following may not prove too surprising.

Most of the time, we can omit whitespace from expressions, and Haskell will parse them as we intended. But not always. Here's an expression that works:

ghci> 2+3
5
ghci> 2+3
5

And here's one that similar to the problematic negative number example above, but results in a different error message.

ghci> 2+-3

<interactive>:1:1: Not in scope: `+-'
ghci> 2+-3

<interactive>:1:1: Not in scope: `+-'

What's happening here is that the Haskell parser is reading +- as a single token, and trying to use it as an operator. Once again, a few parentheses get us and ghci looking at the expression in the same way.

ghci> 2+(-3)
-1
ghci> 2+(-3)
-1

Compared to other languages, this unusual treatment of negative numbers is an annoyance, for sure, but it at least represents a reasoned tradeoff. As we mentioned, Haskell lets us define new operators at any time, and choose the precedence and associativity of those operators. The language designers chose to accept a slightly cumbersome syntax for negative numbers in exchange for this expressive power.

ghci defines at least one well-known mathematical constant for us.

ghci> pi
3.141592653589793
ghci> pi
3.141592653589793

But its coverage of mathematical constants is not great, as we can quickly see. Let's see if Euler's number, e, is available.

ghci> e

<interactive>:1:0: Not in scope: `e'
ghci> e

<interactive>:1:0: Not in scope: `e'

Oh well.

	Note
	If the above “not in scope” error message seems a little daunting, don't worry. All it means is that there is no variable defined with the name e.

We can define e ourselves; the let construct allows us to introduce a new variable.

ghci> let e = 2.7182818284590451
ghci> let e = 2.7182818284590451

We can then use our definition of e in arithmetic expressions.

ghci> (e ** pi) - pi
19.99909997918947
ghci> (e ** pi) - pi
19.99909997918947

Haskell gives us the usual operators for working with boolean values.

ghci> True
True
ghci> False
False
ghci> True && False
False
ghci> False || True
True
ghci> True
True
ghci> False
False
ghci> True && False
False
ghci> False || True
True

Unlike some other languages, Haskell does not treat the number zero as synonymous with False, nor does it accept non-zero as True.

ghci> True && 1

<interactive>:1:8:
    No instance for (Num Bool)
      arising from the literal `1' at <interactive>:1:8
    Possible fix: add an instance declaration for (Num Bool)
    In the second argument of `(&&)', namely `1'
    In the expression: True && 1
    In the definition of `it': it = True && 1
ghci> True && 1

<interactive>:1:8:
    No instance for (Num Bool)
      arising from the literal `1' at <interactive>:1:8
    Possible fix: add an instance declaration for (Num Bool)
    In the second argument of `(&&)', namely `1'
    In the expression: True && 1
    In the definition of `it': it = True && 1

Comparison operators are mostly familiar from other languages.

ghci> 1 == 1
True
ghci> 2 < 3
True
ghci> 4 >= 3.99
True
ghci> 1 == 1
True
ghci> 2 < 3
True
ghci> 4 >= 3.99
True

There's one exception: the “is not equal” operator is (/=).

ghci> 2 /= 3
True
ghci> 2 /= 3
True

In addition to integers and floating point numbers, Haskell supports rational numbers. Haskell coders collect self-contained hunks of code into modules. The integer and floating point numbers, and the operators we've seen so far, are packaged in a module named Prelude.

(The Prelude module is often referred to as “the standard prelude”, because its contents are defined by the Haskell 98 standard. Sometimes, it's simply shortened to “the prelude”.)

The prelude is always implicitly available; we don't need to take any actions to use the types, values, or functions it defines. But to use definitions from other modules, we must import them. To use rational numbers, the module we need to import is named Data.Ratio. We can use a ghci directive named :module to import it.

ghci> :module Data.Ratio
ghci> :module Data.Ratio

The notation for writing a rational number is as follows.

ghci> 7 % 2
7%2
ghci> 7 % 2
7%2

The (%) operator above takes two integers and constructs a rational number from them.

Arithmetic on rational numbers works in the same way as on other types of number, even allowing the same operators.

ghci> 7 % 2 + 2 % 3
25%6
ghci> 7 % 2 + 2 % 3
25%6

Haskell represents a rational number with the lowest denominator it can. For example, the result of the following expression is simplified from 254%7 to something easier to read.

ghci> (22 % 7) * 7
22%1
ghci> (22 % 7) * 7
22%1

Is it too early to introduce this? Does it disrupt the flow?

We've already seen an exponentiation operator in Haskell: (^) raises a number to an integer power. The word integer is significant here: if we try to raise a number to the power of a floating point number using the (^) operator, exciting things will happen.

ghci> 12 ^ 2
144
ghci> 12.1 ^ 2
146.41
ghci> 12 ^ 2.1

<interactive>:1:0:
    Ambiguous type variable `t' in the constraints:
      `Integral t' arising from use of `^' at <interactive>:1:0-7
      `Fractional t'
	arising from the literal `2.1' at <interactive>:1:5-7
    Probable fix: add a type signature that fixes these type variable(s)
ghci> 12 ^ 2
144
ghci> 12.1 ^ 2
146.41
ghci> 12 ^ 2.1

<interactive>:1:0:
    Ambiguous type variable `t' in the constraints:
      `Integral t' arising from use of `^' at <interactive>:1:0-7
      `Fractional t'
	arising from the literal `2.1' at <interactive>:1:5-7
    Probable fix: add a type signature that fixes these type variable(s)

Notice from the second example that it doesn't matter whether or not the base is an integer, only that the exponent must be.

There's a further constraint on the exponent that is not immediately obvious: it must be not just an integer, but a non-negative integer.

ghci> 12 ^ 2
144
ghci> 12 ^ (-2)
*** Exception: Prelude.^: negative exponent
ghci> 12 ^ 2
144
ghci> 12 ^ (-2)
*** Exception: Prelude.^: negative exponent

If you think about the simplest definition of exponentiation, which is a number repeatedly multiplied by itself a given number of times, this restriction makes sense.

Haskell's exponentiation operator follows the convention that a number raised to the zeroth power is one. This is why the restriction on the exponent is that it must be non-negative, and not that it must be positive.

ghci> 12 ^ 0
1
ghci> 12 ^ 0
1

Haskell also provides a generalised integer exponentiation operator, (^^). This accepts both positive and negative exponents, following the rule that a number raised to a negative exponent is the reciprocal of the number raised to the positive exponent. Let's try this with both integer and rational bases.

ghci> 12 ^^ (-2)
6.944444444444444e-3
ghci> (12%1) ^^ (-2)
1%144
ghci> 12 ^^ (-2)
6.944444444444444e-3
ghci> (12%1) ^^ (-2)
1%144

Finally, Haskell also gives us a floating point exponentiation operator, (**).

ghci> 12.2 ** 2.1
191.1417880875707
ghci> 12.2 ** 2.1
191.1417880875707