Module

Yoga.Format.Parse

Package: purescript-yoga-format
Repository: rowtype-yoga/purescript-yoga-format

#Lit Source

data Lit :: Symbol -> Segmentdata Lit t0

Instances

FlushLitCons litAcc seg rest (SCons (Lit litAcc) (SCons seg rest))
FlushLitTail acc (SCons (Lit acc) SNil)

#Var Source

data Var :: Symbol -> Segmentdata Var t0

#Segment Source

data Segment

#SNil Source

data SNil :: SListdata SNil

Instances

ParseTemplate "" SNil
ContinueParse "" SNil
FlushLitTail "" SNil
FlushLitTail acc (SCons (Lit acc) SNil)

#SCons Source

data SCons :: Segment -> SList -> SListdata SCons t0 t1

Instances

FlushLitCons "" seg rest (SCons seg rest)
FlushLitCons litAcc seg rest (SCons (Lit litAcc) (SCons seg rest))
FlushLitTail acc (SCons (Lit acc) SNil)

#SList Source

data SList

#ParseTemplate Source

class ParseTemplate :: Symbol -> SList -> Constraintclass ParseTemplate sym segments | sym -> segments

Parse a template string into a list of segments

Instances

ParseTemplate "" SNil
(Cons h t sym, ParseNormal h t "" segments) => ParseTemplate sym segments

#ParseNormal Source

class ParseNormal :: Symbol -> Symbol -> Symbol -> SList -> Constraintclass ParseNormal head tail acc segments | head tail acc -> segments

Normal mode: accumulate literal characters

Instances

(Cons h2 t2 t, FlushLitCons acc (Var "dummy") SNil litSegments, ParseAfterDollar h2 t2 acc segments) => ParseNormal "$" t acc segments
(Append acc "$" final, FlushLitTail final segments) => ParseNormal "$" "" acc segments
(Append acc h final, FlushLitTail final segments) => ParseNormal h "" acc segments
(Append acc h acc', Cons nextH nextT t, ParseNormal nextH nextT acc' segments) => ParseNormal h t acc segments

#ParseAfterDollar Source

class ParseAfterDollar :: Symbol -> Symbol -> Symbol -> SList -> Constraintclass ParseAfterDollar head tail litAcc segments | head tail litAcc -> segments

After $: dispatch { for braced, otherwise simple var

Instances

(Cons h3 t3 t, ParseBracedVar h3 t3 "" litAcc segments) => ParseAfterDollar "{" t litAcc segments
(Fail (Text "Unclosed ${ at end of template")) => ParseAfterDollar "{" "" litAcc segments
(ParseSimpleVar h t "" litAcc segments) => ParseAfterDollar h t litAcc segments

#ParseBracedVar Source

class ParseBracedVar :: Symbol -> Symbol -> Symbol -> Symbol -> SList -> Constraintclass ParseBracedVar head tail acc litAcc segments | head tail acc litAcc -> segments

Parse braced var ${name.path} — accumulate until }

Instances

(ContinueParse t rest, FlushLitCons litAcc (Var acc) rest segments) => ParseBracedVar "}" t acc litAcc segments
(Fail (Beside (Text "Unclosed ${ in template. Missing } after: ") (Text acc))) => ParseBracedVar h "" acc litAcc segments
(Append acc h acc', Cons nextH nextT t, ParseBracedVar nextH nextT acc' litAcc segments) => ParseBracedVar h t acc litAcc segments

#ParseSimpleVar Source

class ParseSimpleVar :: Symbol -> Symbol -> Symbol -> Symbol -> SList -> Constraintclass ParseSimpleVar head tail acc litAcc segments | head tail acc litAcc -> segments

Parse simple $varname — stop on non-identifier chars

Instances

(IsVarChar h isVar, ParseSimpleVarDispatch isVar h t acc litAcc segments) => ParseSimpleVar h t acc litAcc segments

#ParseSimpleVarDispatch Source

class ParseSimpleVarDispatch :: Boolean -> Symbol -> Symbol -> Symbol -> Symbol -> SList -> Constraintclass ParseSimpleVarDispatch isVar head tail acc litAcc segments | isVar head tail acc litAcc -> segments

Instances

(Append h "" litChar, FlushLitCons litAcc (Var acc) (SCons (Lit litChar) SNil) segments) => ParseSimpleVarDispatch False h "" acc litAcc segments
(ParseNormal h t "" rest, FlushLitCons litAcc (Var acc) rest segments) => ParseSimpleVarDispatch False h t acc litAcc segments
(Append acc h varName, FlushLitCons litAcc (Var varName) SNil segments) => ParseSimpleVarDispatch True h "" acc litAcc segments
(Append acc h acc', Cons nextH nextT t, ParseSimpleVar nextH nextT acc' litAcc segments) => ParseSimpleVarDispatch True h t acc litAcc segments

#ContinueParse Source

class ContinueParse :: Symbol -> SList -> Constraintclass ContinueParse sym segments | sym -> segments

Continue parsing remaining input

Instances

ContinueParse "" SNil
(Cons h t sym, ParseNormal h t "" segments) => ContinueParse sym segments

#FlushLitCons Source

class FlushLitCons :: Symbol -> Segment -> SList -> SList -> Constraintclass FlushLitCons litAcc seg rest result | litAcc seg rest -> result

If litAcc is non-empty, prepend Lit litAcc before seg :: rest Otherwise just produce SCons seg rest

Instances

FlushLitCons "" seg rest (SCons seg rest)
FlushLitCons litAcc seg rest (SCons (Lit litAcc) (SCons seg rest))

#FlushLitTail Source

class FlushLitTail :: Symbol -> SList -> Constraintclass FlushLitTail acc segments | acc -> segments

Flush literal at tail position (end of template)

Instances

FlushLitTail "" SNil
FlushLitTail acc (SCons (Lit acc) SNil)

#IsVarChar Source

class IsVarChar :: Symbol -> Boolean -> Constraintclass IsVarChar ch result | ch -> result

Check if a character is valid in a variable name

Instances

Modules: Yoga.Format; Yoga.Format.Interpolate; Yoga.Format.Parse; Yoga.Format.Render