**Course Title:** Functional Programming with Haskell: From Fundamentals to Advanced Concepts **Section Title:** Working with Databases and Web Services in Haskell **Topic:** Create a Haskell program that connects to a database and exposes a RESTful API.(Lab topic) **Objective:** In this lab, you will create a Haskell program that connects to a PostgreSQL database using the HDBC library and exposes a RESTful API using the Servant library. **Prerequisites:** * You have completed the previous topics on Haskell programming, including functional programming concepts, type systems, and database interactions. * You have a PostgreSQL database installed on your local machine or have access to a remote PostgreSQL database. * You have installed the HDBC and Servant libraries using Cabal or Stack. **Step 1: Setting up the HDBC Library** To connect to a PostgreSQL database, you will use the HDBC library. First, install the HDBC library using Cabal or Stack: ```bash cabal install hdbc-postgresql ``` or ```bash stack install hdbc-postgresql ``` **Step 2: Creating a Database Connection** Create a new Haskell file called `Database.hs` and add the following code to connect to a PostgreSQL database: ```haskell module Database where import Database.HDBC import Database.HDBC.PostgreSQL -- Database connection string dbString :: String dbString = "host=localhost dbname=mydb user=myuser password=mypassword" -- Create a database connection createConnection :: IO Connection createConnection = connectPostgreSQL dbString ``` **Step 3: Defining Database Queries** Create a new Haskell file called `Queries.hs` and add the following code to define database queries: ```haskell module Queries where import Database.HDBC -- Retrieve all rows from the "users" table getAllUsers :: IO [[SqlValue]] getAllUsers conn = quickQuery conn "SELECT * FROM users" [] -- Retrieve a user by ID getUserById :: Int -> IO [[SqlValue]] getUserById userId conn = quickQuery conn "SELECT * FROM users WHERE id = ?" [toSql userId] ``` **Step 4: Creating a Servant API** Create a new Haskell file called `Server.hs` and add the following code to create a Servant API: ```haskell module Server where import Servant import Data.Aeson import Database.HDBC type API = "users" :> Get '[JSON] [User] :<|> "users" :> Capture "id" Int :> Get '[JSON] User type User = (Int, String, String) server :: Server API server = serve users API where users = queryUsers :<|> getUser queryUsers :: IO [User] queryUsers = do conn <- createConnection result <- getAllUsers conn closeConnection conn return [ (fromSql id :: Int, fromSql name :: String, fromSql email :: String) | [id, name, email] <- result] getUser :: Int -> IO User getUser userId = do conn <- createConnection result <- getUserById userId conn closeConnection conn return $ \(id, name, email) -> (fromSql id :: Int, fromSql name :: String, fromSql email :: String) ``` **Step 5: Running the API** Create a new Haskell file called `Main.hs` and add the following code to run the API: ```haskell module Main where import Network.HTTP.Client (defaultManager) import Network.HTTP.Client.TLS (tlsManagerSettings) import Server import Servant.Client (Client, client) import Servant.Server (serve) import Data.Aeson (decode) main :: IO () main = do ctx <- tlsManagerSettings result <- client runContext (runManager ctx) server putStrLn result ``` **Testing the API** To test the API, you can use a tool like curl or Postman to send HTTP requests to the API. For example, you can use the following curl command to retrieve a list of all users: ```bash curl http://localhost:3000/users ``` You should see a JSON response containing the list of all users. **Conclusion:** In this lab, you have created a Haskell program that connects to a PostgreSQL database using the HDBC library and exposes a RESTful API using the Servant library. You have defined database queries to retrieve data from the database and created a Servant API to expose these queries as RESTful endpoints. **Practical Takeaway:** When connecting to a database in a Haskell program, use a library such as HDBC to create a database connection and define database queries to retrieve data from the database. When exposing these queries as a RESTful API, use a library such as Servant to define the API endpoints and handle the underlying HTTP requests and responses. **Additional Resources:** * [HDBC Documentation](https://hackage.haskell.org/package/hdbc-2.4.0.2/docs/Database-HDBC.html) * [Servant Documentation](https://hackage.haskell.org/package/servant-0.18.3/docs/Servant-API.html) * [PostgreSQL Documentation](https://www.postgresql.org/docs/) **Leave a comment below if you have any questions or need further clarification on any of the concepts presented in this lab.**