A compiled Splice is a HeistT computation that returns a DList (Chunk m).

The more interesting part of the type signature is what comes before the return value. The first type parameter in HeistT n IO is the runtime monad. This reveals that the Chunks know about the runtime monad. The second type parameter in HeistT n IO is IO. This tells is that the compiled splices themselves are run in the IO monad, which will usually mean at load time. Compiled splices run at load time, and they return computations that run at runtime.

Looks up a compiled template and returns a runtime monad computation that constructs a builder.

Given a list of output chunks, consolidate turns consecutive runs of Pure Html values into maximally-efficient pre-rendered strict ByteString chunks.

Runs the parameter node's children and returns the resulting compiled chunks. By itself this function is a simple passthrough splice that makes the spliced node disappear. In combination with locally bound splices, this function makes it easier to pass the desired view into your splices.

Helper function for transforming the second element of each of a list of tuples.

The type signature says it all.

Adds a prefix to the tag names for a list of splices. If the existing tag name is empty, then the new tag name is just the prefix. Otherwise the new tag name is the prefix followed by the separator followed by the existing name.

prefixSplices specialized to use a colon as separator in the style of XML namespaces.

Converts pure text splices to pure Builder splices.

Converts pure Node splices to pure Builder splices.

Converts pure Builder splices into monadic splice functions of a Promise.

Converts a pure text splice function to a pure Builder splice function.

Converts a pure Node splice function to a pure Builder splice function.

Converts a pure Builder splice function into a monadic splice function that takes a Promise.

Repromise a list of splices.

repromiseMay' for a list of splices.

Change the promise type of a splice function.

Change the promise type of a splice function with a function that might fail. If a Nothing is encountered, then the splice will generate no output.

Allows you to use deferred Promises in a compiled splice. It takes care of the boilerplate of creating and storing data in a promise to be used at load time when compiled splices are processed. This function is similar to mapPromises but runs on a single value instead of a list.

Takes a promise function and a runtime action returning a list of items that fit in the promise and returns a Splice that executes the promise function for each item and concatenates the results.

Another useful way of combining groups of splices. FIXME - We probably need to export this applyDeferred :: Monad n => RuntimeSplice n a -> [(Text, Promise a -> Splice n)] -> [(Text, Splice n)] applyDeferred m = applySnd m . mapSnd defer

This is kind of the opposite of defer. Not sure what to name it yet. FIXME - This is a really common pattern, so I think we do want to expose it deferred :: (Monad n) => (t -> RuntimeSplice n Builder) -> Promise t -> Splice n deferred f p = return $ yieldRuntime $ f =<< getPromise p

Runs a splice computation with a list of splices that are functions of runtime data.

Gets a list of items at runtime, then for each item it runs the splice with the list of splices bound. There is no pure variant of this function because the desired behavior can only be achieved as a function of a Promise.

Like withSplices, but works for "pure" splices that don't operate in the HeistT monad.

Takes a promise function and a runtime action returning a list of items that fit in the promise and returns a Splice that executes the promise function for each item and concatenates the results.

This function works nicely with the promiseChildrenWith family of functions, much like the combination of mapSplices and runChildrenWith for interpreted splices.

Returns a runtime computation that simply renders the node's children.

Binds a list of Builder splices before using the children of the spliced node as a view.

Wrapper that composes a transformation function with the second item in each of the tuples before calling promiseChildren.

Binds a list of Text splices before using the children of the spliced node as a view.

Binds a list of Node splices before using the children of the spliced node as a view. Note that this will slow down page generation because the nodes generated by the splices must be traversed and rendered into a ByteString at runtime.

Yields a pure Builder known at load time. You should use this and yieldPureText as much as possible to maximize the parts of your page that can be compiled to static ByteStrings.

Yields a runtime action that returns a builder.

Yields a runtime action that returns no value and is only needed for its side effect.

A convenience wrapper around yieldPure for working with Text. Roughly equivalent to textSplice from Heist.Interpreted.

Convenience wrapper around yieldRuntime allowing you to work with Text.

Adds a list of compiled splices to the splice map. This function is useful because it allows compiled splices to bind other compiled splices during load-time splice processing.

Promises are used for referencing the results of future runtime computations during load time splice processing.

Creates an empty promise.

Gets the result of a promised runtime computation.

Adds a promise to the runtime splice context.

Modifies a promise.

Returns a computation that performs load-time splice processing on the supplied list of nodes.

Runs a single node. If there is no splice referenced anywhere in the subtree, then it is rendered as a pure chunk, otherwise it calls compileNode to generate the appropriate runtime computation.

Performs splice processing on a list of attributes. This is useful in situations where you need to stop recursion, but still run splice processing on the node's attributes.

Performs splice processing on a list of attributes. This is useful in situations where you need to stop recursion, but still run splice processing on the node's attributes.

Looks up a compiled template and returns a compiled splice.