# Difference between revisions of "Web/Literature/Practical web programming in Haskell"

This page is under construction. Feel free to help out. If you make substantial edits, please add your name to the authors list at the bottom of this page, so that you can be credited if this is ever published in another medium.

This tutorial focuses on CGI and FastCGI programming. For more introductory information, see tutorials, blogs and research and discussion.

## Introduction

This tutorial aims to get you started with writing web applications in Haskell. We describe a relatively light-weight approach to Haskell web programming which uses a CGI library and an XHTML combinator library.

We think that while the approach we describe here is not as sophisticated or innovative as some other approaches, it is simple, portable and easy to understand if you are already familiar with web programming in other languages.

The tutorial starts with preliminaries such as how to install the necessary software and how to compile and run your web applications. We then show a number of working small example programs which introduce the basic features of the CGI and XHtml libraries. We then move on to how to use monad transformers to add application specific functionality such as sessions to the CGI monad, and how to create database-driven web applications. We also present FastCGI, and an approach to using dynamically loaded Haskell code.

## Assumed knowledge

This tutorial is not meant as an introduction to Haskell or web programming. We will assume that you have some familiarity with the following concepts: We assume knowledge of the following:

• Haskell: This tutorial is not meant as a first introduction to Haskell. If you want to learn about Haskell in general, have a look at the lists of books and tutorials. You may want to start with Haskell in 5 steps.
• (X)HTML: HTML (HyperText Markup Language) is the "the lingua franca for publishing hypertext on the World Wide Web. The XHtml library which we use in this tutorial produces XHTML 1.0, which is HTML 4.0 formulated as XML. The combinators in the XHtml library do not make much sense unless you understand at least some parts of HTML.
• CGI: CGI (Common Gateway Interface) programs are programs which run on the web server. They are given input which comes from the user's browser, and their output is given to the browser. To really understand how the CGI library works, you probably need to know a thing or two about CGI. (Tutorial.)

## Required software

• GHC, the Glasgow Haskell Compiler, is the Haskell implementation that we will use in this tutorial. However, any Haskell implementation that supports Haskell98 and multi-parameter type classes should work.
• xhtml: This package provides combinators for producing XHTML 1.0, including the Strict, Transitional and Frameset variants. Download here.
• A web server: You need to have access to a web server on which you can run CGI programs. The most convenient way to do this when learning and developing is to run a web server on your development machine. If you run the programs on some other machine you need to make sure that you compile your programs so that they can run on that machine. This normally means that the machines must to have the same architecture and run the same operating system.

## Compiling and running web applications

Use GHC to produce a binary executable called prog.cgi from the Haskell source code file prog.hs:

ghc --make -o prog.cgi prog.hs


Put the compiled program in the cgi-bin directory, or give it the extension .cgi, depending on the configuration of the web server. Linking your applications statically will avoid problems with missing libraries on the web server.

## Hello World!

Here is a very simple example which just outputs some static HTML. The type signatures in this code are optional. We show them here for clarity, but omit them in some later examples.

import Network.CGI
import Text.XHtml

page :: Html
page = body << h1 << "Hello World!"

cgiMain :: CGI CGIResult
cgiMain = output $renderHtml page main :: IO () main = runCGI$ handleErrors cgiMain


The page function constructs an HTML document which consists of a body containing a single header element which contains the text "Hello World". The CGI-action cgiMain renders the HTML document as a string, and produces that string as output. The main function runs cgiMain, using the normal CGI protocol for input and output. It also uses handleErrors to output an error page in case cgiMain throws an exception.

Fans of one-liners may like this version better (handleErrors has been omitted since this simple program will not throw any exceptions):

import Text.XHtml
import Network.CGI

main = runCGI $handleErrors cgiMain  This code makes use of the getInput function from the CGI library: -- Get the value of an input variable, for example from a form. -- If the variable has multiple values, the first one is returned. getInput :: String -> CGI (Maybe String)  ## Cookies import Network.CGI import Text.XHtml import Control.Monad (liftM) import Data.Maybe (fromMaybe) hello :: Int -> Html hello 0 = h1 << "Welcome!" +++ p << "This is the first time I see you." hello c = h1 << "Welcome back!" +++ p << ("I have seen you " ++ show c ++ " times before.") page :: String -> Html -> Html page t b = header << thetitle << t +++ body << b cgiMain :: CGI CGIResult cgiMain = do c <- liftM (fromMaybe 0)$ readCookie "mycookie"
output . renderHtml . page "Cookie example" $hello c main :: IO () main = runCGI$ handleErrors cgiMain


Here we use newCookie, setCookie and readCookie to store and retrieve a counter cookie in the browser. If you want to get the string value of a cookie, use getCookie instead of readCookie.

FIXME: use a safer example

-- Accepts file uploads and saves the files in the given directory.
-- WARNING: this script is a SECURITY RISK and only for
-- demo purposes. Do not put it on a public web server.

import Network.CGI
import Text.XHtml

import qualified Data.ByteString.Lazy as BS

import Data.Maybe (fromJust)

fileForm = form ! [method "post", enctype "multipart/form-data"]
<< [afile "file", submit "" "Upload"]
saveFile n =
do cont <- liftM fromJust $getInputFPS "file" let f = uploadDir ++ "/" ++ basename n liftIO$ BS.writeFile f cont
return $paragraph << ("Saved as " +++ anchor ! [href f] << f +++ ".") page t b = header << thetitle << t +++ body << b basename = reverse . takeWhile (notElem "/\\") . reverse cgiMain = do mn <- getInputFilename "file" h <- maybe (return fileForm) saveFile mn output . renderHtml$ page "Upload example" h

main = runCGI $handleErrors cgiMain  We first output a file upload form, which should use the HTTP POST method, and the multipart/form-data content type. Here we seen an example of the use of HTML attributes, added with the ! operator. For efficiency reasons, we use Data.ByteString.Lazy to represent the file contents. getInputFPS gets the value of an input variable as a lazy ByteString. ## Error handling handleErrors catches all exceptions and outputs a default error page with some information about the exception. You can write you own exception handler if you want to do something else when an exception is thrown. It can be useful to set the response code, e.g. 404. ## Returning non-HTML Of course we do not have to output HTML. Use setHeader to set the value of the Content-type header, and you can output whatever string you like. In this example we return an image: import Network.CGI import System.IO import qualified Data.ByteString.Lazy as B main = do b <- B.readFile "./img/test.jpg" -- read the image runCGI . handleErrors . cgiMain$ b

cgiMain :: B.ByteString -> CGI CGIResult
cgiMain p = do
-- we need to set the appropriate content-type
outputFPS p


You can use the setHeader function to set arbitrary HTTP response headers. You can also set the response code, as seen above.

Example: output raw file data (with last-modified)

At this point, you should be able to create many useful CGI scripts. As your scripts get more ambitious, however, you may find yourself needing to pass "global" parameters to your CGI actions (e.g. database connections, session information.) Rather than explicitly passing these values around, you can extend the CGI monad to do this work for you.

The Network.CGI.Monad module defines a CGI monad transformer, allowing us to build a new monad that does everything the CGI monad does -- and more!

For example, let's define a new CGI monad that provides a database connection (in this example, we use the Database.HSQL.PostgreSQL module for our database.) Since it will be used by the CGI application, I'll call the new monad "App".

Should this not compile for you, you need to enable some extensions:

{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE FlexibleInstances #-}


After importing the appropriate modules, we define a new type, AppT that is made up of two monad transformers, CGIT and ReaderT. The CGIT monad "wraps" the base monad "m". The CGIT monad, in turn, is wrapped by the ReaderT monad, which contains, in its environment, the database Connection.

AppT takes two type parameters. The first is the base monad that the monad transformers are modifying. Usually this will be the IO monad. The second type is the data type that an action in the monad will return.

import Control.Monad.Reader
import Network.CGI
import Database.HSQL.PostgreSQL

newtype AppT m a = App (ReaderT Connection (CGIT m) a)


Like CGI, we make a type synonym that defines the most common use of this new monad.

type App a = AppT IO a


We're not quite finished defining App yet. In order to be used like the CGI monad, App needs to be an instance of the MonadCGI class. This class defines two functions that we must support.

instance MonadCGI (AppT IO) where
cgiAddHeader n v = App . lift $cgiAddHeader n v cgiGet x = App . lift$ cgiGet x


So now we have an App monad that gives us all the functionality of CGI, but also carries around a database connection. The last step is to define the function that creates the monad so we can run actions inside it.

import Control.Exception (bracket)
import System.IO (stdin, stdout)

runApp :: App CGIResult -> IO ()
runApp (App a) =
bracket (connect "host" "db" "user" "password")
disconnect
(\c -> do { env <- getCGIVars
; hRunCGI env stdin stdout (runCGIT (runReaderT a c))
; return () } )


(either fill in your account/password information, or change runApp to accept the parameters as function arguments.) The function uses bracket so that the database connection gets released properly when the monad ends or if an exception is thrown.

## Templating

There are times when you absolutely do not want to embed (X)HTML in Haskell. You can separate the code and the presentation (the Holy Grail of erm, web development). The code will be, well, Haskell, and the presentation will be buried inside templates. This might not be the case: fortunately, there is a very nice templating engine available: HStringTemplate; also very useful is hakyll, a simple static site generator library, mainly aimed at creating blogs and brochure sites.

## FastCGI

FastCGI is a standard for CGI-like programs that are not restarted for every request. This reduces the overhead involved in handling each request, and reduces the servers response time for each request. The overhead involved in starting a new process for each request can also include the need to set up new DB connections every time. With FastCGI, DB connections can be reused.

Install FastCGI. Get a web server which can run FastCGI programs. Import Network.FastCGI. Use runFastCGI.