Your First Haskell Program: Hello World

Getting started with Haskell can be exciting and fulfilling, especially when you write your very first program. In this guide, we’ll walk through the process of creating a simple "Hello, World!" program in Haskell. This tutorial will follow a step-by-step approach, ensuring that even if you're a complete beginner, you can follow along effortlessly.

Step 1: Setting Up Your Haskell Environment

Before writing your Haskell program, you must ensure your environment is set up correctly. Here’s how to do it:

Install the Haskell Platform

The easiest way to get started with Haskell is to install the Haskell Platform, which includes the Glasgow Haskell Compiler (GHC), the interactive interpreter (GHCi), and various Haskell libraries.

  1. Download the Haskell Platform from the official website: Haskell Platform

  2. Follow the Installation Instructions specific to your operating system (Windows, macOS, Linux).

  3. Verify Installation: Open a terminal and type the following command to check if GHC is installed:

    ghc --version

    You should see the version number of GHC if it's installed correctly.

Installing an Editor

You'll need a text editor to write your Haskell code. You can use any text editor, but here are a few popular ones that support Haskell syntax highlighting:

  • Visual Studio Code: Install the Haskell extension for enhanced features.
  • Atom: Another great option with packages available for Haskell development.
  • Sublime Text: Lightweight and fast, also with Haskell support.

For this tutorial, we’ll use Visual Studio Code.

Step 2: Writing Your First Haskell Program

Now that your environment is ready, let’s write your very first Haskell program!

Create a New Haskell File

  1. Open your favorite text editor.
  2. Create a new file and name it HelloWorld.hs.
  3. Make sure to save it in a directory where you want to keep your Haskell projects.

Add the Haskell Code

Now, let’s write the code for our "Hello, World!" program. Type the following into your HelloWorld.hs file:

main :: IO ()
main = putStrLn "Hello, World!"

Explanation of the Code:

  • main :: IO (): This line defines the main function. The type signature specifies that main will perform input/output operations (IO) and will not return a value (()).

  • putStrLn "Hello, World!": This expression outputs the string "Hello, World!" to the console. The putStrLn function takes a string as an argument and prints it to the screen followed by a newline.

Save Your File

Make sure to save the file after you’ve written the code. You’re now ready to run your program!

Step 3: Compiling and Running Your Haskell Program

With your code in place, it’s time to compile and run the program to see the result of your hard work.

Compiling the Program

Open your terminal, navigate to the directory where you saved your HelloWorld.hs file, and run the following command:

ghc -o HelloWorld HelloWorld.hs

Here’s what this command does:

  • ghc: Invokes the Glasgow Haskell Compiler.
  • -o HelloWorld: Specifies the output file name for the compiled program (HelloWorld).
  • HelloWorld.hs: The source file you want to compile.

If everything goes correctly, you won’t see any messages in your terminal. The command will create an executable file named HelloWorld in the same directory.

Running the Program

To execute your program, type the following command in the terminal:

./HelloWorld

If you’re on Windows, use:

HelloWorld.exe

You should see the following output in your terminal:

Hello, World!

Congratulations! You've successfully written and executed your first Haskell program!

Step 4: Running the Program in GHCi

GHCi, the interactive shell for Haskell, allows you to run Haskell code without compiling it every time. Here’s how to run your Hello World program in GHCi.

Starting GHCi

Open your terminal and type:

ghci

You should see the GHCi prompt.

Loading Your Haskell File

At the GHCi prompt, load your Haskell file by typing:

:l HelloWorld.hs

If there are no errors, you will see a message like Ok, modules loaded: HelloWorld.

Running the Main Function

To run the main function, type:

main

You should see the output:

Hello, World!

Exiting GHCi

When you’re done, you can exit GHCi by typing:

:q

Step 5: Making Your Code Interactive

Now that you have successfully created a simple program, why not expand on it? You can prompt the user for input and then greet them. Here’s an example of an interactive program:

Update HelloWorld.hs

Modify your HelloWorld.hs file to look like this:

main :: IO ()
main = do
    putStrLn "What is your name?"
    name <- getLine
    putStrLn ("Hello, " ++ name ++ "!")

Explanation of the New Code:

  • do: This keyword is used to sequence IO actions. You can think of it as telling Haskell, "Do these actions one after another."

  • name <- getLine: This line reads a line of input from the user and binds it to the variable name.

  • putStrLn ("Hello, " ++ name ++ "!"): This line greets the user with their name.

Compile and Run Again

Follow the same steps to compile and run your updated program. You’ll now be prompted to enter your name, and the program will greet you personally!

Conclusion

You've now embarked on a journey into the world of Haskell by writing your first program. Whether you're using GHC or GHCi, you've learned how to compile, run code, and even make it interactive. This foundational knowledge will serve you well as you explore Haskell further and tackle more complex programs.

Keep experimenting! Try modifying your program, adding more features, or even diving into other topics like functions, types, or even libraries. Welcome to the world of Haskell programming! Happy coding!