Safe Haskell	None

Hakyll.Web.Template

Description

This module provides means for reading and applying Templates.

Templates are tools to convert items into a string. They are perfectly suited for laying out your site.

Let's look at an example template:

 <html>
     <head>
         <title>My crazy homepage - $title$</title>
     </head>
     <body>
         <div id="header">
             <h1>My crazy homepage - $title$</h1>
         </div>
         <div id="content">
             $body$
         </div>
         <div id="footer">
             By reading this you agree that I now own your soul
         </div>
     </body>
 </html>

As you can see, the format is very simple -- $key$ is used to render the $key$ field from the page, everything else is literally copied. If you want to literally insert "$key$" into your page (for example, when you're writing a Hakyll tutorial) you can use

 <p>
     A literal $$key$$.
 </p>

Because of it's simplicity, these templates can be used for more than HTML: you could make, for example, CSS or JS templates as well.

Synopsis

Documentation

data Template Source

Datatype used for template substitutions.

Instances

Eq Template
Show Template
Typeable Template
Binary Template
Writable Template

templateCompiler :: Compiler (Item Template)Source

Read a template.

applyTemplate Source

Arguments

:: Template	Template
-> Context a	Context
-> Item a	Page
-> Compiler (Item String)	Resulting item

loadAndApplyTemplate Source

Arguments

:: Identifier	Template identifier
-> Context a	Context
-> Item a	Page
-> Compiler (Item String)	Resulting item

The following pattern is so common:

 tpl <- loadBody "templates/foo.html"
 someCompiler
     >>= applyTemplate tpl context

That we have a single function which does this:

 someCompiler
     >>= loadAndApplyTemplate "templates/foo.html" context

applyAsTemplate Source

Arguments

:: Context String	Context
-> Item String	Item and template
-> Compiler (Item String)	Resulting item

It is also possible that you want to substitute $key$ s within the body of an item. This function does that by interpreting the item body as a template, and then applying it to itself.

applyTemplateWith :: Monad m => (String -> a -> m String) -> Template -> a -> m String Source

Overloaded apply template function to work in an arbitrary Monad.