Routing.Match

newtype Match a

Constructors

• Match (Route -> V (Free MatchError) (Tuple Route a))

Instances

• Newtype (Match a) (List RoutePart -> V (Free MatchError) (Tuple (List RoutePart) a))
• Functor Match
• Alt Match
• Plus Match
• Alternative Match
• Apply Match
• Applicative Match

root :: Match Unit

Matches a leading slash.

lit :: String -> Match Unit

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

num :: Match Number

num matches any numerical path component.

int :: Match Int

int matches any integer path component.

bool :: Match Boolean

bool matches any boolean path component.

str :: Match String

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

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 :: 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 :: Match Unit

end matches the end of a route.

fail :: forall a. String -> Match a

nonempty :: Match NonEmptyString

Matches a non-empty string.

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 :: forall a. Match a -> Route -> Either String a

eitherMatch :: forall b a. 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 :: 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")]))