Error in user YAML: (<unknown>): did not find expected ',' or ']' while parsing a flow sequence at line 3 column 1

---

# Writing Simple

[![Haskell](https://www.haskell.org/static/img/haskell-logo.svg)](https://haskell.org)

---

Writing Simple Haskell

This is a follow-up to Reading Simple Haskell
Markdown format available here.

What we're going to do

We're going to build a cli todo app.
To get the most out of this, follow along using a haskell toolchain or repl.it.

TODO - Requirements

We want to be able to:

Add a new todo item
Display all items
Mark an item as done

But first, let's greet the user.

Hello

-- Hello.hs
module Main where

main :: IO ()
main = putStrLn "Hello user!"

$ runghc Hello.hs
Hello user!

Hello

module Main where

main :: IO ()
main = putStrLn "Hello user!"

:: means "type of"
= means equality (the two sides are interchangeable).
The type of putStrLn is String -> IO ()
The type of main is IO ().

Hello

module Main where

main :: IO ()
main = putStrLn "Hello user!"

The type IO a means This is a description of a subroutine which when run, may perform IO actions and in the end will return a value of type a
main is the name of the entry point of the program.
The Haskell runtime will look for main and will run it.

What is your name?

module Main where

main :: IO ()
main = do
  putStrLn "Hello! What is your name?"
  name <- getLine
  let out = "Nice to meet you, " ++ name ++ "!"
  putStrLn out

$ runghc Hello.hs
"Hello! What is your name?"
suppi
"Nice to meet you, suppi!

What is your name?

module Main where

main :: IO ()
main = do
  putStrLn "Hello! What is your name?"
  name <- getLine
  let out = "Nice to meet you, " ++ name ++ "!"
  putStrLn out

Haskell is indentation sensitive
Code which is part of some expression should be indented further in than the beginning of that expression

What is your name?

module Main where

main :: IO ()
main = do
  putStrLn "Hello! What is your name?"
  name <- getLine
  let out = "Nice to meet you, " ++ name ++ "!"
  putStrLn out

do is a special syntax that lets us sequence IO actions
the type of getLine is IO String
IO String means This is a description of a subroutine which when run, may perform IO operations and in the end will return a value of type String
getLine produces a String by taking a line from the standard input

What is your name?

module Main where

main :: IO ()
main = do
  putStrLn "Hello! What is your name?"
  name <- getLine
  let out = "Nice to meet you, " ++ name ++ "!"
  putStrLn out

The type of getLine is IO String
The type of name is String
<- is special syntax that can only appear in do notation.
<- means run the subroutine and bind the value it produces to the name on the left side of <-
let <name> = <expr> means that the <name> is interchangeable with <expr> for the rest of the do block
In do notation, let does not need the accompanying in

Common Error #1

module Main where

main :: IO ()
main = do
  putStrLn "Hello! What is your name?"
  let out = "Nice to meet you, " ++ getLine ++ "!"
  putStrLn out

Hello.hs:6:37: error:
    • Couldn't match expected type ‘[Char]’
                  with actual type ‘IO String’
    • In the first argument of ‘(++)’, namely ‘getLine’
      In the second argument of ‘(++)’, namely ‘getLine ++ "!"’
      In the expression: "Nice to meet you, " ++ getLine ++ "!"
  |
6 |   let out = "Nice to meet you, " ++ getLine ++ "!"
  |                                     ^^^^^^^

Common Error #1 - Using `IO String` in place of `String`

Note: String is defined as type String = [Char]
Haskell says it can't match the types String which was expected, with IO String which is the type of getLine
IO a and a are different types

Common Error #2

module Main where

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

Common Error #2

Hello.hs:7:3: error:
    • Couldn't match expected type ‘[Char]’ with actual type ‘IO ()’
    • In the first argument of ‘(++)’, namely
        ‘putStrLn "Nice to meet you, "’
      In a stmt of a 'do' block:
        putStrLn "Nice to meet you, " ++ name ++ "!"
      In the expression:
        do putStrLn "Hello! What is your name?"
           name <- getLine
           putStrLn "Nice to meet you, " ++ name ++ "!"
  |
7 |   putStrLn "Nice to meet you, " ++ name ++ "!"
  |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Common Error #2 - Function application precedes operator application

Parenthesis are needed around the expression string

putStrLn ("Nice to meet you, " ++ name ++ "!")

TODO

We want to be able to:

Add a new todo item
Display all items
Mark an item as done

How should we

Model the data?
Store the items?

TODO

We can store the items in a linked list.

type Item = String
type Items = [Item]

TODO

We can save the items in a linked list.

type Item = String
type Items = [Item]

How can we refer to an item?

TODO

We can save the items in a linked list.

type Item = String
type Items = [Item]

How can we refer to an item?

By its index in the list

TODO

We can save the items in a linked list.

type Item = String
type Items = [Item]

How can we refer to an item?

By its index in the list

What will the operations we want to do look like?

TODO - Items as a linked list

Add a new todo item -> Add an item to the start of the list
Display all items -> Reverse and print with indices
Mark an item as done -> Remove an item by its reverse-index

How can we represent these actions?

TODO - Actions as functions

-- Returns a new list of Items with the new item in it
addItem :: Item -> Items -> Items

-- Returns a string representation of the items
displayItems :: Items -> String

-- Returns a new list of items or an error message if the index is out of bounds
removeItem :: Int -> Items -> Either String Items

We use Either to mark a possible failure

TODO - addItem

-- Returns a new list of Items with the new item in it
addItem :: Item -> Items -> Items
addItem item items = item : items

TODO - displayItems

-- Returns a string representation of the items
displayItems :: Items -> String
displayItems items =
  let
    displayItem index item = show index ++ " - " ++ item
    reversedList = reverse items
    displayedItemsList = zipWith displayItem [1..] reversedList
  in
    unlines displayedItemsList

Use hoogle to search for zipWith, reverse, and unlines to find more about them
Haskell only evaluates values when it needs to (for example, when they need to be evaluated in order to print something to the user).
It lets us write functions that work on infinite lists such as [1..] and only evaluate what it needs to evaluate.
You can read more about evaluation in Haskell in this guide

TODO - User Interaction

Let's skip removeItem for now and add user interaction

-- Takes a list of items
-- Interact with the user
-- Return an updated list of items
interactWithUser :: Items -> IO Items

TODO - User Interaction

Let's start by reading a line, treat it as an item, add it to the list, and display the new items

interactWithUser :: Items -> IO Items
interactWithUser items = do
  putStrLn "Enter an item to add to your todo list:"
  item <- getLine
  let newItems = addItem item items
  putStrLn "Item added.\n"
  putStrLn "The List of items is:"
  putStrLn (displayItems newItems)
  pure newItems

The last line of the do notation is the result of the computation
In this case, it needs to be a value of the type IO Items
But newItems has the type Items
So we use pure which has the type a -> IO a
pure creates a subroutine that produces an a without doing any IO

Back to main

main :: IO ()
main = do
  putStrLn "TODO app"
  let initialList = []
  interactWithUser initialList
  putStrLn "Thanks for using this app."

We can now try and run this program.

Execution

$ runghc Todo.hs
TODO app
Enter an item to add to your todo list:
Make a better app
Item added.

The List of items is:
1 - Make a better app

Thanks for using this app.

Iteration and State

We want to let the user add more than one item to their todo list
We want to remember the changes to the list

To do this in Haskell, we use recursion.

Iteration and State

Instead of returning the todo list, we feed it back to interactWithUser

interactWithUser :: Items -> IO ()
interactWithUser items = do
  putStrLn "Enter an item to add to your todo list:"
  item <- getLine
  let newItems = addItem item items
  putStrLn "Item added.\n"
  putStrLn "The List of items is:"
  putStrLn (displayItems newItems)
  interactWithUser newItems

Iteration and State

TODO app
Enter an item to add to your todo list:
Make
Item added.

The List of items is:
1 - Make

Enter an item to add to your todo list:
This
Item added.

The List of items is:
1 - Make
2 - This

Enter an item to add to your todo list:
Stop
Item added.

The List of items is:
1 - Make
2 - This
3 - Stop

Enter an item to add to your todo list:
^C

Iteration and State

This program will run forever
We can stop it using Ctrl-C, but that's not very nice
Let's make it possible for the user to use different commands

User Commands - Representation

data Command
  = Quit
  | DisplayItems
  | AddItem String

We create a new ADT to model the possible user commands

User Commands - Parsing

And parse a user command to our data type
This may fail

parseCommand :: String -> Either String Command
parseCommand line = case words line of
  ["quit"] -> Right Quit
  ["items"] -> Right DisplayItems
  "add" : "-" : item -> Right (AddItem (unwords item))
  _ -> Left "Unknown command."

User Commands - Change iteraction

We change interactWithUser to accomodate for our new functionality

interactWithUser :: Items -> IO ()
interactWithUser items = do
  putStrLn "Commands: quit, items, add - <item to add>"
  line <- getLine
  case parseCommand line of
    Right DisplayItems -> do
      putStrLn "The List of items is:"
      putStrLn (displayItems items)
      interactWithUser items

    Right (AddItem item) -> do
      let newItems = addItem item items
      putStrLn "Item added."
      interactWithUser newItems

    Right Quit -> do
      putStrLn "Bye!"
      pure ()

    Left errMsg -> do
      putStrLn ("Error: " ++ errMsg)
      interactWithUser items

TODO - interact

TODO app
Commands: quit, items, add - <item to add>
add - Add a remove item command
Item added.
Commands: quit, items, add - <item to add>
add - Maybe also display the list of commands only once    
Item added.
Commands: quit, items, add - <item to add>
items
The List of items is:
1 - Add a remove item command
2 - Maybe also display the list of commands only once

Commands: quit, items, add - <item to add>
quit
Bye!
Thanks for using this app.

Let's add a help command

data Command
  ...
  | Help

parseCommand :: String -> Either String Command
parseCommand line = case words line of
  ...
  ["help"] -> Right Help
  _ -> Left "Unknown command."

interactWithUser :: Items -> IO ()
interactWithUser items = do
  line <- getLine
  case parseCommand line of
    Right Help -> do
      putStrLn "Commands: help, quit, items, add - <item to add>"
      interactWithUser items
    ...

The pattern _ serves as a "catch all" so we need to add the pattern for ["help"] before it.

TODO - removeItem

-- Returns a new list of items or an error message if the index is out of bounds
removeItem :: Int -> Items -> Either String Items
removeItem reverseIndex allItems =
    impl (length allItems - reverseIndex) allItems
  where
    impl index items =
      case (index, items) of
        (0, item : rest) ->
          Right rest
        (n, []) ->
          Left "Index out of bounds."
        (n, item : rest) ->
          case impl (n - 1) rest of
            Right newItems ->
              Right (item : newItems)
            Left errMsg ->
              Left errMsg

TODO - add commands for marking an Item as done

data Command
  ...
  | Done Int

parseCommand :: String -> Either String Command
parseCommand line = case words line of
  ...
  ["done", idxStr] ->
    if all (\c -> elem c "0123456789") idxStr
      then Right (Done (read idxStr))
      else Left "Invalid index."
  _ -> Left "Unknown command."

interactWithUser :: Items -> IO ()
interactWithUser items = do
  line <- getLine
  case parseCommand line of
    Right Help -> do
      putStrLn "Commands: help, quit, items, add - <item to add>, done <item index>"
      interactWithUser items
    Right (Done index) -> do
      let result = removeItem index items
      case result of
        Left errMsg -> do
          putStrLn ("Error: " ++ errMsg)
          interactWithUser items
        Right newItems -> do
          putStrLn "Item done."
          interactWithUser newItems

    ...

TODO - Done

TODO app
help
Commands: help, quit, items, add - <item to add>, done <item index>
add - Greet user
Item added.
add - Model data and user interaction
Item added.
add - Implement data modification
Item added.
add - Implement state and iteration using recursion
Item added.
add - Parse user input
Item added.
add - Interact with the user
Item added.
items
The List of items is:
1 - Greet user
2 - Model data and user interaction
3 - Implement data modification
4 - Implement state and iteration using recursion
5 - Parse user input
6 - Interact with the user

done 1
Item done.
items 
The List of items is:
1 - Model data and user interaction
2 - Implement data modification
3 - Implement state and iteration using recursion
4 - Parse user input
5 - Interact with the user

done 1
Item done.
done 1
Item done.
done 1
Item done.
items
The List of items is:
1 - Parse user input
2 - Interact with the user

done 1
Item done.
done 1
Item done.
items
The List of items is:

quit
Bye!
Thanks for using this app.

TODO - Done

The final app's source code can be viewed here.

This code is still a bit messy. Can we do better?

Yes!

Haskell provides us with all kinds of features to simplify the code and reduce code duplication!
But this is a story for another time.

Curious? Want to learn more?

Install a Haskell compiler and environment
Minimal Haskell IDE based on Emacs
Haskell Study Plan

Files

writing_simple_haskell.md

Latest commit

History

writing_simple_haskell.md

File metadata and controls

Writing Simple Haskell

What we're going to do

TODO - Requirements

Hello

Hello

Hello

What is your name?

What is your name?

What is your name?

What is your name?

Common Error #1

Common Error #1 - Using IO String in place of String

Common Error #2

Common Error #2

Common Error #2 - Function application precedes operator application

TODO

TODO

TODO

TODO

TODO

TODO - Items as a linked list

TODO - Actions as functions

TODO - addItem

TODO - displayItems

TODO - User Interaction

TODO - User Interaction

Back to main

Execution

Iteration and State

Iteration and State

Iteration and State

Iteration and State

User Commands - Representation

User Commands - Parsing

User Commands - Change iteraction

TODO - interact

Let's add a help command

TODO - removeItem

TODO - add commands for marking an Item as done

TODO - Done

TODO - Done

This code is still a bit messy. Can we do better?

Yes!

Curious? Want to learn more?

Common Error #1 - Using `IO String` in place of `String`