In this section, we will learn how to build a simple web server using Haskell. This will involve setting up a basic server, handling HTTP requests, and sending responses. We will use the wai and warp libraries, which are popular choices for web development in Haskell.

Before we start, ensure you have the following:

• Basic understanding of Haskell syntax and functional programming concepts.
• Haskell environment set up on your machine.
• Familiarity with basic I/O operations in Haskell.

1. Create a new Haskell project:

   stack new simple-web-server
   cd simple-web-server
   

2. Add dependencies: Open the package.yaml file and add the following dependencies under the dependencies section:

   dependencies:
   - base >= 4.7 && < 5
   - wai
   - warp
   

3. Install the dependencies:

   stack build
   

1. Create a new Haskell source file: Create a file named src/Main.hs and open it in your text editor.

2. Import necessary modules:

   {-# LANGUAGE OverloadedStrings #-}
   
   module Main where
   
   import Network.Wai (Application, responseLBS)
   import Network.Wai.Handler.Warp (run)
   import Network.HTTP.Types (status200)
   

3. Define the application:

   -- | The application that handles incoming requests
   app :: Application
   app request respond = do
       let response = responseLBS
               status200
               [("Content-Type", "text/plain")]
               "Hello, World!"
       respond(response)
   

4. Run the server:

   -- | Main function to run the server
   main :: IO ()
   main = do
       putStrLn "Starting server on port 8080..."
       run 8080 app
   

5. Build and run the server:

   stack build
   stack exec simple-web-server
   

6. Test the server: Open your web browser and navigate to http://localhost:8080. You should see the message "Hello, World!".

• Imports:

  • Network.Wai provides the core types and functions for building web applications.
  • Network.Wai.Handler.Warp is a fast, lightweight web server for WAI applications.
  • Network.HTTP.Types provides common HTTP types and status codes.

• Application:

  • The app function is our web application. It takes a request and a function to send a response.
  • We create a simple response with status200 (HTTP 200 OK) and a plain text body "Hello, World!".

• Main Function:

  • The main function starts the server on port 8080 and uses our app to handle incoming requests.

Modify the server to respond with a custom message and a different content type.

1. Change the response message to "Welcome to my Haskell web server!".
2. Change the content type to "text/html".

Solution:

Extend the server to handle different routes and respond with different messages.

1. Respond with "Hello, World!" for the root path /.
2. Respond with "About Page" for the path /about.

Solution:

• Port Conflicts: Ensure the port you choose (e.g., 8080) is not already in use by another application.
• Content-Type: Always set the correct Content-Type header to match the response body format.
• Error Handling: Implement proper error handling for more robust applications.

In this section, we learned how to set up a simple web server in Haskell using the wai and warp libraries. We covered the basics of handling HTTP requests and sending responses. We also explored practical exercises to customize responses and handle different routes. This foundational knowledge prepares you for more advanced web development topics in Haskell.