**Course Title:** Functional Programming with Haskell: From Fundamentals to Advanced Concepts **Section Title:** Advanced Topics: Applicatives, Foldables, Traversables **Topic:** Implement programs that make use of applicatives, foldables, and traversables to solve complex data manipulation problems.(Lab topic) **Introduction** In this lab, we will put into practice the concepts of applicatives, foldables, and traversables to solve complex data manipulation problems. We will explore how to use these abstract concepts to process and transform data in a concise and composable way. **Problem 1: Processing Nested Data Structures** Given a list of tuples, where each tuple contains a string and a list of integers, write a program to extract the sum of all the integers in the nested lists. ```haskell data NestedData = NestedData String [Int] data NestedDataList = [NestedData] exampleData :: NestedDataList exampleData = [NestedData "A" [1, 2, 3], NestedData "B" [4, 5, 6]] ``` To solve this problem, we can use the `Traversable` instance for lists to traverse the nested lists and extract the sum of integers. ```haskell import Data.Traversable sumIntegers :: NestedDataList -> Int sumIntegers xs = sum $ concatMap snd xs sumIntegersAsync :: NestedDataList -> IO Int sumIntegersAsync xs = do results <- traverse (\(NestedData _ ys) -> pure $ sum ys) xs pure $ sum results ``` **Problem 2: Validating User Input** Given a list of user input records, where each record contains a name, email, and age, write a program to validate the input data using applicatives. ```haskell data UserInput = UserInput String String Int data ValidationError = InvalidEmail | InvalidAge validateEmail :: String -> Maybe ValidationError validateEmail email | email =~ /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/ = Nothing | otherwise = Just InvalidEmail validateAge :: Int -> Maybe ValidationError validateAge age | age >= 18 = Nothing | otherwise = Just InvalidAge validateUserInput :: UserInput -> [ValidationError] validateUserInput (UserInput name email age) = catMaybes [validateEmail email, validateAge age] ``` To solve this problem, we can use the `Applicative` instance for `Maybe` to sequence the validation steps and collect errors. ```haskell import Control.Applicative validateUserInputAsync :: UserInput -> IO [ValidationError] validateUserInputAsync (UserInput name email age) = pure $ (<*>) (validateEmail email) (validateAge age) ``` **Problem 3: Processing Large Data Sets** Given a large data set of records, where each record contains a name, age, and salary, write a program to process the data in parallel using foldables. ```haskell data Employee = Employee String Int Int data EmployeeList = [Employee] exampleData :: EmployeeList exampleData = [Employee "John" 30 50000, Employee "Alice" 25 60000] ``` To solve this problem, we can use the `Foldable` instance for lists to process the data in parallel and calculate the sum of salaries. ```haskell import Data.Foldable sumSalaries :: EmployeeList -> Int sumSalaries xs = foldl' (+) 0 $ map (\(Employee _ _ salary) -> salary) xs sumSalariesAsync :: EmployeeList -> IO Int sumSalariesAsync xs = foldlM' (\acc (Employee _ _ salary) -> pure $ acc + salary) 0 xs ``` **Conclusion** In this lab, we have explored how to use applicatives, foldables, and traversables to solve complex data manipulation problems. We have seen how to use these abstract concepts to process and transform data in a concise and composable way. By applying these concepts to real-world problems, we can write more efficient and scalable software systems. **Reference Materials** * [Applicative Functors](https://en.wikibooks.org/wiki/Haskell/Applicative_Functors) * [Foldable](https://hackage.haskell.org/package/base-4.16.0.0/docs/Data-Foldable.html) * [Traversable](https://hackage.haskell.org/package/base-4.16.0.0/docs/Data-Traversable.html) **Leave a Comment/Ask for Help** If you have any questions or need help with any of the problems, please leave a comment below. We will be happy to assist you. **Next Topic** In the next topic, we will explore how to use Haskell database libraries to interact with databases and web services. We will cover the basics of HDBC and Persistent, and see how to use them to build a simple web application.