How to use the command ghci (with examples)

The ghci command is the interactive environment for the Glasgow Haskell Compiler (GHC). It provides a Read-Evaluate-Print Loop (REPL) that allows users to interactively write and execute Haskell code. This article will illustrate several use cases of the ghci command with examples.

Use case 1: Start a REPL (interactive shell)

Code:

ghci

Motivation: The ghci command is primarily used to start a REPL, which provides an interactive environment for testing and debugging Haskell code. Using a REPL allows for rapid iterations and easy experimentation, which enhances the development process.

Explanation: This use case simply entails running the ghci command without any additional arguments. This will start the REPL, where you can enter Haskell code line by line, and see the results immediately.

Example output:

GHCi, version 8.6.5: http://www.haskell.org/ghc/  :? for help
Prelude>

The output shows that the GHCi REPL has started successfully, and the prompt Prelude> indicates that you can now enter Haskell expressions and evaluate them.

Use case 2: Start a REPL and load the specified Haskell source file

Code:

ghci source_file.hs

Motivation: When working on a large Haskell project, it is often necessary to load specific source files into the REPL to test and debug individual components. This use case allows you to load the specified Haskell source file directly into the REPL environment.

Explanation: By providing the filename of the Haskell source file as an argument (source_file.hs in the example), you can directly load the file into the GHCi REPL. This makes all the definitions and functions defined in that file available for testing and experimentation within the REPL session.

Example output:

GHCi, version 8.6.5: http://www.haskell.org/ghc/  :? for help
[1 of 1] Compiling Main             ( source_file.hs, interpreted )
Ok, one module loaded.
*Main>

The output indicates that the specified Haskell source file (source_file.hs) was successfully loaded into the GHCi REPL. The prompt *Main> indicates that the module defined in the source file is now available for use within the REPL session.

Use case 3: Start a REPL and enable a language option

Code:

ghci -Xlanguage_option

Motivation: Haskell provides a variety of language options that enable additional language features or change the behavior of certain constructs. Enabling specific language options using ghci allows you to use those language features and experiment with different behaviors during the REPL session.

Explanation: To enable a language option, you need to use the -X flag followed by the name of the desired option (language_option in the example). This will enable the specified language option within the GHCi REPL session, allowing you to use the associated features.

Example output:

GHCi, version 8.6.5: http://www.haskell.org/ghc/  :? for help
Prelude> :set -XDataKinds
Prelude> :set -XTypeApplications

The output demonstrates enabling two different language options (DataKinds and TypeApplications) within the GHCi REPL. Once enabled, you can use the features provided by these language options in your Haskell expressions.

Use case 4: Start a REPL and enable some level of compiler warnings

Code:

ghci -Wwarning_level

Motivation: Compiler warnings provide valuable feedback on potential errors or issues in your code. By enabling compiler warnings using ghci, you can catch potential problems early and ensure the code is of higher quality.

Explanation: To enable compiler warnings, you need to use the -W flag followed by the desired warning level (warning_level in the example). The available warning levels in GHC are none, normal, warn, deprecations, lite, and compat - each offering a different level of reporting.

Example output:

GHCi, version 8.6.5: http://www.haskell.org/ghc/  :? for help
Prelude> :set -Wcompat

The output shows enabling the compat level of compiler warnings in the GHCi REPL. After setting this warning level, GHC will provide additional warnings about code compatibility issues, ensuring that your code adheres to more restricted language rules.

Use case 5: Start a REPL with a colon-separated list of directories for finding source files

Code:

ghci -ipath/to/directory1:path/to/directory2

Motivation: When working on a larger Haskell project, it’s common to have source files distributed across multiple directories. Specifying directories using ghci allows the REPL to locate and load the required files without explicitly specifying their paths every time.

Explanation: The -i flag, followed by a colon-separated list of directories (path/to/directory1:path/to/directory2 in the example), instructs GHCi to search for source files in the provided directories when loading modules. This eliminates the need to provide the full path for each source file in the REPL session.

Example output:

GHCi, version 8.6.5: http://www.haskell.org/ghc/  :? for help
Prelude> :set -ipath/to/src:path/to/lib

The output shows adding two directories (path/to/src and path/to/lib) to the search path of GHCi. From now on, GHCi will look for source files in these directories when loading modules.

Conclusion:

The ghci command is a powerful tool for Haskell development. It provides an interactive environment where you can write and test Haskell code, experiment with different language options, enable compiler warnings, and load source files for testing. By utilizing the various use cases of ghci explained in this article, you can enhance your Haskell development workflow and write more robust and efficient code.