:: IO_a_ -> _ IO_a -package:base

Generalized version of evaluate.

Respond with 200 OK.

main = simpleHTTP nullConf $ ok "Everything is OK"

Respond with 204 No Content A 204 No Content response may not contain a message-body. If you try to supply one, it will be dutifully ignored.

main = simpleHTTP nullConf $ noContent "This will be ignored."

Respond with 500 Internal Server Error.

main = simpleHTTP nullConf $ internalServerError "Sorry, there was an internal server error."

Responds with 502 Bad Gateway.

main = simpleHTTP nullConf $ badGateway "Bad Gateway."

Respond with 400 Bad Request.

main = simpleHTTP nullConf $ badRequest "Bad Request."

Respond with 401 Unauthorized.

main = simpleHTTP nullConf $ unauthorized "You are not authorized."

Respond with 403 Forbidden.

main = simpleHTTP nullConf $ forbidden "Sorry, it is forbidden."

Respond with 404 Not Found.

main = simpleHTTP nullConf $ notFound "What you are looking for has not been found."

Respond with 413 Request Entity Too Large.

main = simpleHTTP nullConf $ requestEntityTooLarge "That's too big for me to handle."

Throw an error, escaping the current computation up to the nearest catchError (if any).

runThrow (throwError e >>= k) = runThrow (throwError e)

Like throwEnvelopeErr but without providing a message.

>>> import Control.Monad.Except (runExcept)

>>> throwEnvelopeErr "BAD_ERROR" "a very bad error occurred!" :: Either (Err String) Int
Left (Err {errErr = "BAD_ERROR", errExtra = Just "a very bad error occurred!"})

A higher-order generalisation of replicate. For example

foo :: IO (String, String, String)
foo = replicateT getLine

> foo
Hello
world
!
("Hello","world","!")

Use sequenceT instead. It has a better name.

A higher-order generalisation of sequenceA. For example

> sequenceT (print 3110, putStrLn World) :: IO ((), ())
3110
World
((),())

Lift a value.

Lift a value into the Structure.

Examples

>>> pure 1 :: Maybe Int
Just 1

>>> pure 'z' :: [Char]
"z"

>>> pure (pure ":D") :: Maybe [String]
Just [":D"]

Lift a value.

Inject a value into the monadic type.

Inject a value into the monadic type. This function should not be different from its default implementation as pure. The justification for the existence of this function is merely historic.

Strict version of return because usually we don't need that extra thunk.