Module

Routing.Match

Package
purescript-routing
Repository
slamdata/purescript-routing

#root Source

root :: Match Unit

Matches a leading slash.

#lit Source

lit :: String -> Match Unit

lit x will match exactly the path component x. For example, lit "x" matches /x.

#num Source

num :: Match Number

num matches any numerical path component.

#int Source

int :: Match Int

int matches any integer path component.

#bool Source

bool :: Match Boolean

bool matches any boolean path component.

#str Source

str :: Match String

str matches any path string component. For example, str matches /foo as "foo".

#param Source

param :: String -> Match String

param p matches a parameter assignment q=v within a query block. For example, param "q" matches /?q=a&r=b as "a".

#params Source

params :: Match (Map String String)

params matches an entire query block. For exmaple, params matches /?q=a&r=b as the map {q : "a", r : "b"}. Note that lit "foo" *> params does not match /foo, since a query component is required.

#end Source

end :: Match Unit

end matches the end of a route.

#fail Source

fail :: forall a. String -> Match a

#nonempty Source

nonempty :: Match NonEmptyString

Matches a non-empty string.

#list Source

list :: forall a. Match a -> Match (List a)

Matches list of matchers. Useful when argument can easy fail (not str) returns Match Nil if no matches

#runMatch Source

runMatch :: forall a. Match a -> Route -> Either String a

#eitherMatch Source

eitherMatch :: forall a b. Match (Either a b) -> Match b

if we match something that can fail then we have to match Either a b. This function converts matching on such sum to matching on right subpart. Matching on left branch fails. i.e.

data Sort = Asc | Desc
sortOfString :: String -> Either String Sort
sortOfString "asc" = Right Asc
sortOfString "desc" = Right Desc
sortOfString _ = Left "incorrect sort"

newtype Routing = Routing Sort
routes :: Match Routing
routes = (pure Routing) <*> (eitherMatch (sortOfString <$> var))

#optionalMatch Source

optionalMatch :: forall a. Match a -> Match (Maybe a)

useful for matching optional params at the end of a path

optParams = maybe M.empty id <$> optionalMatch params <* end
runMatch (lit "path" *> optParams) (parse id "path/?a=1")
-- (Right (fromFoldable [(Tuple "a" "1")]))