Nero

This module re-exports the essential functions for quickly writing Nero applications. Use the original modules for more specialized functions.

Server

type Application = Request -> IO Response

class Server a where

Ultimately any valid Nero server application must be transformed Request -> IO Response. This type class facilitates the creation of web server handling Nero applications.

Methods

application :: a -> Application

Instances

Server Response

Server (Request -> Maybe Response)

Server (Request -> Response)

Request

data Request

An HTTP Request.

Instances

Eq Request

Show Request

Param Request

It traverses the values with the same key both in the query string and the form encoded body of a POST Request.

Formed Request

HasBody Request

HasQuery Request

HasPath Request

HasHost Request

HasUrl Request

Server (Request -> Maybe Response)

Server (Request -> Response)

get :: Url -> Request

Smart constructor for GET Requests.

post :: Url -> Payload -> Request

Smart constructor for POST Requests.

_GET :: Prism' Request GET

Prism' for GET Requests.

_POST :: Prism' Request POST

Prism' to filter for POST Requests.

method :: Request -> ByteString

Show Request method.

path :: HasPath a => Lens' a Path

query :: HasQuery a => Lens' a Query

form :: Formed a => Traversal' a Form

params :: Traversal' Request MultiMap

This Traversal lets you traverse every HTTP parameter regardless of whether it's present in the query string or in the form encoded body of a POST Request. In the rare case where there are HTTP parameters in both, every parameter is still being traversed starting from the /query string/.

You might want to use param for traversing a specific parameter.

>>> let request = dummyRequestForm & query . at "name" ?~ ["hello", "out"] & form  . at "name" ?~ ["there"]
>>> foldOf params request ^? ix "name"
Just ["hello","out","there"]

param :: Param a => Text -> Traversal' a Text

body :: HasBody a => a -> Body

GET

data GET

A GET Request.

Instances

Eq GET

Show GET

HasQuery GET

HasPath GET

HasHost GET

HasUrl GET

POST

data POST

A POST Request.

Instances

Eq POST

Show POST

HasPayload POST

HasQuery POST

HasPath POST

HasHost POST

HasUrl POST

Response

data Response

An HTTP response.

Instances

Eq Response

Show Response

HasBody Response

Location Response

Server Response

Server (Request -> Maybe Response)

Server (Request -> Response)

ok :: Text -> Response

Creates an 200 OK response from the given text. It automatically encodes the text to 'utf-8'. The Mime type is text/plain.

movedPermanently :: Url -> Response

Creates an 301 Moved Permanently response with the Location corresponding to the given Url.

URL

data Url

Composite type of a Scheme, Host, Path, Query.

Instances

Eq Url

Show Url

Renderable Url

Param Url

HasQuery Url

HasPath Url

HasHost Url

Matching

match :: Getter Text Match

This is just to pure with a refined type.

class Prefixed a where

This Prism' strips/prepends a prefix.

>>> ("/hello/there"::Text) ^? prefixed "/hello/"
Just "there"

>>> prefixed "/hello/" # ("there"::Text)
"/hello/there"

If matching the entire source it previews to an empty Text. You might use exact if you are expecting this behavior.

>>> ("hello"::Text) ^? prefixed "hello"
Just ""

This also means that to review an entire source, you need to give it an empty Text.

>>> prefixed "hello" # (mempty::Text)
"hello"

An empty Match matches to itself regardless of the pattern.

>>> preview (prefixed "hello") (review (prefixed "hello") (mempty::Text)) <&> is _Empty
Just True

Methods

prefixed :: Text -> Prism' a a

Instances

Prefixed Text

Prefixed Match

Like Text instance but for the head of a Match

class Suffixed a where

This Prism' strips/appends a suffix.

>>> ("/hello/there"::Text) ^? suffixed "there"
Just "/hello/"

>>> suffixed "there" # ("/hello/"::Text)
"/hello/there"

If matching the entire source it previews to an empty Text. You might use exact if you are expecting this behavior.

>>> ("hello"::Text) ^? suffixed "hello"
Just ""

This also means that to review an entire source, you need to give it an empty Text.

>>> suffixed "hello" # (mempty::Text)
"hello"

An empty Match matches to itself regardless of the pattern.

>>> preview (suffixed "hello") (review (suffixed "hello") (mempty::Text)) <&> is _Empty
Just True

Methods

suffixed :: Text -> Prism' a a

Instances

Suffixed Text

Suffixed Match

Like Text instance but for the head of a Match

sep :: Text -> Prism' Match Match

This Prism' splits/joins at the first occurrence of a boundary for the first value of a Match.

>>> pure "hello/out/there" ^? sep "/" <&> toListOf folded
Just ["out/there","hello"]

>>> sep "/" # (pure "out/there" <> pure "hello") & view _head
"hello/out/there"

Notice what happens when there is no source before or after a boundary:

>>> pure "hello/" ^? sep "/"
Just ["","hello"]
>>> (pure "hello/" <> pure "there") ^? sep "/"
Just ["","hello","there"]

>>> pure "/hello" ^? sep "/"
Just ["hello",""]
>>> (pure "/hello" <> pure "there") ^? sep "/"
Just ["hello","","there"]

When the source is identical to the boundary: >>> pure "hello" ^? sep "hello" Just []

split :: Text -> Fold Text Match

This is the composition of match and sep. Use this to avoid lifting a Match explicitly. Notice that, unlike sep, this is not reversible.

exact :: Text -> Prism' Text ()

This is just an alias to only. Use this to match the entirety of the source. The source mustn't be lifted to a Match.

>>> "hello" ^? exact "hello"
Just ()

Results handling

class Target a where

Prism' between a Match and a target type.

Methods

target :: Prism' Match a

Instances

Target Float

Target Int

Target Text

Target Match

(Target a, Target b) => Target (a, b)

Testing

dummyRequest :: Request

An empty GET request useful for testing.

dummyRequestForm :: Request

An empty POST request with an empty form encoded body useful for testing.

dummyUrl :: Url

Empty Url useful for testing.

Nero Prelude

module Nero.Prelude