3.4. Interactive evaluation at the prompt
Prev | Chapter 3. Using GHCi | Next

## 3.4. Interactive evaluation at the prompt

When you type an expression at the prompt, GHCi immediately evaluates and prints the result. But that's not the whole story: if you type something of type `IO a` for some `a`, then GHCi executes it as an IO-computation, and doesn't attempt to print the result:.

    Prelude> "hello"
    "hello"
    Prelude> putStrLn "hello"
    hello

What actually happens is that GHCi typechecks the expression, and if it doesn't have an `IO` type, then it transforms it as follows: an expression `e` turns into

                 let it = e;
                 print it

which is then run as an IO-action.

Hence, the original expression must have a type which is an instance of the `Show` class, or GHCi will complain:

    Prelude> id
    No instance for `Show (a -> a)'
    arising from use of `print'
    in a `do' expression pattern binding: print it

The error message contains some clues as to the transformation happening internally.

### 3.4.1. What's really in scope at the prompt?

When you type an expression at the prompt, what identifiers and types are in scope? GHCi provides a flexible way to control exactly how the context for an expression is constructed. Let's start with the simple cases; when you start GHCi the prompt looks like this:

    Prelude>

Which indicates that everything from the module `Prelude` is currently in scope. If we now load a file into GHCi, the prompt will change:

    Prelude> :load Main.hs
    Compiling Main             ( Main.hs, interpreted )
    *Main>

The new prompt is `*Main`, which indicates that we are typing expressions in the context of the top-level of the `Main` module. Everything that is in scope at the top-level in the module `Main` we just loaded is also in scope at the prompt (probably including `Prelude`, as long as `Main` doesn't explicitly hide it).

The syntax `*`module`` indicates that it is the full top-level scope of `module` that is contributing to the scope for expressions typed at the prompt. Without the `*`, just the exports of the module are visible.

We're not limited to a single module: GHCi can combine scopes from multiple modules, in any mixture of `*` and non-`*` forms. GHCi combines the scopes from all of these modules to form the scope that is in effect at the prompt. For technical reasons, GHCi can only support the `*`-form for modules which are interpreted, so compiled modules and package modules can only contribute their exports to the current scope.

The scope is manipulated using the `:module` command. For example, if the current scope is `Prelude`, then we can bring into scope the exports from the module `IO` like so:

    Prelude> :module +IO
    Prelude,IO> hPutStrLn stdout "hello\n"
    hello
    Prelude,IO>

(Note: `:module` can be shortened to `:m`). The full syntax of the `:module` command is:

    :module [+|-] [*]mod1 ... [*]modn

Using the `+` form of the `module` commands adds modules to the current scope, and `-` removes them. Without either `+` or `-`, the current scope is replaced by the set of modules specified. Note that if you use this form and leave out `Prelude`, GHCi will assume that you really wanted the `Prelude` and add it in for you (if you don't want the `Prelude`, then ask to remove it with `:m -Prelude`).

The scope is automatically set after a `:load` command, to the most recently loaded "target" module, in a `*`-form if possible. For example, if you say `:load foo.hs bar.hs` and `bar.hs` contains module `Bar`, then the scope will be set to `*Bar` if `Bar` is interpreted, or if `Bar` is compiled it will be set to `Prelude,Bar` (GHCi automatically adds `Prelude` if it isn't present and there aren't any `*`-form modules).

With multiple modules in scope, especially multiple `*`-form modules, it is likely that name clashes will occur. Haskell specifies that name clashes are only reported when an ambiguous identifier is used, and GHCi behaves in the same way for expressions typed at the prompt.

#### 3.4.1.1. Qualified names

To make life slightly easier, the GHCi prompt also behaves as if there is an implicit `import qualified` declaration for every module in every package, and every module currently loaded into GHCi.

### 3.4.2. Using `do-`notation at the prompt

GHCi actually accepts statements rather than just expressions at the prompt. This means you can bind values and functions to names, and use them in future expressions or statements.

The syntax of a statement accepted at the GHCi prompt is exactly the same as the syntax of a statement in a Haskell `do` expression. However, there's no monad overloading here: statements typed at the prompt must be in the `IO` monad.

Here's an example:

    Prelude> x <- return 42
    Prelude> print x
    42
    Prelude>

The statement `x <- return 42` means “execute `return 42` in the `IO` monad, and bind the result to `x`”. We can then use `x` in future statements, for example to print it as we did above.

Of course, you can also bind normal non-IO expressions using the `let`-statement:

    Prelude> let x = 42
    Prelude> print x
    42
    Prelude>

An important difference between the two types of binding is that the monadic bind (`p <- e`) is strict (it evaluates `e`), whereas with the `let` form, the expression isn't evaluated immediately:

    Prelude> let x = error "help!"
    Prelude> print x
    *** Exception: help!
    Prelude>

Any exceptions raised during the evaluation or execution of the statement are caught and printed by the GHCi command line interface (for more information on exceptions, see the module `Control.Exception` in the libraries documentation).

Every new binding shadows any existing bindings of the same name, including entities that are in scope in the current module context.

WARNING: temporary bindings introduced at the prompt only last until the next `:load` or `:reload` command, at which time they will be simply lost. However, they do survive a change of context with `:module`: the temporary bindings just move to the new location.

HINT: To get a list of the bindings currently in scope, use the `:show bindings` command:

    Prelude> :show bindings
    x :: Int
    Prelude>

HINT: if you turn on the `+t` option, GHCi will show the type of each variable bound by a statement. For example:

    Prelude> :set +t
    Prelude> let (x:xs) = [1..]
    x :: Integer
    xs :: [Integer]

### 3.4.3. The `it` variable

Whenever an expression (or a non-binding statement, to be precise) is typed at the prompt, GHCi implicitly binds its value to the variable `it`. For example:

    Prelude> 1+2
    3
    Prelude> it * 2
    6

This is a result of the translation mentioned earlier, namely that an expression `e` is translated to

                 let it = e;
                 print it

before execution, resulting in a binding for `it`.

If the expression was of type `IO a` for some `a`, then `it` will be bound to the result of the `IO` computation, which is of type `a`. eg.:

    Prelude> Time.getClockTime
    Prelude> print it
    Wed Mar 14 12:23:13 GMT 2001

The corresponding translation for an IO-typed `e` is

                 it <- e

Note that `it` is shadowed by the new value each time you evaluate a new expression, and the old value of `it` is lost.

### 3.4.4. Type defaulting in GHCi

Consider this GHCi session:

      ghci> reverse []

What should GHCi do? Strictly speaking, the program is ambiguous. `show (reverse [])` (which is what GHCi computes here) has type `Show a => a` and how that displays depends on the type `a`. For example:

      ghci> (reverse []) :: String
      ""
      ghci> (reverse []) :: [Int]
      []

However, it is tiresome for the user to have to specify the type, so GHCi extends Haskell's type-defaulting rules (Section 4.3.4 of the Haskell 98 Report (Revised)) as follows. If the expression yields a set of type constraints that are all from standard classes (`Num`, `Eq` etc.), and at least one is either a numeric class or the `Show`, `Eq`, or `Ord` class, GHCi will try to use one of the `default` types, just as described in the Report. The standard defaulting rules require that one of the classes is numeric; the difference here is that defaulting is also triggered at least one is `Show`, `Eq`, or `Ord`.

Prev | Up | Next
3.3. Loading compiled code | Home | 3.5. Invoking GHCi