In this first lesson we demonstrate working with the basic Haskell tools so you can follow along with everything we’ll be doing in this course.

We’ll be repeating the same demonstration three times:

  1. with a text editor and a terminal;
  2. with Visual Studio;
  3. with

The first two will assume that you have Haskell already installed on your computer. If you don’t already have that set up, then for this course you should be using the third option – just runs in a web browser, and so you can use that without any setup.

If you do have Haskell installed, start by creating a directory for this course.

Text editor and terminal

For this setup, open two windows side-by-side:In the video we open the two side-by-side in one terminal using tmux; opening the two applications using a graphical window manager is also fine.

  • On the left, open a text editor.In the video we use vim, though any editor will do.
  • On the right, run ghci.

‘GHC’ is the name of the Haskell compiler, and ‘i’ stands for ‘interactive’.This course will cover everything you need to know about GHCi to start. We also have another course – The interactive compiler – that goes into GHCi in much greater detail. So GHCi is the interactive interface to the Haskell compiler.

Using the GHCi prompt

In GHCi we can do things like…

  • Define variables – we’ll define x to be 3.

    λ> x = 3
  • Evaluate expressionsGHCi is sometimes referred to as a “REPL”, or read–eval–print loop, which describes its ability to evaluate expressions typed at the prompt – although it can do much more than this. – if we ask for the value of x + 2, it tells us that it’s 5.

    λ> x + 2
  • Run actions – let’s say we want to print the string “hello” to the terminal. The putStrLn function does that. (That stands for “put string line”.)

    λ> putStrLn "hello"


Notice that we’ve used two functions so far: the plus sign (+) and the putStrLn function. We didn’t have to import either of these. That’s because these things come from the standard library, a moduleLater in this course we’ll talk a bit more about what modules are and what it means to import them. called Prelude, which is imported by default. If, hypothetically, it weren’t, we could have written

λ> import Prelude

We can write that, but we don’t have to, because this import is already there implicitly.

Saving definitions in a file

What we can’t do in ghci is save the definitions we write. The prompt also not very good for entering large expressions, especially ones that span multiple lines. For that, we’re going to want the text editor.

Create a file called main.hs..hs is always the file extension for Haskell source files. In this file, we can write definitions. For example:

x = 100

y = x + 2

main = putStrLn "hello"

We’ve defined x as 100 this time, added a new variable y defined to be a number that is two greater than x, and our putStrLn "hello" action here is assigned the name “main”.

So we can write definitions in the text editor, but what we can’t do is evaluate the expressions or run the action. For that, we have to go back over to GHCi. Once we save that file, we load it into the REPL. Use the :load command and specify the name of the file we want to load, which is main.hs.

λ> :load main.hs
[1 of 1] Compiling Main    ( main.hs, interpreted )
Ok, one module loaded.

GHCi tells us that it’s now loaded. Now in the REPL we can, for example, look at the values of x and y.

λ> x

λ> y

We can run that main action, and it prints “hello”.

λ> main

Changing and reloading

Make some changes to the main.hs file. Let’s say we now want x to be 200 instead of 100, and have our greeting be more emphatic.

x = 200

y = x + 2

main = putStrLn "hello!!!!!"

Save the file, and reload it into GHCi using the :reload command.

λ> :reload
[1 of 1] Compiling Main    ( main.hs, interpreted )
Ok, one module loaded.

You can also abbreviate that as :r, which does the same thing.

λ> :r
Ok, one module loaded.

Now if we look at x and y again, we see their new values 200 and 202.

λ> x

λ> y

And main is now excited.

λ> main

Error messages

Sometimes we make mistakes. Suppose we misspelled the name of putStrLn. Modify the main.hs file as follows:

x = 200

y = x + 2

main = putStrLtr "hello!!!!!"

And :reload once more. When GHCi tries to load the code with the misspelling, it shows us an error message.

λ> :reload
[1 of 1] Compiling Main    ( main.hs, interpreted )

main.hs:5:8 error:
    • Variable not in scope: putStrLtr :: [Char] -> t
    • Perhaps you meant ‘putStrLn’ (imported from Prelude)

5 | main = putStrLtr "hello!!!!!"
  |        ^^^^^^^^^
Failed, no modules loaded.

Please take some time to read the error message carefully, because it contains a lot of information.

  • main.hs:5 – The error occurred in the file main.hs on line 5.
  • Variable not in scope: putStrLr – There is no such function as putStrLtr.
  • Perhaps you meant ‘putStrLn’ – GHCi guesses correctly that what we really wanted was the function named putStrLn.

The error output also includes an excerpt from the file, with an underline highlighting where we made the mistake. The line numbering to the left of the excerpt also reminds us again that this is line 5.

5 | main = putStrLtr "hello!!!!!"
  |        ^^^^^^^^^

Change putStrLtr back to putStrLn, reload the code, and run main in GHCi to verify that it works correctly again.


If you prefer to use Visual Studio Code, the setup is still very similar. Visual Studio is convenient because it has a side panel with a built-in terminal.

Create a file called main.hs:

x = 100

y = x + 2

main = putStrLn "hello :)"

Open the terminal in the panel on the right. Run ghci in that terminal and :load the source file. For the demonstration as before: query the values of x and y, and run the main action. runs in a web browser and is your quick-start option if you don’t have Haskell installed on your computer yet. It does have some limitations, but it will server just fine for the purposes of this course.

Go to the website, click the “start coding” button, and choose Haskell from the list of language choices. Then click “create repl”. automatically starts us off with a file called main.hs, and it has already opened GHCi on the right.

  • Again, in our source file we can type some definitions.
  • We still have to use the :load command to load that main.hs file into GHCi.
  • Again, we can query the defined values and run the main action. also has a “run” button at the top. When we click on that, it reloads and runs main. If you are working on a program and often testing its main action, you may find this button convenient.

Join Type Classes for courses and projects to get you started and make you an expert in FP with Haskell.