The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Basic I/O

Next ►
►

In this section, we will explore how to perform basic input and output (I/O) operations in Haskell. Haskell, being a purely functional language, handles I/O in a unique way compared to imperative languages. We will cover the following topics:

  1. Introduction to I/O in Haskell
  2. Reading from the console
  3. Writing to the console
  4. Combining I/O actions
  5. Practical examples and exercises

  1. Introduction to I/O in Haskell

In Haskell, I/O operations are handled using the IO type. This type encapsulates any computation that interacts with the outside world, ensuring that the purity of the language is maintained. The IO type can be thought of as a "container" for actions that produce side effects.

Key Concepts:

  • IO Type: Represents a computation that performs I/O.
  • do Notation: A syntactic sugar to sequence I/O actions.

  1. Reading from the Console

To read input from the console, we use the getLine function, which has the type IO String. This function reads a line of input from the standard input (usually the keyboard) and returns it as a string.

Example:

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

Explanation:

  • putStrLn "Enter your name:" prints a prompt to the console.
  • name <- getLine reads a line of input from the user and binds it to the variable name.
  • putStrLn ("Hello, " ++ name ++ "!") prints a greeting message using the input.

  1. Writing to the Console

To write output to the console, we use the putStr and putStrLn functions. The difference between them is that putStrLn appends a newline character at the end of the string, while putStr does not.

Example:

main :: IO ()
main = do
    putStr "Hello, "
    putStrLn "world!"

Explanation:

  • putStr "Hello, " prints "Hello, " without a newline.
  • putStrLn "world!" prints "world!" followed by a newline.

  1. Combining I/O Actions

Haskell allows us to combine multiple I/O actions using the do notation. This notation makes it easy to sequence actions and handle the results of previous actions.

Example:

main :: IO ()
main = do
    putStrLn "Enter the first number:"
    num1 <- getLine
    putStrLn "Enter the second number:"
    num2 <- getLine
    let sum = (read num1 :: Int) + (read num2 :: Int)
    putStrLn ("The sum is: " ++ show sum)

Explanation:

  • The program prompts the user to enter two numbers.
  • It reads the input and converts the strings to integers using read.
  • It calculates the sum and prints the result using show to convert the integer back to a string.

  1. Practical Examples and Exercises

Example: Simple Calculator

Create a simple calculator that reads two numbers and an operator from the user, then performs the corresponding operation.

main :: IO ()
main = do
    putStrLn "Enter the first number:"
    num1 <- getLine
    putStrLn "Enter the operator (+, -, *, /):"
    operator <- getLine
    putStrLn "Enter the second number:"
    num2 <- getLine
    let n1 = read num1 :: Double
    let n2 = read num2 :: Double
    let result = case operator of
                    "+" -> n1 + n2
                    "-" -> n1 - n2
                    "*" -> n1 * n2
                    "/" -> n1 / n2
                    _   -> error "Invalid operator"
    putStrLn ("The result is: " ++ show result)

Exercise: Greeting Program

Write a program that asks the user for their name and age, then prints a greeting message that includes their name and age.

Solution:

main :: IO ()
main = do
    putStrLn "Enter your name:"
    name <- getLine
    putStrLn "Enter your age:"
    age <- getLine
    putStrLn ("Hello, " ++ name ++ "! You are " ++ age ++ " years old.")

Common Mistakes:

  • Forgetting to use do notation: Ensure that you use do notation when sequencing multiple I/O actions.
  • Incorrect type conversion: Use read and show correctly to convert between strings and other types.

Conclusion

In this section, we learned how to perform basic I/O operations in Haskell. We covered reading from the console, writing to the console, and combining I/O actions using the do notation. We also provided practical examples and exercises to reinforce the concepts. In the next section, we will explore file handling in Haskell, which will allow us to read from and write to files.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved