Building Interactive Programs | CodeSignal Learn

Building Interactive Programs | CodeSignal Learn

Introduction to Interactive Haskell

Welcome back! In our previous lessons, we built a solid foundation of pure functions for our task manager . We created custom data types, modeled missing data with Maybe, and handled errors with Either . These pure functions, like our lookupById function, safely calculate results based on the data we feed them. However, pure functions just sit there quietly. They calculate answers, but they do not actively communicate with the user. To make a real, usable application, we need to interact with the user. We need to wait for them to type a command, read what they typed, and print a response to the screen. In Haskell, we do this using IO (Input/Output). IO is how Haskell safely interacts with the outside world while keeping the rest of our logic pure and predictable. In this lesson, we are going to build an interactive shell that wraps around the pure task manager logic you already wrote.

Parsing Input: words and readMaybe

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Sequencing Actions with do Notation

Now that we know how to respond to text, we need to actually read the text from the keyboard. We do this inside a special function called main . The main function is the entry point of a Haskell program, and it has the type IO () . The () means it performs an action but does not return specific data to the program when it finishes. To perform multiple actions in a specific order, we use the do notation keyword. Think of do notation as a way to write a step-by-step recipe, much like you would in other programming languages. Let's write a simple main function that reads one line from the user and prints a response. Haskell main :: IO () main = do line <- getLine putStrLn (respond tasks (words line)) Let's break down what happens in this do block: getLine is an IO action that pauses the program and waits for the user to type a line of text and press Enter. The <- symbol (a left-pointing arrow) is very important. It reaches into the IO action, grabs the raw string the user typed, and binds it to the name line . Finally, we use putStrLn (put string and move to a new line) to print text to the screen. Inside the parentheses, we pass line to words and pass the result to our pure respond function. If you run this and type find 1, the program will print the description of task 1 and then immediately close.

Looping and Ending with isEOF

Real command-line tools do not close after a single command. They run in a loop, asking for input over and over until you tell them to stop or until the input stream ends. To check if the input is finished, we can use isEOF (End of File) from the System.IO module. This is an IO Bool action that checks if there is any more text left to read. Let's add isEOF to our main function to check if we should stop. We will also add an if/then/else block inside our do notation to make a decision. Haskell import System.IO (isEOF) main :: IO () main = do end <- isEOF if end then putStrLn "Goodbye." else do line <- getLine putStrLn (respond tasks (words line)) Notice that we use <- again. isEOF performs an IO check, and end <- isEOF pulls out a simple True or False . If it is True, we print "Goodbye." But wait, this still only runs once! How do we make it loop? In Haskell, we do this using recursion . Inside the else block, after we print our response, we simply call main again. Haskell import System.IO (isEOF) main :: IO () main = do end <- isEOF if end then putStrLn "Goodbye." else do line <- getLine putStrLn (respond tasks (words line)) main Now the program behaves perfectly. It checks if the input is done. If not, it reads a line, processes it, prints the result, and loops back to the start. If you feed this program the command find 1, it prints the task. If you type find abc, it politely says "Please type a whole number." . If you type hello, it prints "Commands: find <id>" . Because of isEOF, when the user finally closes the input stream, the program safely prints "Goodbye." and ends without crashing.