Module

TLDR.Combinators.Class

Package: purescript-tldr
Repository: mikesol/purescript-tldr

#Unit Source

data Unit

Instances

UnUnit (Success (Cons Unit r) t) (Success r t)

#RCPair Source

data RCPair token combinator

#InternalFormat Source

class InternalFormat :: Symbol -> Doc -> Doc -> Constraintclass InternalFormat indent doc doc' | indent doc -> doc'

Instances

InternalFormat sym (Text t) (Beside (Text sym) (Text t))
InternalFormat sym (Quote q) (Beside (Text sym) (Quote q))
(InternalFormat "" a a', InternalFormat "" b b') => InternalFormat sym (Beside a b) (Beside (Text sym) (Beside a' b'))
(Append " " sym sym', InternalFormat sym' a a', InternalFormat sym' b b') => InternalFormat sym (Above a b) (Above a' b')

#Format Source

class Format i o | i -> o

Instances

Format (Success a b) (Success a b)
(InternalFormat "" fail newFail) => Format (Failure fail) (Failure newFail)

#ModifyState Source

class ModifyState :: Symbol -> Type -> Type -> Type -> Constraintclass ModifyState remaining constant stateI stateO | remaining constant stateI -> stateO

#DoConstantStateModificationOnSuccess Source

class DoConstantStateModificationOnSuccess :: Symbol -> Type -> Type -> Type -> Type -> Constraintclass DoConstantStateModificationOnSuccess remaining constant res stateI stateO | constant res stateI -> stateO

Instances

DoConstantStateModificationOnSuccess remaining constant (Failure fail) stateI stateI
(ModifyState remaining constant stateI stateO) => DoConstantStateModificationOnSuccess remaining constant (Success a b) stateI stateO

#DoConstantStateModificationWithResult Source

class DoConstantStateModificationWithResult :: Symbol -> (Type -> Type) -> Type -> Type -> Type -> Constraintclass DoConstantStateModificationWithResult sym f res stateI stateO | f res stateI -> stateO

Instances

DoConstantStateModificationWithResult sym f (Failure fail) stateI stateI
(ModifyState sym (f a) stateI stateO) => DoConstantStateModificationWithResult sym f (Success a b) stateI stateO

#ShowParser Source

class ShowParser :: forall k. k -> Doc -> Constraintclass ShowParser k doc | k -> doc

Instances

(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d', ShowParser e e', ShowParser g g', ShowParser h h', ShowParser i i', ShowParser j j', ShowParser k k') => ShowParser (SP10 name a b c d e g h i j k) (Above (Text name) (Above a' (Above b' (Above c' (Above d' (Above e' (Above g' (Above h' (Above i' (Above j' k'))))))))))
(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d', ShowParser e e', ShowParser g g', ShowParser h h', ShowParser i i', ShowParser j j') => ShowParser (SP9 name a b c d e g h i j) (Above (Text name) (Above a' (Above b' (Above c' (Above d' (Above e' (Above g' (Above h' (Above i' j')))))))))
(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d', ShowParser e e', ShowParser g g', ShowParser h h', ShowParser i i') => ShowParser (SP8 name a b c d e g h i) (Above (Text name) (Above a' (Above b' (Above c' (Above d' (Above e' (Above g' (Above h' i'))))))))
(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d', ShowParser e e', ShowParser g g', ShowParser h h') => ShowParser (SP7 name a b c d e g h) (Above (Text name) (Above a' (Above b' (Above c' (Above d' (Above e' (Above g' h')))))))
(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d', ShowParser e e', ShowParser g g') => ShowParser (SP6 name a b c d e g) (Above (Text name) (Above a' (Above b' (Above c' (Above d' (Above e' g'))))))
(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d', ShowParser e e') => ShowParser (SP5 name a b c d e) (Above (Text name) (Above a' (Above b' (Above c' (Above d' e')))))
(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d') => ShowParser (SP4 name a b c d) (Above (Text name) (Above a' (Above b' (Above c' d'))))
(ShowParser a a', ShowParser b b', ShowParser c c') => ShowParser (SP3 name a b c) (Above (Text name) (Above a' (Above b' c')))
(ShowParser a a', ShowParser b b') => ShowParser (SP2 name a b) (Above (Text name) (Above a' b'))
(ShowParser a a') => ShowParser (SP1 name a) (Above (Text name) a')
ShowParser (Text a) (Text a)
ShowParser (Quote a) (Quote a)
ShowParser (Above a b) (Above a b)
ShowParser (Beside a b) (Beside a b)
ShowParser (Failure fail) fail
ShowParser (Proxy s) (Text s)
ShowParser Nil (Text "Nil")
(ShowParser a a', ShowParser b b') => ShowParser (Cons a b) (Beside a' b')
(ShowParser ignore ignore', ShowParser match match') => ShowParser (IgnoreAndThenParse ignore match) (Above (Text "C.IgnoreAndThenParse") (Above ignore' match'))
(ShowParser ignore ignore', ShowParser match match') => ShowParser (ParseAndThenIgnore match ignore) (Above (Text "C.ParseAndThenIgnore") (Above match' ignore'))
(ShowParser match match') => ShowParser (Many match) (Above (Text "Many") match')
(ShowParser match match') => ShowParser (Some match) (Above (Text "Some") match')
(ShowParser match match') => ShowParser (Const match) (Above (Text "Const") match')
(ShowParser constant constant', ShowParser cont cont') => ShowParser (ModifyStateAfterSuccessOnConstant constant cont) (Above (Text "C.ModifyStateAfterSuccessOnConstant") (Above constant' cont'))
(ShowParser cont cont') => ShowParser (ModifyStateAfterSuccessWithResult f cont) (Above (Text "C.ModifyStateAfterSuccessWithResult") cont')
(ShowParser a a', ShowParser b b') => ShowParser (BranchOnState a b) (Above (Text "BranchOnState") (Above a' b'))
(ShowParser i i', ShowParser t t') => ShowParser (IfThen i t) (Above (Text "IfThen") (Above i' t'))
(ShowParser i i', ShowParser t t') => ShowParser (Or i t) (Above (Text "Or") (Above i' t'))
(ShowMatch Any o) => ShowParser Any (Text o)
(ShowMatch MatchAZ o) => ShowParser MatchAZ (Text o)
(ShowMatch Noop o) => ShowParser Noop (Text o)
(ShowMatch EOF o) => ShowParser EOF (Text o)
(ShowMatch Match09 o) => ShowParser Match09 (Text o)
(ShowMatch Matchaz o) => ShowParser Matchaz (Text o)
(ShowMatch MatchAlpha o) => ShowParser MatchAlpha (Text o)
(ShowMatch MatchAlphanumeric o) => ShowParser MatchAlphanumeric (Text o)
(ShowMatch MatchAZ09 o) => ShowParser MatchAZ09 (Text o)
(ShowMatch Matchaz09 o) => ShowParser Matchaz09 (Text o)
(ShowMatch MatchHex o) => ShowParser MatchHex (Text o)
(ShowMatch MatchWhitespace o) => ShowParser MatchWhitespace (Text o)
(ShowMatch (Literal m) o) => ShowParser (Literal m) (Text o)
(ShowMatch (Some m) o) => ShowParser (Some m) (Text o)
(ShowMatch (Many m) o) => ShowParser (Many m) (Text o)
(ShowMatch (Except m n) o) => ShowParser (Except m n) (Text o)
(ShowMatch (Or m n) o) => ShowParser (Or m n) (Text o)
(ShowMatch (And m n) o) => ShowParser (And m n) (Text o)
(ShowMatch (Match2 m) o) => ShowParser (Match2 m) (Text o)
(ShowMatch (Match3 m) o) => ShowParser (Match3 m) (Text o)
(ShowMatch (Match4 m) o) => ShowParser (Match4 m) (Text o)
(ShowMatch (Match5 m) o) => ShowParser (Match5 m) (Text o)
(ShowMatch (Match6 m) o) => ShowParser (Match6 m) (Text o)
(ShowMatch (Match7 m) o) => ShowParser (Match7 m) (Text o)
(ShowMatch (Match8 m) o) => ShowParser (Match8 m) (Text o)
(ShowMatch (Match9 m) o) => ShowParser (Match9 m) (Text o)

#SP10 Source

data SP10 :: Symbol -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Typedata SP10 name a b c d e g h i j k

Instances

(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d', ShowParser e e', ShowParser g g', ShowParser h h', ShowParser i i', ShowParser j j', ShowParser k k') => ShowParser (SP10 name a b c d e g h i j k) (Above (Text name) (Above a' (Above b' (Above c' (Above d' (Above e' (Above g' (Above h' (Above i' (Above j' k'))))))))))

#SP9 Source

data SP9 :: Symbol -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Typedata SP9 name a b c d e g h i j

Instances

(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d', ShowParser e e', ShowParser g g', ShowParser h h', ShowParser i i', ShowParser j j') => ShowParser (SP9 name a b c d e g h i j) (Above (Text name) (Above a' (Above b' (Above c' (Above d' (Above e' (Above g' (Above h' (Above i' j')))))))))

#SP8 Source

data SP8 :: Symbol -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Typedata SP8 name a b c d e g h i

Instances

(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d', ShowParser e e', ShowParser g g', ShowParser h h', ShowParser i i') => ShowParser (SP8 name a b c d e g h i) (Above (Text name) (Above a' (Above b' (Above c' (Above d' (Above e' (Above g' (Above h' i'))))))))

#SP7 Source

data SP7 :: Symbol -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Typedata SP7 name a b c d e g h

Instances

(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d', ShowParser e e', ShowParser g g', ShowParser h h') => ShowParser (SP7 name a b c d e g h) (Above (Text name) (Above a' (Above b' (Above c' (Above d' (Above e' (Above g' h')))))))

#SP6 Source

data SP6 :: Symbol -> Type -> Type -> Type -> Type -> Type -> Type -> Typedata SP6 name a b c d e g

Instances

(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d', ShowParser e e', ShowParser g g') => ShowParser (SP6 name a b c d e g) (Above (Text name) (Above a' (Above b' (Above c' (Above d' (Above e' g'))))))

#SP5 Source

data SP5 :: Symbol -> Type -> Type -> Type -> Type -> Type -> Typedata SP5 name a b c d e

Instances

(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d', ShowParser e e') => ShowParser (SP5 name a b c d e) (Above (Text name) (Above a' (Above b' (Above c' (Above d' e')))))

#SP4 Source

data SP4 :: Symbol -> Type -> Type -> Type -> Type -> Typedata SP4 name a b c d

Instances

(ShowParser a a', ShowParser b b', ShowParser c c', ShowParser d d') => ShowParser (SP4 name a b c d) (Above (Text name) (Above a' (Above b' (Above c' d'))))

#SP3 Source

data SP3 :: Symbol -> Type -> Type -> Type -> Typedata SP3 name a b c

Instances

(ShowParser a a', ShowParser b b', ShowParser c c') => ShowParser (SP3 name a b c) (Above (Text name) (Above a' (Above b' c')))

#SP2 Source

data SP2 :: Symbol -> Type -> Type -> Typedata SP2 name a b

Instances

(ShowParser a a', ShowParser b b') => ShowParser (SP2 name a b) (Above (Text name) (Above a' b'))

#SP1 Source

data SP1 :: Symbol -> Type -> Typedata SP1 name a

Instances

(ShowParser a a') => ShowParser (SP1 name a) (Above (Text name) a')

#ContinueIfMatch Source

class ContinueIfMatch :: Row Type -> Type -> Type -> Type -> Type -> Type -> Constraintclass ContinueIfMatch rc res' parse stateI res stateO | rc res' parse stateI -> res stateO

Instances

ContinueIfMatch rc (Failure fail) parse stateI (Failure fail) stateI
(ParseRC rc b parse stateI res stateO) => ContinueIfMatch rc (Success ignore b) parse stateI res stateO

#GetDefault Source

class GetDefault :: RowList Type -> Type -> Constraintclass GetDefault i o | i -> o

Instances

GetDefault (Cons k v rest) v

#ContinueIfParse Source

class ContinueIfParse :: Row Type -> Type -> Type -> Type -> Type -> Type -> Constraintclass ContinueIfParse rc res' match stateI res stateO | rc res' match stateI -> res stateO

Instances

ContinueIfParse rc (Failure fail) match stateI (Failure fail) stateI
(ParseRC rc b (IgnoreAndThenParse match (Const yay)) stateI res stateO) => ContinueIfParse rc (Success yay b) match stateI res stateO

#UseIfMatch Source

class UseIfMatch :: Row Type -> Symbol -> Type -> Type -> Type -> Type -> Type -> Type -> Constraintclass UseIfMatch rc sym res' parse stateI stateI' res stateO | rc sym res' parse stateI stateI' -> res stateO

Instances

(ParseRC rc sym parse stateI res stateO) => UseIfMatch rc sym (Failure fail) parse stateI stateI' res stateO
UseIfMatch rc sym (Success h t) parse stateI stateI' (Success h t) stateI'

#ManyLoop Source

class ManyLoop :: Row Type -> Symbol -> Type -> Type -> Type -> Type -> Type -> Constraintclass ManyLoop rc i inRes inState parse outRes outState | rc i inRes inState parse -> outRes outState

Instances

(ParseRC rc t parse inState res' outState', ManyLoop rc t res' outState' parse (Success h' t') outState) => ManyLoop rc i (Success h t) inState parse (Success (Cons h h') t') outState
ManyLoop rc i (Failure ignore) inState parse (Success Nil i) inState

#UnUnit Source

class UnUnit i o | i -> o

Instances

UnUnit (Success (Cons Unit r) t) (Success r t)
UnUnit a a

#FailOnNil Source

class FailOnNil i o | i -> o

Instances

FailOnNil (Success Nil i) (Failure (Text "Expected at least one match"))
FailOnNil (Success (Cons a b) c) (Success (Cons a b) c)
FailOnNil (Failure fail) (Failure fail)

#ContinueNary Source

class ContinueNary :: forall ctor. Row Type -> Type -> Type -> ctor -> Type -> Type -> Type -> Constraintclass ContinueNary rc resI stateI ctor args resO stateO | rc resI stateI ctor args -> resO stateO

Instances

(ShowParser (ctor (Failure fail) b c d e g h i j k) doc) => ContinueNary rc (Failure fail) stateI ctor (Args9 b c d e g h i j k) (Failure (SingleFailure doc)) stateI
(ShowParser (ctor (Failure fail) b c d e g h i j) doc) => ContinueNary rc (Failure fail) stateI ctor (Args8 b c d e g h i j) (Failure (SingleFailure doc)) stateI
(ShowParser (ctor (Failure fail) b c d e g h i) doc) => ContinueNary rc (Failure fail) stateI ctor (Args7 b c d e g h i) (Failure (SingleFailure doc)) stateI
(ShowParser (ctor (Failure fail) b c d e g h) doc) => ContinueNary rc (Failure fail) stateI ctor (Args6 b c d e g h) (Failure (SingleFailure doc)) stateI
(ShowParser (ctor (Failure fail) b c d e g) doc) => ContinueNary rc (Failure fail) stateI ctor (Args5 b c d e g) (Failure (SingleFailure doc)) stateI
(ShowParser (ctor (Failure fail) b c d e) doc) => ContinueNary rc (Failure fail) stateI ctor (Args4 b c d e) (Failure (SingleFailure doc)) stateI
(ShowParser (ctor (Failure fail) b c d) doc) => ContinueNary rc (Failure fail) stateI ctor (Args3 b c d) (Failure (SingleFailure doc)) stateI
(ShowParser (ctor (Failure fail) b c) doc) => ContinueNary rc (Failure fail) stateI ctor (Args2 b c) (Failure (SingleFailure doc)) stateI
(ShowParser (ctor (Failure fail) b) doc) => ContinueNary rc (Failure fail) stateI ctor (Args1 b) (Failure (SingleFailure doc)) stateI
(ParseADT rc rest (ctor yay) (Args9 b c d e g h i j k) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args9 b c d e g h i j k) res stateO
(ParseADT rc rest (ctor yay) (Args8 b c d e g h i j) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args8 b c d e g h i j) res stateO
(ParseADT rc rest (ctor yay) (Args7 b c d e g h i) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args7 b c d e g h i) res stateO
(ParseADT rc rest (ctor yay) (Args6 b c d e g h) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args6 b c d e g h) res stateO
(ParseADT rc rest (ctor yay) (Args5 b c d e g) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args5 b c d e g) res stateO
(ParseADT rc rest (ctor yay) (Args4 b c d e) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args4 b c d e) res stateO
(ParseADT rc rest (ctor yay) (Args3 b c d) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args3 b c d) res stateO
(ParseADT rc rest (ctor yay) (Args2 b c) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args2 b c) res stateO
(ParseADT rc rest (ctor yay) (Args1 b) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args1 b) res stateO

#RecastSuccessToProxy Source

class RecastSuccessToProxy i o | i -> o

Instances

RecastSuccessToProxy (Failure fail) (Failure fail)
RecastSuccessToProxy (Success a b) (Success (Proxy a) b)

#Sequence2 Source

class Sequence2 :: forall f. f -> Type -> Type -> Constraintclass Sequence2 f res o | f res -> o

Instances

Sequence2 f (Success a b) (Success (f a) b)
(ShowParser (f (Failure fail)) o) => Sequence2 f (Failure fail) (Failure (SingleFailure o))

#ParseRC Source

class ParseRC :: Row Type -> Symbol -> Type -> Type -> Type -> Type -> Constraintclass ParseRC rc sym combinator stateI res stateO | rc sym combinator stateI -> res stateO

Instances

(Match sym Any res', RecastSuccessToProxy res' res) => ParseRC rc sym Any stateI res stateI
(Match sym MatchAZ res', RecastSuccessToProxy res' res) => ParseRC rc sym MatchAZ stateI res stateI
(Match sym Match09 res', RecastSuccessToProxy res' res) => ParseRC rc sym Match09 stateI res stateI
(Match sym Matchaz res', RecastSuccessToProxy res' res) => ParseRC rc sym Matchaz stateI res stateI
(Match sym MatchAlpha res', RecastSuccessToProxy res' res) => ParseRC rc sym MatchAlpha stateI res stateI
(Match sym MatchAlphanumeric res', RecastSuccessToProxy res' res) => ParseRC rc sym MatchAlphanumeric stateI res stateI
(Match sym MatchAZ09 res', RecastSuccessToProxy res' res) => ParseRC rc sym MatchAZ09 stateI res stateI
(Match sym Matchaz09 res', RecastSuccessToProxy res' res) => ParseRC rc sym Matchaz09 stateI res stateI
(Match sym MatchHex res', RecastSuccessToProxy res' res) => ParseRC rc sym MatchHex stateI res stateI
(Match sym MatchWhitespace res', RecastSuccessToProxy res' res) => ParseRC rc sym MatchWhitespace stateI res stateI
(Match sym (Literal m) res', RecastSuccessToProxy res' res) => ParseRC rc sym (Literal m) stateI res stateI
(Match sym (Some m) res', RecastSuccessToProxy res' res) => ParseRC rc sym (Some m) stateI res stateI
(Match sym (Many m) res', RecastSuccessToProxy res' res) => ParseRC rc sym (Many m) stateI res stateI
(Match sym (Except m n) res', RecastSuccessToProxy res' res) => ParseRC rc sym (Except m n) stateI res stateI
(Match sym (Or m n) res', RecastSuccessToProxy res' res) => ParseRC rc sym (Or m n) stateI res stateI
(Match sym (And m n) res', RecastSuccessToProxy res' res) => ParseRC rc sym (And m n) stateI res stateI
(Match sym (Match2 m) res', RecastSuccessToProxy res' res) => ParseRC rc sym (Match2 m) stateI res stateI
(Match sym (Match3 m) res', RecastSuccessToProxy res' res) => ParseRC rc sym (Match3 m) stateI res stateI
(Match sym (Match4 m) res', RecastSuccessToProxy res' res) => ParseRC rc sym (Match4 m) stateI res stateI
(Match sym (Match5 m) res', RecastSuccessToProxy res' res) => ParseRC rc sym (Match5 m) stateI res stateI
(Match sym (Match6 m) res', RecastSuccessToProxy res' res) => ParseRC rc sym (Match6 m) stateI res stateI
(Match sym (Match7 m) res', RecastSuccessToProxy res' res) => ParseRC rc sym (Match7 m) stateI res stateI
(Match sym (Match8 m) res', RecastSuccessToProxy res' res) => ParseRC rc sym (Match8 m) stateI res stateI
(Match sym (Match9 m) res', RecastSuccessToProxy res' res) => ParseRC rc sym (Match9 m) stateI res stateI
(Match sym ignore res', ContinueIfMatch rc res' parse stateI res stateO) => ParseRC rc sym (IgnoreAndThenParse ignore parse) stateI res stateO
(ParseRC rc sym parse stateI res' stateO', ContinueIfParse rc res' ignore stateO' res stateO) => ParseRC rc sym (ParseAndThenIgnore parse ignore) stateI res stateO
(ParseRC rc sym left stateI res' stateO', UseIfMatch rc sym res' right stateI stateO' res stateO) => ParseRC rc sym (Or left right) stateI res stateO
ParseRC rc sym (Const val) stateI (Success val sym) stateI
(Cons token combinator rc' rc, ParseRC rc sym combinator stateI res stateO) => ParseRC rc sym (Proxy token) stateI res stateO
(ParseRC rc sym cont stateI res stateO', DoConstantStateModificationOnSuccess sym constant res stateO' stateO) => ParseRC rc sym (ModifyStateAfterSuccessOnConstant constant cont) stateI res stateO
(ParseRC rc sym cont stateI res stateO', DoConstantStateModificationWithResult sym f res stateO' stateO) => ParseRC rc sym (ModifyStateAfterSuccessWithResult f cont) stateI res stateO
(ManyLoop rc i (Success Unit i) stateI parse res' stateO, UnUnit res' res) => ParseRC rc i (Many parse) stateI res stateO
(ManyLoop rc i (Success Unit i) stateI parse res' stateO, UnUnit res' res'', FailOnNil res'' res) => ParseRC rc i (Some parse) stateI res stateO
(ParseRC rc i cont stateI res stateO) => ParseRC rc i (BranchOnState (Cons (IfThen stateI cont) rest) otherwise) stateI res stateO
(ParseRC rc i (BranchOnState rest otherwise) stateI res stateO) => ParseRC rc i (BranchOnState (Cons (IfThen stateX cont) rest) otherwise) stateI res stateO
(ParseRC rc i otherwise stateI res stateO) => ParseRC rc i (BranchOnState Nil otherwise) stateI res stateO
(Union selfs rc newRC, RowToList selfs rcl, GetDefault rcl combinator, ParseRC newRC i combinator stateI res stateO) => ParseRC rc i (Fix selfs) stateI res stateO
(ParseADT rc sym f (Args10 a b c d e g h i j k) stateI res stateO) => ParseRC rc sym (f a b c d e g h i j k) stateI res stateO
(ParseADT rc sym f (Args9 a b c d e g h i j) stateI res stateO) => ParseRC rc sym (f a b c d e g h i j) stateI res stateO
(ParseADT rc sym f (Args8 a b c d e g h i) stateI res stateO) => ParseRC rc sym (f a b c d e g h i) stateI res stateO
(ParseADT rc sym f (Args7 a b c d e g h) stateI res stateO) => ParseRC rc sym (f a b c d e g h) stateI res stateO
(ParseADT rc sym f (Args6 a b c d e g) stateI res stateO) => ParseRC rc sym (f a b c d e g) stateI res stateO
(ParseADT rc sym f (Args5 a b c d e) stateI res stateO) => ParseRC rc sym (f a b c d e) stateI res stateO
(ParseADT rc sym f (Args4 a b c d) stateI res stateO) => ParseRC rc sym (f a b c d) stateI res stateO
(ParseADT rc sym f (Args3 a b c) stateI res stateO) => ParseRC rc sym (f a b c) stateI res stateO
(ParseADT rc sym f (Args2 a b) stateI res stateO) => ParseRC rc sym (f a b) stateI res stateO
(ParseADT rc sym f (Args1 a) stateI res stateO) => ParseRC rc sym (f a) stateI res stateO

#ParseADT Source

class ParseADT :: forall ctor. Row Type -> Symbol -> ctor -> Type -> Type -> Type -> Type -> Constraintclass ParseADT rc sym ctor args stateI res stateO | rc sym ctor args stateI -> res stateO

Instances

(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args9 b c d e g h i j k) res stateO) => ParseADT rc sym f (Args10 a b c d e g h i j k) stateI res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args8 b c d e g h i j) res stateO) => ParseADT rc sym f (Args9 a b c d e g h i j) stateI res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args7 b c d e g h i) res stateO) => ParseADT rc sym f (Args8 a b c d e g h i) stateI res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args6 b c d e g h) res stateO) => ParseADT rc sym f (Args7 a b c d e g h) stateI res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args5 b c d e g) res stateO) => ParseADT rc sym f (Args6 a b c d e g) stateI res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args4 b c d e) res stateO) => ParseADT rc sym f (Args5 a b c d e) stateI res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args3 b c d) res stateO) => ParseADT rc sym f (Args4 a b c d) stateI res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args2 b c) res stateO) => ParseADT rc sym f (Args3 a b c) stateI res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args1 b) res stateO) => ParseADT rc sym f (Args2 a b) stateI res stateO
(ParseRC rc sym a stateI res' stateO, Sequence2 f res' res) => ParseADT rc sym f (Args1 a) stateI res stateO

#Args10 Source

data Args10 a b c d e g h i j k

Instances

(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args9 b c d e g h i j k) res stateO) => ParseADT rc sym f (Args10 a b c d e g h i j k) stateI res stateO

#Args9 Source

data Args9 a b c d e g h i j

Instances

(ShowParser (ctor (Failure fail) b c d e g h i j k) doc) => ContinueNary rc (Failure fail) stateI ctor (Args9 b c d e g h i j k) (Failure (SingleFailure doc)) stateI
(ParseADT rc rest (ctor yay) (Args9 b c d e g h i j k) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args9 b c d e g h i j k) res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args8 b c d e g h i j) res stateO) => ParseADT rc sym f (Args9 a b c d e g h i j) stateI res stateO

#Args8 Source

data Args8 a b c d e g h i

Instances

(ShowParser (ctor (Failure fail) b c d e g h i j) doc) => ContinueNary rc (Failure fail) stateI ctor (Args8 b c d e g h i j) (Failure (SingleFailure doc)) stateI
(ParseADT rc rest (ctor yay) (Args8 b c d e g h i j) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args8 b c d e g h i j) res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args7 b c d e g h i) res stateO) => ParseADT rc sym f (Args8 a b c d e g h i) stateI res stateO

#Args7 Source

data Args7 a b c d e g h

Instances

(ShowParser (ctor (Failure fail) b c d e g h i) doc) => ContinueNary rc (Failure fail) stateI ctor (Args7 b c d e g h i) (Failure (SingleFailure doc)) stateI
(ParseADT rc rest (ctor yay) (Args7 b c d e g h i) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args7 b c d e g h i) res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args6 b c d e g h) res stateO) => ParseADT rc sym f (Args7 a b c d e g h) stateI res stateO

#Args6 Source

data Args6 a b c d e g

Instances

(ShowParser (ctor (Failure fail) b c d e g h) doc) => ContinueNary rc (Failure fail) stateI ctor (Args6 b c d e g h) (Failure (SingleFailure doc)) stateI
(ParseADT rc rest (ctor yay) (Args6 b c d e g h) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args6 b c d e g h) res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args5 b c d e g) res stateO) => ParseADT rc sym f (Args6 a b c d e g) stateI res stateO

#Args5 Source

data Args5 a b c d e

Instances

(ShowParser (ctor (Failure fail) b c d e g) doc) => ContinueNary rc (Failure fail) stateI ctor (Args5 b c d e g) (Failure (SingleFailure doc)) stateI
(ParseADT rc rest (ctor yay) (Args5 b c d e g) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args5 b c d e g) res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args4 b c d e) res stateO) => ParseADT rc sym f (Args5 a b c d e) stateI res stateO

#Args4 Source

data Args4 a b c d

Instances

(ShowParser (ctor (Failure fail) b c d e) doc) => ContinueNary rc (Failure fail) stateI ctor (Args4 b c d e) (Failure (SingleFailure doc)) stateI
(ParseADT rc rest (ctor yay) (Args4 b c d e) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args4 b c d e) res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args3 b c d) res stateO) => ParseADT rc sym f (Args4 a b c d) stateI res stateO

#Args3 Source

data Args3 a b c

Instances

(ShowParser (ctor (Failure fail) b c d) doc) => ContinueNary rc (Failure fail) stateI ctor (Args3 b c d) (Failure (SingleFailure doc)) stateI
(ParseADT rc rest (ctor yay) (Args3 b c d) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args3 b c d) res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args2 b c) res stateO) => ParseADT rc sym f (Args3 a b c) stateI res stateO

#Args2 Source

data Args2 a b

Instances

(ShowParser (ctor (Failure fail) b c) doc) => ContinueNary rc (Failure fail) stateI ctor (Args2 b c) (Failure (SingleFailure doc)) stateI
(ParseADT rc rest (ctor yay) (Args2 b c) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args2 b c) res stateO
(ParseRC rc sym a stateI res' stateO', ContinueNary rc res' stateO' f (Args1 b) res stateO) => ParseADT rc sym f (Args2 a b) stateI res stateO

#Args1 Source

data Args1 a

Instances

(ShowParser (ctor (Failure fail) b) doc) => ContinueNary rc (Failure fail) stateI ctor (Args1 b) (Failure (SingleFailure doc)) stateI
(ParseADT rc rest (ctor yay) (Args1 b) stateI res stateO) => ContinueNary rc (Success yay rest) stateI ctor (Args1 b) res stateO
(ParseRC rc sym a stateI res' stateO, Sequence2 f res' res) => ParseADT rc sym f (Args1 a) stateI res stateO

#Parse Source

class Parse :: Symbol -> Type -> Type -> Type -> Type -> Constraintclass Parse sym combinator stateI res stateO | sym combinator stateI -> res stateO

Instances

(ParseRC () sym Any stateI res' stateI, Format res' res) => Parse sym Any stateI res stateI
(ParseRC () sym MatchAZ stateI res' stateI, Format res' res) => Parse sym MatchAZ stateI res stateI
(ParseRC () sym Match09 stateI res' stateI, Format res' res) => Parse sym Match09 stateI res stateI
(ParseRC () sym Matchaz stateI res' stateI, Format res' res) => Parse sym Matchaz stateI res stateI
(ParseRC () sym MatchAlpha stateI res' stateI, Format res' res) => Parse sym MatchAlpha stateI res stateI
(ParseRC () sym MatchAlphanumeric stateI res' stateI, Format res' res) => Parse sym MatchAlphanumeric stateI res stateI
(ParseRC () sym MatchAZ09 stateI res' stateI, Format res' res) => Parse sym MatchAZ09 stateI res stateI
(ParseRC () sym Matchaz09 stateI res' stateI, Format res' res) => Parse sym Matchaz09 stateI res stateI
(ParseRC () sym MatchHex stateI res' stateI, Format res' res) => Parse sym MatchHex stateI res stateI
(ParseRC () sym MatchWhitespace stateI res' stateI, Format res' res) => Parse sym MatchWhitespace stateI res stateI
(ParseRC () sym (Literal m) stateI res' stateI, Format res' res) => Parse sym (Literal m) stateI res stateI
(ParseRC () sym (Some m) stateI res' stateI, Format res' res) => Parse sym (Some m) stateI res stateI
(ParseRC () sym (Many m) stateI res' stateI, Format res' res) => Parse sym (Many m) stateI res stateI
(ParseRC () sym (Except m n) stateI res' stateI, Format res' res) => Parse sym (Except m n) stateI res stateI
(ParseRC () sym (Or m n) stateI res' stateI, Format res' res) => Parse sym (Or m n) stateI res stateI
(ParseRC () sym (And m n) stateI res' stateI, Format res' res) => Parse sym (And m n) stateI res stateI
(ParseRC () sym (Match2 m) stateI res' stateI, Format res' res) => Parse sym (Match2 m) stateI res stateI
(ParseRC () sym (Match3 m) stateI res' stateI, Format res' res) => Parse sym (Match3 m) stateI res stateI
(ParseRC () sym (Match4 m) stateI res' stateI, Format res' res) => Parse sym (Match4 m) stateI res stateI
(ParseRC () sym (Match5 m) stateI res' stateI, Format res' res) => Parse sym (Match5 m) stateI res stateI
(ParseRC () sym (Match6 m) stateI res' stateI, Format res' res) => Parse sym (Match6 m) stateI res stateI
(ParseRC () sym (Match7 m) stateI res' stateI, Format res' res) => Parse sym (Match7 m) stateI res stateI
(ParseRC () sym (Match8 m) stateI res' stateI, Format res' res) => Parse sym (Match8 m) stateI res stateI
(ParseRC () sym (Match9 m) stateI res' stateI, Format res' res) => Parse sym (Match9 m) stateI res stateI
(ParseRC () sym (IgnoreAndThenParse ignore parse) stateI res' stateO, Format res' res) => Parse sym (IgnoreAndThenParse ignore parse) stateI res stateO
(ParseRC () sym (ParseAndThenIgnore parse ignore) stateI res' stateO, Format res' res) => Parse sym (ParseAndThenIgnore parse ignore) stateI res stateO
(ParseRC () sym (Or left right) stateI res' stateO, Format res' res) => Parse sym (Or left right) stateI res stateO
(ParseRC () sym (Const val) stateI (Success val sym) stateO) => Parse sym (Const val) stateI (Success val sym) stateO
(ParseRC () sym (ModifyStateAfterSuccessOnConstant constant cont) stateI res' stateO, Format res' res) => Parse sym (ModifyStateAfterSuccessOnConstant constant cont) stateI res stateO
(ParseRC () sym (ModifyStateAfterSuccessWithResult f cont) stateI res' stateO, Format res' res) => Parse sym (ModifyStateAfterSuccessWithResult f cont) stateI res stateO
(ParseRC () i (Many parse) stateI res' stateO, Format res' res) => Parse i (Many parse) stateI res stateO
(ParseRC () i (Some parse) stateI res' stateO, Format res' res) => Parse i (Some parse) stateI res stateO
(ParseRC () i (BranchOnState (Cons (IfThen stateI cont) rest) otherwise) stateI res' stateO, Format res' res) => Parse i (BranchOnState (Cons (IfThen stateI cont) rest) otherwise) stateI res stateO
(ParseRC () i (BranchOnState (Cons (IfThen stateX cont) rest) otherwise) stateI res' stateO, Format res' res) => Parse i (BranchOnState (Cons (IfThen stateX cont) rest) otherwise) stateI res stateO
(ParseRC () i (BranchOnState Nil otherwise) stateI res' stateO, Format res' res) => Parse i (BranchOnState Nil otherwise) stateI res stateO
(RowToList selfs rcl, GetDefault rcl combinator, ParseRC selfs i combinator stateI res' stateO, Format res' res) => Parse i (Fix selfs) stateI res stateO
(ParseRC () sym (f a b c d e g h i j k) stateI res' stateO, Format res' res) => Parse sym (f a b c d e g h i j k) stateI res stateO
(ParseRC () sym (f a b c d e g h i j) stateI res' stateO, Format res' res) => Parse sym (f a b c d e g h i j) stateI res stateO
(ParseRC () sym (f a b c d e g h i) stateI res' stateO, Format res' res) => Parse sym (f a b c d e g h i) stateI res stateO
(ParseRC () sym (f a b c d e g h) stateI res' stateO, Format res' res) => Parse sym (f a b c d e g h) stateI res stateO
(ParseRC () sym (f a b c d e g) stateI res' stateO, Format res' res) => Parse sym (f a b c d e g) stateI res stateO
(ParseRC () sym (f a b c d e) stateI res' stateO, Format res' res) => Parse sym (f a b c d e) stateI res stateO
(ParseRC () sym (f a b c d) stateI res' stateO, Format res' res) => Parse sym (f a b c d) stateI res stateO
(ParseRC () sym (f a b c) stateI res' stateO, Format res' res) => Parse sym (f a b c) stateI res stateO
(ParseRC () sym (f a b) stateI res' stateO, Format res' res) => Parse sym (f a b) stateI res stateO
(ParseRC () sym (f a) stateI res' stateO, Format res' res) => Parse sym (f a) stateI res stateO

#FailOnFail Source

class FailOnFail res

Instances

(Fail fail) => FailOnFail (Failure fail)
FailOnFail (Success a b)

Modules: TLDR.Combinators; TLDR.Combinators.Class; TLDR.List; TLDR.Matchers; TLDR.Matchers.Class; TLDR.Matchers.Match09; TLDR.Matchers.MatchAlpha; TLDR.Matchers.MatchAlphanumeric; TLDR.Matchers.MatchHex; TLDR.Matchers.MatchLaz; TLDR.Matchers.MatchLaz09; TLDR.Matchers.MatchUaz; TLDR.Matchers.MatchUaz09; TLDR.Matchers.MatchWhitespace; TLDR.Matchers.Show; TLDR.Result; TLDR.Sugar