Network.Routing

>>> :set -XDataKinds -XOverloadedStrings -XNoMonomorphismRestriction
>>> import Data.Proxy (Proxy(..))
>>> import Text.Read(readMaybe)
>>> import qualified Data.Text as T

1. create path

>>> data Result = A | B T.Text | C | D Int deriving Show
>>> let a = root $ exact "foo" $ action Nothing (\_ -> Just A)
>>> let b = root $ exact "bar" $ fetch (Proxy :: Proxy "key") Just $ action Nothing (\d -> Just . B $ D.get (Proxy :: Proxy "key") d)
>>> let c = root $ exact "bar" $ any $ action (Just "GET") (\_ -> Just C)
>>> let d = root $ exact "bar" $ fetch (Proxy :: Proxy "key") (\t -> readMaybe (T.unpack t) :: Maybe Int) $ action Nothing (\d -> Just . D $ D.get (Proxy :: Proxy "key") d)
>>> a
* /foo
>>> b
* /bar/:key
>>> c
GET /bar/**
>>> d
* /bar/:key

1. create router

>>> let r = d +| a +| b +| c +| empty

1. execute router

>>> let run = execute r

>>> run "GET" ["foo"]
Just A
>>> run "GET" ["foo", "bar"]
Nothing
>>> run "GET" ["bar", "12"]
Just (D 12)
>>> run "GET" ["bar", "baz"]
Just (B "baz")
>>> run "GET" ["bar", "baz", "qux"]
Just C
>>> run "POST" ["bar", "baz", "qux"]
Nothing

Documentation

type Method = ByteString

Path

data Path d m a

routing path

Instances

Show (Path d m a)

Path constructors

root :: Path [] m a -> Path [] m a

root

root == id

children

exact :: Text -> Path d m a -> Path d m a

exact matching path

action

action

Arguments

:: Maybe Method

if Nothing, any method allowed

-> (Dict d -> m a)

action when route matching

-> Path d m a

action

get parameter

type Raw m d d'

Arguments

 = Dict d

input dictionary

-> [Text]

input path information

-> m (Dict d', [Text])

output dictionary and path information

raw

Arguments

:: String

pretty print

-> Raw m d d'

-> Path d' m a

-> Path d m a

get one directory as parameter.

raw get parameter function

if you want matching exact path, use exact for performance

fetch

Arguments

:: (MonadPlus m, KnownSymbol k, k </ d)

=> proxy k

dictionary key

-> (Text -> Maybe v)

reading function

-> Path ((k := v) : d) m a

-> Path d m a

any :: Monad m => Path d m a -> Path d m a

drop any pathes

rest

Arguments

:: (KnownSymbol k, Monad m, k </ d)

=> proxy k

dictionary key

-> Path ((k := [Text]) : d) m a

-> Path d m a

take any pathes as [Text]

Router

data Router d m a

router

empty :: MonadPlus m => Router [] m a

empty router

add :: MonadPlus m => Path [] m a -> Router [] m a -> Router [] m a infixr 9

insert path to router

(+|) :: MonadPlus m => Path [] m a -> Router [] m a -> Router [] m a infixr 9

infix version of add

execute

execute :: MonadPlus m => Router [] m a -> Method -> [Text] -> m a

execute router