**Course Title:** Functional Programming with Haskell: From Fundamentals to Advanced Concepts **Section Title:** Input/Output and Working with Side Effects **Topic:** Create a Haskell program that reads from a file, processes the data, and writes the output to another file.(Lab topic) **Objective:** In this lab topic, you will learn how to create a Haskell program that reads from a file, processes the data, and writes the output to another file. You will gain hands-on experience with Haskell's input/output (IO) system and learn how to handle side effects in a functional programming context. **Prerequisites:** * Understanding of Haskell's IO monads (covered in Monads and Functors in Haskell) * Familiarity with Haskell's file input/output functions (covered in Input/Output and Working with Side Effects) * Basic understanding of functional programming concepts and Haskell syntax **Step 1: Reading from a File** To read from a file in Haskell, you can use the `readFile` function from the `Prelude` module. This function takes a file path as a string and returns a `String` containing the file's contents. ```haskell readFile :: FilePath -> IO String ``` Here's an example of how to use `readFile`: ```haskell main :: IO () main = do contents <- readFile "input.txt" putStrLn contents ``` In this example, we define a `main` function that reads the contents of a file named "input.txt" and prints it to the console using `putStrLn`. **Step 2: Processing the Data** Once you've read the file contents into a `String`, you can process the data using Haskell's standard library functions. For example, you can split the string into lines using `lines`: ```haskell lines :: String -> [String] ``` or parse the string into a list of integers using `map read . words`: ```haskell read :: String -> Integer words :: String -> [String] ``` Let's assume you want to process a file containing a list of integers, one per line. You can use the following code: ```haskell main :: IO () main = do contents <- readFile "input.txt" let numbers = map read (lines contents) :: [Int] putStrLn (show numbers) ``` **Step 3: Writing to a File** To write to a file in Haskell, you can use the `writeFile` function from the `Prelude` module. This function takes a file path and a `String` to write to the file. ```haskell writeFile :: FilePath -> String -> IO () ``` Here's an example of how to use `writeFile`: ```haskell main :: IO () main = do let output = "Hello, world!" writeFile "output.txt" output ``` In this example, we define a `main` function that writes the string "Hello, world!" to a file named "output.txt". **Putting it All Together** Now that you've learned how to read from a file, process the data, and write to a file, you can combine these steps into a single program. Let's assume you want to write a program that reads a list of integers from a file, squares each number, and writes the result to another file. ```haskell main :: IO () main = do contents <- readFile "input.txt" let numbers = map read (lines contents) :: [Int] let squaredNumbers = map (^2) numbers writeFile "output.txt" (unlines (map show squaredNumbers)) ``` In this example, we read the contents of "input.txt", parse it into a list of integers, square each number, and write the result to "output.txt". **External Resources:** For more information on Haskell's file input/output functions, see the Haskell documentation: * [File IO](https://hackage.haskell.org/package/base-4.16.1.0/docs/System-IO.html) **Questions or Need Help?** If you have any questions or need help with this lab topic, feel free to leave a comment below. **What's Next:** In the next topic, we'll cover **Understanding Haskell modules and importing libraries**.