Lesson 1: Hello, World!

Installing Haskell and supporting tools

Disclaimer

In this series I am using the following software packages on a Debian based GNU/Linux distribution:

• GHC 6.6.1


• Emacs 21


• Haskell Mode 2.3 (for Emacs)

In some of the initial lessons I assume you are as well, but if you are not, you should still be able to follow along. Once we really get into the language, it should not matter much, until we get to advanced lessons that use features only found in recent versions of GHC.

Installing

First run:

 $ sudo apt-get install emacs21 ghc6

Then check that haskell-mode 2.3 or higher is available:

 $ sudo apt-cache policy haskell-mode
haskell-mode:
  Installed: 2.3-0cnr1
  Candidate: 2.3-0cnr1
  Version table:
 *** 2.3-0cnr1 0
        500 http://apt2.freespire.org skipjack-feisty/main Packages
        100 /var/lib/dpkg/status

If it is, run the following command and skip to the next section:

 $ sudo apt-get install haskell-mode

If the version of haskell-mode is less than 2.3, then temporarily add this line to your /etc/apt/sources.list:

deb http://apt2.freespire.org/CNRUbuntu skipjack-feisty main

and run:

 $ sudo apt-get update 
 $ sudo apt-get install haskell-mode

and, finally, remove the skipjack-feisty line from your sources.list.

Configure Emacs and Haskell mode

Add the following lines to your ~/.emacs file and restart emacs:

;; Font Locking, Programming Modes, and Compilation settings
;;

(global-font-lock-mode 1)
;; maximum colors
(setq font-lock-maximum-decoration t)

;; extra key bindings
(global-set-key "\M-C" 'compile)
(global-set-key "\C-^" 'next-error)
(global-set-key "\C-\M-g" 'goto-line)

;; use spaces instead of tabs
(setq-default indent-tabs-mode nil)

;; haskell mode configuration
(setq auto-mode-alist
      (append auto-mode-alist
              '(("\\.[hg]s$"  . haskell-mode)
                ("\\.hic?$"     . haskell-mode)
                ("\\.hsc$"     . haskell-mode)
  ("\\.chs$"    . haskell-mode)
                ("\\.l[hg]s$" . literate-haskell-mode))))
(autoload 'haskell-mode "haskell-mode"
   "Major mode for editing Haskell scripts." t)
(autoload 'literate-haskell-mode "haskell-mode"
   "Major mode for editing literate Haskell scripts." t)

;adding the following lines according to which modules you want to use:
(require 'inf-haskell)

(add-hook 'haskell-mode-hook 'turn-on-font-lock)
;(add-hook 'haskell-mode-hook 'turn-off-haskell-decl-scan)
;(add-hook 'haskell-mode-hook 'turn-off-haskell-doc-mode)
(add-hook 'haskell-mode-hook 'turn-on-haskell-indent)
;(add-hook 'haskell-mode-hook 'turn-on-haskell-simple-indent)
;(add-hook 'haskell-mode-hook 'turn-on-haskell-hugs)
(add-hook 'haskell-mode-hook 'turn-on-haskell-ghci)
(add-hook 'haskell-mode-hook 
   (function
    (lambda ()
      (setq haskell-program-name "ghci")
      (setq haskell-ghci-program-name "ghci6"))))

Hello, World

Run emacs HelloWorld.hs, and enter the following program:

module Main where

main = putStrLn "Hello, World!"

To save press Control-x followed by Control-s. In emacs-speak this is written as C-x C-s.

Loading the code into GHC Interactive

Now we can load the code into the GHC intepreter by pressing C-c C-l.
This should open another buffer in emacs that looks something like this:

   ___         ___ _
  / _ \ /\  /\/ __(_)
 / /_\// /_/ / /  | |      GHC Interactive, version 6.6.1, for Haskell 98.
/ /_\\/ __  / /___| |      http://www.haskell.org/ghc/
\____/\/ /_/\____/|_|      Type :? for help.

Loading package base ... linking ... done.
Prelude> :load "/tmp/HelloWorld.hs"
[1 of 1] Compiling Main             ( /tmp/HelloWorld.hs, interpreted )
Ok, modules loaded: Main.
*Main> 

To switch between the code and ghci buffers press C-x o, or use the mouse and click inside the buffer you want active.

To run the main function, just type main and hit enter at the *Main> prompt:

*Main> main
Hello, World!
*Main>

Compiling the Code

Switch back to the HelloWorld.hs buffer and enter M-C. The M stands for Meta, which is usually the key labelled Alt, and the C is uppercase. So you will need to press Alt-Shift-c. At the bottom of the emacs window it should now say:

Compile command: make -k 

Change it to

Compile command: ghc --make -O2 HelloWorld.hs -o helloWorld

You should now have a *compilation* buffer that looks like

cd /tmp/
ghc --make -O2 HelloWorld.hs -o helloWorld
[1 of 1] Compiling Main             ( HelloWorld.hs, HelloWorld.o )
Linking helloWorld ...

Compilation finished at Thu Sep  6 12:33:33

Now open a shell, and run the executable:

lain:/tmp $ ./helloWorld 
Hello, World!
lain:/tmp $ 

The parts of the command-line are pretty straight forward:

ghc

The name of the compiler

--make

This tells the compiler that we want to compile a module and all of its dependencies, and produce an executable that we can run.

-O2

This tells the compiler that we want to enable level 2 optimizations (the highest level available). This should result in an executable that runs faster.

HelloWorld.hs

This is the name of the file that contains the main function.

-o helloWorld

This tells the compiler that the executable should be named helloWorld. If you do not specify a name, it will probably default to a.out

Parts of the Program

The program is pretty short, but let's go over the details anyway.

module Main where

This tells the compiler that this file contains the Main module.
When your program is run, it always starts at the main function in the module Main.

main = putStrLn "Hello, World"

This defines a function named main that prints Hello, World followed by a carriage return to stdout. putStrLn is a function, and "Hello, World" is a String. To call a function with an argument, we simply put some whitespace after the function name followed by the argument.

Cool Stuff We Learned

This lesson was a bit long, because we had to install stuff, but we learned some cool stuff:

1. Haskell code can be compiled to an executable, or run interactively


2. Haskell syntax is very clean. We do not need lots of characters like {}(); to get stuff done


3. We are not required to declare the types of our functions anywhere