Building Complete Interactive Programs

Introduction: Assembling the Capstone

Welcome to the seventh and final lesson of this course! You have made it to the capstone of our Haskell journey. Over the previous lessons, you learned how to model information using custom types, how to handle missing data and errors safely with Maybe and Either, and how to read user input using the IO system. Now, we are going to combine all of those pieces to build a complete, interactive command-line task manager . Our goal is to create a program that continuously accepts user commands so we can find, list, and add tasks. To keep the command parsing beginner-friendly, this final version will accept single-word titles for the add command, such as add laundry . A command like add write report will not be recognized by this simple parser because it splits input with words and matches exactly two words. To do this, we will use a common and powerful pattern in functional programming : we will separate our program into a pure core that handles data logic and a thin impure IO shell that interacts with the user. Let us start by building the pure core.

Handling Commands: The Pure Core

The brain of our program will be a function called handle . This function does not print anything to the screen or read from the keyboard. It simply takes the current list of tasks and a list of command words from the user and decides what to do. Let us start by defining its signature and a fallback for commands it does not recognize. Haskell handle :: [Task] -> [String] -> (String, [Task]) handle tasks _ = ("Commands: list | add <title> | find <id>", tasks) Notice the return type: (String, [Task]) . When we give handle a command, it returns a tuple containing two things: A message to show the user (String). The list of tasks, which might be updated ([Task]). Because the catch-all pattern (_) simply provides help text, it returns the tasks exactly as it received them. Next, let us add a command to find a task by its ID. You might remember our parseFind function from a previous lesson, which safely searches for a task and returns a formatted string. We can reuse it here! Haskell handle :: [Task] -> [String] -> (String, [Task]) handle tasks ["find", arg] = (parseFind tasks (readMaybe arg), tasks) handle tasks _ = ("Commands: list | add <title> | find <id>", tasks) When the user types something like find 1, the words are split into the list ["find", "1"] . Our new clause catches this pattern. It uses readMaybe to safely turn the "1" into a number, passes it to parseFind to get the output message, and returns the list of tasks unchanged.

Join the 1M+ learners on CodeSignal

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

The Interactive Loop: Threading State

Now that we have a function to process commands, we need a way to continuously ask the user for input. In standard programming languages, you might use a while loop and update a variable. In Haskell, variables cannot change. Instead, we read the user's command, get the new data, and pass it forward by calling our loop function again.

Here is the state-threading idea in one compact flow:

text

tasks -> handle command -> (output, newTasks) -> print output -> loop newTasks

The key point is that we never mutate tasks. We compute newTasks, then pass that newer list into the next recursive call.

Let us start writing our loop function in the IO world. We will check whether the user has closed the program (using isEOF).

Haskell

loop :: [Task] -> IO ()
loop tasks = do
  end <- isEOF
  if end
    then putStrLn "Goodbye."
    else do
      line <- getLine

If the program is not ending, we read the user's typing using getLine. Now, we need to pass this input to our handle function. We will use the words function to split the user's sentence into a list of strings and pass it along with our current tasks.

Haskell

loop :: [Task] -> IO ()
loop tasks = do
  end <- isEOF
  if end
    then putStrLn "Goodbye."
    else do
      line <- getLine
      let (output, newTasks) = handle tasks (words line)

Because handle is pure and returns a tuple, we use let to unpack the (output, newTasks) tuple. This gives us the text to show the user and the next version of our task list.

Finally, we print the output and call loop again, passing the newTasks forward.

Haskell

loop :: [Task] -> IO ()
loop tasks = do
  end <- isEOF
  if end
    then putStrLn "Goodbye."
    else do
      line <- getLine
      let (output, newTasks) = handle tasks (words line)
      putStrLn output
      loop newTasks

To start this continuous cycle, our main function simply calls loop with an initial list of tasks.

Haskell

initialTasks :: [Task]
initialTasks = [Task 1 "Write report" Todo, Task 2 "Review code" Done]

main :: IO ()
main = loop initialTasks

If we run this and type find 1, the program works exactly as expected:

text

find 1
#1 Write report (not done)

Introduction: Assembling the Capstone

Handling Commands: The Pure Core

Join the 1M+ learners on CodeSignal

The Interactive Loop: Threading State

Listing Tasks with Recursive Helpers

Adding Tasks and Growing State

Course Wrap-Up and Final Practice