hakyll-4.2.1.0: A static website compiler library

Safe HaskellNone

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.

applyTemplateSource

Arguments

:: Template

Template

-> Context a

Context

-> Item a

Page

-> Compiler (Item String)

Resulting item

loadAndApplyTemplateSource

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

applyAsTemplateSource

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 StringSource

Overloaded apply template function to work in an arbitrary Monad.