Evaluate expression <<I>expr</I>>

Evaluate expression <expr>

To evaluate an expression, the user simply enters it at the Hugs prompt. This is treated as a special case, without the leading colon that is required for other commands. The expression must fit on a single line; there is no way to continue an expression onto the next line of input to the interpreter. The actual behaviour of the evaluator depends on the type of <expr>:

If <expr> has type IO (), then it will be treated as a program using the I/O facilities provided by the Haskell IO monad.
```
 Prelude> putStr "Hello, world"

 Hello, world

 Prelude> 
```
In any other case, the value produced by the expression is converted to a string by applying the show function from the standard prelude, and the interpreter uses this to print the result.
```
 Prelude> "Hello" ++ ", " ++ "world"

 "Hello, world"

 Prelude> 
```
Unlike some previous versions of Hugs, there is no special treatment for values of type String; to display a string without the enclosing quotes and special escapes, you should turn it into a program using the putStr function, as shown above.

The interpreter will not evaluate an expression that contains a syntax error, a type error, or a reference to an undefined variable:


 Prelude> sum [1..)

 ERROR: Syntax error in expression (unexpected `)')

 Prelude> sum 'a'

 ERROR: Type error in application

 *** expression     : sum 'a'

 *** term           : 'a'

 *** type           : Char

 *** does not match : [a]

 Prelude> sum [1..n]

 ERROR: Undefined variable "n"

 Prelude>

Another common problem occurs if there is no show function for the expression entered---that is, if its type is not an instance of the Show class. For example, suppose that a module defines a type T without a Show instance:


 module Test where

 data T = A | B

With just these definitions, any attempt to evaluate an expression of type T will cause an error:


 Test> A

 ERROR: Cannot find "show" function for:

 *** expression : A

 *** of type    : T

 Test>

To avoid problems like this, you will need to add an instance of the Show class to your program. One of the simplest ways to do that is to request a derived instance of Show as part of the datatype definition, as in:


 module Test where

 data T = A | B  deriving Show

Once this has been loaded, Hugs will evaluate and display values of type T:


 Test> A

 A

 Test> take 5 (cycle [A,B])

 [A, B, A, B, A]

 Test>

Values in the IO monad are only treated as programs if they return (). For example, getChar has type IO Char, so it is printed using show:


 Prelude> getChar

 <>

 Prelude>

Hugs will not execute this expression as a program because it does not specify what should be done with the character returned by getChar. If you want to run getChar as a program and, for example, discard its result, then you must do this explicitly:


 Prelude> do getChar; return ()

 w

 Prelude>

You should also note that the behaviour of the evaluator can be changed while the interpreter is running by using the :set command to modify option settings.