A function to compile template file. This function DOES NOT escape template variables. To render the compiled file, use Renderer.*.renderMarkup.

>>> putStr $ renderMarkup (let as = ["<a>", "b"] in $(compileTextFile "templates/sample.txt"))
sample
key: <a>,
key: b,

Same as compileText but allows the user to specify extra values for template parameters. Values declared by overwrite overwrites same name variables. Values declared by setDefault are overwritten by same name variables.

>>> :set -XOverloadedStrings
>>> :{
putStr $ renderMarkup (
  let as = ["<a>", "b"]
  in $(compileTextFileWith "templates/sample.txt" $ do
    setDefault "as" [| ["foo", "bar"] |]
  )
)
:}
sample
key: <a>,
key: b,

>>> :{
putStr $ renderMarkup (
  let as = ["<a>", "b"]
  in $(compileTextFileWith "templates/sample.txt" $ do
    overwrite "as" [| ["foo", "bar"] |]
  )
)
:}
sample
key: foo,
key: bar,

>>> :{
putStr $ renderMarkup (
  let as = ["<a>", "b"]
  in $(compileTextFileWith "templates/sample.txt" $ do
    overwrite "as" [| ["bazbaz", "barbar"] |]
    setDefault "as" [| ["foo", "bar"] |]
    overwrite "as" [| ["baz", "foobar"] |]
  )
)
:}
sample
key: baz,
key: foobar,

Same as compileText but allows the user to specify default values for template parameters.

>>> :set -XOverloadedStrings
>>> :{
putStr $ renderMarkup (
  let as = ["<a>", "b"]
  in $(compileTextFileWithDefault "templates/sample.txt"
    [("as", [| ["foo", "bar"] |])]
  )
)
:}
sample
key: <a>,
key: b,

>>> :{
putStr $ renderMarkup (
  $(compileTextFileWithDefault "templates/sample.txt"
    [("as", [| ["foo", "bar"] |])]
  )
)
:}
sample
key: foo,
key: bar,

Same as compileTextFile but escapes template variables in HTML.

>>> putStr $ renderMarkup (let as = ["<a>", "b"] in $(compileHtmlFile "templates/sample.txt"))
sample
key: &lt;a&gt;,
key: b,

Same as compileHtmlFile but allows the user to specify extra values for template parameters. Values declared by overwrite overwrites same name variables. Values declared by setDefault are overwritten by same name variables.

>>> :set -XOverloadedStrings
>>> :{
putStr $ renderMarkup (
  let as = ["<a>", "b"]
  in $(compileHtmlFileWith "templates/sample.txt" $ do
    setDefault "as" [| ["foo", "bar"] |]
  )
)
:}
sample
key: &lt;a&gt;,
key: b,

>>> :{
putStr $ renderMarkup (
  let as = ["<a>", "b"]
  in $(compileHtmlFileWith "templates/sample.txt" $ do
    overwrite "as" [| ["foo", "bar"] |]
  )
)
:}
sample
key: foo,
key: bar,

>>> :{
putStr $ renderMarkup (
  let as = ["<a>", "b"]
  in $(compileHtmlFileWith "templates/sample.txt" $ do
    overwrite "as" [| ["bazbaz", "barbar"] |]
    setDefault "as" [| ["foo", "bar"] |]
    overwrite "as" [| ["baz", "foobar"] |]
  )
)
:}
sample
key: baz,
key: foobar,

Same as compileHtmlFile but allows the user to specify default values for template parameters.

>>> :set -XOverloadedStrings
:{
putStr $ renderMarkup (
  let as = ["<a>", "b"]
  in $(compileHtmlFileWithDefault "templates/sample.txt"
    [("as", [| ["foo", "bar"] |])]
  )
)
:}
sample
key: &lt;a&gt;,
key: b,

>>> :{
putStr $ renderMarkup (
  $(compileHtmlFileWithDefault "templates/sample.txt"
    [("as", [| ["foo", "bar"] |])]
  )
)
:}
sample
key: foo,
key: bar,

Heterocephalus quasi-quoter. This function DOES NOT escape template variables. To render the compiled file, use Renderer.*.renderMarkup.

>>> renderMarkup (let as = ["<a>", "b"] in [compileText|sample %{ forall a <- as }key: #{a}, %{ endforall }|])
"sample key: <a>, key: b, "

>>> renderMarkup (let num=2 in [compileText|#{num} is %{ if even num }an even number.%{ elseif (num > 100) }big.%{ else }an odd number.%{ endif }|])
"2 is an even number."

Heterocephalus quasi-quoter for HTML. Same as compileText but this function does escape template variables in HTML.

>>> renderMarkup (let as = ["<a>", "b"] in [compileHtml|sample %{ forall a <- as }key: #{a}, %{ endforall }|])
"sample key: &lt;a&gt;, key: b, "

A type to handle extra scopes. This is opaque type, so use setDefault and overwrite to construct new ScopeM.

Constructor for ScopeM. Values declared by this function are overwritten by same name variables exits in scope of render function.

Constructor for ScopeM. Values declared by this function overwrites same name variables exits in scope of render function.

Settings that are used when processing heterocephalus templates.

A setting that DOES NOT escape template variables.

This sets escapeExp to preEscapedToMarkup.

A setting that escapes template variables for Html

This sets escapeExp to toHtml.

Default set of parser options.

Sets parseOptionsControlPrefix to '%' and parseOptionsVariablePrefix to '#'.

QuasiQuoter.

QuasiQuoter.

Compile a template file.

Same as compileFile but we can specify default scope.

Same as compileFile but we can specify default scope.

Same as compileFile, but just compile the String given.

>>> let as = ["<a>", "b"]
>>> let template = "sample %{ forall a <- as }key: #{a}, %{ endforall }"
>>> renderMarkup $(compileFromString textSetting template)
"sample key: <a>, key: b, "

>>> let as = ["<a>", "b"]
>>> let options = createParseOptions '|' '?'
>>> let setting = textSetting { parseOptions = options }
>>> let template = "sample |{ forall a <- as }key: ?{a}, |{ endforall }"
>>> renderMarkup $(compileFromString setting template)
"sample key: <a>, key: b, "