hakyll-4.4.3.0: A static website compiler library

Safe Haskell | None

Hakyll.Web.Template

Description

This module provides means for reading and applying `Template`s.

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

- data Template
- templateCompiler :: Compiler (Item Template)
- applyTemplate :: Template -> Context a -> Item a -> Compiler (Item String)
- loadAndApplyTemplate :: Identifier -> Context a -> Item a -> Compiler (Item String)
- applyAsTemplate :: Context String -> Item String -> Compiler (Item String)

# 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.