request-monad: A transformer for generic requests

[ control, library, mit ] [ Propose Tags ]

An MTL-style monad that can be used to perform requests. Using RequestT simplifies writing generic middleware.

[Skip to Readme]


Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees


  • No Candidates
Versions [RSS],,,
Change log
Dependencies base (>=4.7 && <4.8), free (==4.9), mtl (>=2.2 && <2.3), transformers (>=0.4 && <0.5) [details]
License MIT
Author Tom Hulihan
Maintainer Tom Hulihan <>
Category Control
Home page
Bug tracker
Source repo head: git clone git://
Uploaded by nahiluhmot at 2014-06-27T13:47:58Z
Reverse Dependencies 1 direct, 0 indirect [details]
Downloads 2950 total (6 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs uploaded by user
Build status unknown [no reports yet]

Readme for request-monad-

[back to package description]



This library exports a monad that can be used to abstract a request sending/response handling pattern. It can be used to implement type-transforming middleware, as well as a way to easily implement stubbing.


From the command line:

$ cabal install request-monad

To use data types and functions export from this library:

import Control.Monad.Request


Using RequestT r r' m a abstracts sending requests of type r, and handling responses of r'. Below is an example of using RequestT to ask for somebody's name and age. Note that there is no logic about how to get and return the strings in getNameAndAge, that's all handled in prompt.

import Control.Monad
import Control.Monad.Request
import System.IO

getNameAndAge :: Monad m => RequestT String String m (String, Int)
getNameAndAge = do
    name <- send "Name: "
    age <- liftM read $ send "Age: "
    return (name, age)

prompt :: String -> IO String
prompt str = putStr str >> hFlush stdout >> getLine

main :: IO ()
main = do
    (name, age) <- runRequestT getNameAndAge prompt
    putStrLn $ name ++ " is " ++ show age ++ " years old."

Below is an example of an echo server, which just returns the exact input that it was given.

import Control.Monad.Request

pingPong :: Monad m => RequestT String String m (String, String)
pingPong = do
    a <- send "ping"
    b <- send "pong"
    return (a, b)

main :: IO ()
main = do
    let (a, b) = runRequest pingPong id
    putStrLn $ "a: " ++ a -- Prints "a: ping"
    putStrLn $ "b: " ++ b -- Prints "b: pong"

Aside from implementation-independant requests, this abstraction also simplifies adding request/response middleware. The code below adds JSON deserialization to each response.

{-# LANGUAGE OverloadedStrings #-}

import Control.Monad
import Control.Monad.Request
import qualified Data.Aeson as A
import qualified Data.ByteString.Lazy as B

deserialize :: (A.FromJSON a, Monad m) => B.ByteString -> m (Maybe a)
deserialize = return . A.decode

tryTwice :: Monad m => RequestT B.ByteString B.ByteString m (Maybe A.Value)
tryTwice = mapResponseT deserialize $ do
    a <- send "request one"
    b <- send "request two"
    return $ a `mplus` b

handleRequest :: Monad m => B.ByteString -> B.ByteString
handleRequest "request one" = return "not json"
handleRequest x             = "[15]"

main :: IO ()
main = do
    let res = runRequest tryTwice handleRequest
    print $ res -- Prints "Just (Array (fromList [Number 15.0]))"


  • Add a strict version of RequestT