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]

Downloads

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

Candidates

  • No Candidates
Versions [RSS] 0.1.0.0, 0.2.0.0, 0.3.0.0, 0.3.0.1
Change log CHANGELOG.md
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 <hulihan.tom159@gmail.com>
Category Control
Home page http://github.com/nahiluhmot/request-monad
Bug tracker http://github.com/nahiluhmot/request-monad/issues
Source repo head: git clone git://github.com/nahiluhmot/request-monad.git
Uploaded by nahiluhmot at 2014-06-27T13:47:58Z
Distributions
Reverse Dependencies 1 direct, 0 indirect [details]
Downloads 2933 total (11 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-0.3.0.1

[back to package description]

request-monad

Hackage

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.

Installation

From the command line:

$ cabal install request-monad

To use data types and functions export from this library:

import Control.Monad.Request

Usage

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]))"

TODO

  • Add a strict version of RequestT