**Course Title:** Functional Programming with Haskell: From Fundamentals to Advanced Concepts **Section Title:** Web Development in Haskell **Topic:** Building a web application with Yesod or Servant. In this topic, we will explore the process of building a web application using Yesod or Servant, two popular Haskell web frameworks. We'll discuss the pros and cons of each framework, dive into their specific features, and create a simple web application with each framework. ### Choosing a Framework Haskell has several web frameworks, but we will focus on Yesod and Servant. Yesod is a more comprehensive framework that provides a robust set of features, including routing, templating, and database integration. Servant, on the other hand, is a more lightweight framework that provides a minimalistic approach to building web applications. **Yesod** Yesod is a mature framework that has been around since 2010. It's known for its strong focus on type safety and its extensive set of features, including: * Routing: Yesod provides a robust routing system that supports complex routes and automatic generation of URLs. * Templating: Yesod has built-in support for various templating languages, including Hamlet, Heist, and Lucius. * Database Integration: Yesod provides an extensive set of database integration libraries, including support for PostgreSQL, SQLite, and MongoDB. Here's an example of a simple Yesod application: ```haskell #!/usr/bin/env stack -- stack --resolver lts-19.28 script --package yesod --package yesod-static {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} import Control.Monad (replicateM, replicateM_) import Data.Text (Text) import Yesod import Yesod.Static data App = App { getStatic :: Static } mkYesod "App" [parseRoutes| / HomeR GET |] instance Yesod App instance RenderMessage App FormMessage where renderMessage _ _ = defaultFormMessage getHomeR :: Handler Html getHomeR = do now <- liftIO getCurrentTime defaultLayout [whamlet|<h1>Welcome to my Yesod application! Current time is #{now}|] main :: IO () main = wrapMain $ warpEnv $ App $ static "static" ``` You can run the above application by saving it to a file called `yesod-app.hs` and then running `stack yesod-app.hs`. Open a web browser and navigate to `localhost:3000` to see the application in action. **Servant** Servant is a more lightweight framework that's designed for building RESTful APIs. It's known for its strong focus on type safety and its extensive set of features, including: * Routing: Servant provides a robust routing system that supports complex routes and automatic generation of URLs. * API Documentation: Servant provides built-in support for generating API documentation. Here's an example of a simple Servant application: ```haskell #!/usr/bin/env stack -- stack script --package servant-server --package servant-client import Data.ByteString.Lazy.Char8 as BL import Data.Text import Network.HTTP.Client (newManager) import Network.HTTP.Client.TLS (tlsManagerSettings) import Network.Wai.Handler.Warp (run) import Servant data User = User { userId :: Int, userName :: Text } deriving Show instance ToJSON User where toJSON user = object [ "id" .= userId user , "name" .= userName user ] type API = "user" :> Capture "id" Int :> Get '[JSON] User userApi :: Proxy API userApi = Proxy server :: Server API server = getUser where getUser :: Int -> Handler User getUser id = return $ User id "John Doe" app :: Application app = serve userApi server main :: IO () main = run 3000 app ``` You can run the above application by saving it to a file called `servant-app.hs` and then running `stack servant-app.hs`. Open a web browser and navigate to `localhost:3000/user/1` to see the application in action. ### Choosing the Right Tool Both Yesod and Servant are powerful frameworks, but they have different design goals and philosophies. Yesod is more comprehensive and focuses on providing a robust set of features for building web applications. Servant, on the other hand, is more lightweight and focuses on building RESTful APIs. When deciding which framework to use, consider the type of application you're building and the specific needs of your project. If you need a robust set of features and are building a web application, Yesod may be the better choice. If you're building a RESTful API, Servant may be the better choice. In the next topic, we will explore routing, templating, and handling forms in web applications using Yesod and Servant. **Recommended Reading** * [Yesod Documentation](https://yesodweb.com/): This is the official documentation for the Yesod framework and provides a comprehensive guide to getting started and advanced usage. * [Servant Documentation](https://hackage.haskell.org/package/servant): This is the official documentation for the Servant framework and provides a comprehensive guide to getting started and advanced usage. * [Haskell Web Development](https://www.reddit.com/r/haskell/comments/5q6j9g/web_development_with_haskell/): This is a Reddit thread discussing web development with Haskell and provides a good overview of the various frameworks and libraries available. **Leave a Comment** Leave a comment below with any questions you have about building a web application with Yesod or Servant.