haskell - interactive evaluation at the prompt

Like most other language, haskell also has an interative prompt where you use repl way to quickly run and test your code. however, since haskell do no thave the statement ending sign such as the ; which is common in other languages, you may find yourselves lacking such a construct. 

However, there are some way that can help alleviate the problem, they are:

• use of the let biding with the help of { and } and explicit  braces and semicolons
• wrapping the statement in :{ and :}

The example that you can get from the haskell.org on topic : Interactive evaluation  at the prompt. 

2.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.

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.

If -fprint-bind-result is set then GHCi will print the result of a statement if and only if:

• The statement is not a binding, or it is a monadic binding (p <- e) that binds exactly one variable.

• The variable's type is not polymorphic, is not (), and is an instance of Show

.

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

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

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

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

Note that let bindings do not automatically print the value bound, unlike monadic bindings.

Hint: you can also use let-statements to define functions at the prompt:

Prelude> let add a b = a + b
Prelude> add 1 2
3
Prelude>

However, this quickly gets tedious when defining functions with multiple clauses, or groups of mutually recursive functions, because the complete definition has to be given on a single line, using explicit braces and semicolons instead of layout:

Prelude> let { f op n [] = n ; f op n (h:t) = h `op` f op n t }
Prelude> f (+) 0 [1..3]
6
Prelude>

To alleviate this issue, GHCi commands can be split over multiple lines, by wrapping them in :{ and :} (each on a single line of its own):

Prelude> :{
Prelude| let { g op n [] = n
Prelude|     ; g op n (h:t) = h `op` g op n t
Prelude|     }
Prelude| :}
Prelude> g (*) 1 [1..3]
6

Such multiline commands can be used with any GHCi command, and the lines between :{ and :} are simply merged into a single line for interpretation. That implies that each such group must form a single valid command when merged, and that no layout rule is used. The main purpose of multiline commands is not to replace module loading but to make definitions in .ghci-files (see Section 2.9, “The .ghci file”) more readable and maintainable.

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]

 

2.4.3. Multiline input

Apart from the :{ ... :} syntax for multi-line input mentioned above, GHCi also has a multiline mode, enabled by :set +m, in which GHCi detects automatically when the current statement is unfinished and allows further lines to be added. A multi-line input is terminated with an empty line. For example:

Prelude> :set +m
Prelude> let x = 42
Prelude|

Further bindings can be added to this let statement, so GHCi indicates that the next line continues the previous one by changing the prompt. Note that layout is in effect, so to add more bindings to this let we have to line them up:

Prelude> :set +m
Prelude> let x = 42
Prelude|     y = 3
Prelude| 
Prelude>

Explicit braces and semicolons can be used instead of layout, as usual:

Prelude> do {
Prelude| putStrLn "hello"
Prelude| ;putStrLn "world"
Prelude| }
hello
world
Prelude>

Note that after the closing brace, GHCi knows that the current statement is finished, so no empty line is required.

Multiline mode is useful when entering monadic do statements:

Control.Monad.State> flip evalStateT 0 $ do
Control.Monad.State| i <- get
Control.Monad.State| lift $ do
Control.Monad.State|   putStrLn "Hello World!"
Control.Monad.State|   print i
Control.Monad.State|
"Hello World!"
0
Control.Monad.State>

During a multiline interaction, the user can interrupt and return to the top-level prompt.

Prelude> do
Prelude| putStrLn "Hello, World!"
Prelude| ^C
Prelude>

 

A running example 

NOTE: the following is only workable on a ghci/7.6.1

Prelude>:set +m

 

Below I have an running example

 

Prelude>import Data.Char (chr, ord)
Prelude Data.Char> :{
Prelude Data.Char| let {
Prelude Data.Char|   encode :: Int -> String -> String
Prelude Data.Char|  ;encode shift msg =
Prelude Data.Char|      let ords = map ord msg
Prelude Data.Char|          shifted = map (+shift) ords
Prelude Data.Char|      in map chr shifted;
Prelude Data.Char| }
Prelude Data.Char| :}
Prelude Data.Char> encode 3 "Hello world"
"Khoor#zruog"

 

you can also do this (with the do monad)

Prelude Data.Char> do {
Prelude Data.Char|    let { encode :: Int -> String -> String;
Prelude Data.Char|    encode shift msg =
Prelude Data.Char|     let ords = map ord msg
Prelude Data.Char|         shifted = map (+shift) ords
Prelude Data.Char|     in map chr shifted;
Prelude Data.Char|    };
Prelude Data.Char|    encode 3 "hello world";
Prelude Data.Char| }
"khoor#zruog"

 A note, " The last statement in a 'do' block must be an expression", you cannot do this..

Prelude Data.Char> do {
Prelude Data.Char|   let { encode :: Int -> String -> String;
Prelude Data.Char|   encode shift msg =
Prelude Data.Char|    let ords = map ord msg
Prelude Data.Char|        shifted = map (+shift) ords
Prelude Data.Char|    in map chr shifted;
Prelude Data.Char|    };
Prelude Data.Char| }

<interactive>:152:3:
    The last statement in a 'do' block must be an expression
      let encode :: Int -> String -> String
          encode shift msg = let ... in map chr shifted

 

if you have multiple line enabled, you can just write with one let statement. as follow. 

 

Prelude Data.Char> let {
Prelude Data.Char| encode :: Int -> String -> String
Prelude Data.Char| ;encode shift msg =
Prelude Data.Char| let ords = map ord msg
Prelude Data.Char|     shifted = map (+shift) ords
Prelude Data.Char| in map chr shifted;
Prelude Data.Char| }

 

 Cross references:

• interactive evaluation
• ghci debugger