Safe Haskell	Safe-Infered

Hakyll.Web.Template

Description

This module provides means for reading and applying Templates.

Templates are tools to convert data (pages) 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>

We can use this template to render a Page which has a body and a $title$ metadata field.

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.

In addition to the native format, Hakyll also supports hamlet templates. For more information on hamlet templates, please refer to: http://hackage.haskell.org/package/hamlet. Internally, hamlet templates are converted to hakyll templates -- which means that you can only use variable insertion (and not all hamlet's features).

This is an example of a valid hamlet template. You should place them in files with a .hamlet extension:

 !!!
 <html>
     <head>
         <meta charset="UTF-8">
         <title> MyAweSomeCompany - #{title}
     <body>
         <h1> MyAweSomeCompany - #{title}
         <div id="navigation">
             <a href="/index.html"> Home
             <a href="/about.html"> About
             <a href="/code.html"> Code
         #{body}

Synopsis

Documentation

data Template Source

Datatype used for template substitutions.

Instances

Eq Template
Show Template
Typeable Template
Binary Template
Writable Template

applyTemplate :: Template -> Page String -> Page String Source

Substitutes $identifiers in the given Template by values from the given Page. When a key is not found, it is left as it is.

applyTemplateWith Source

Arguments

:: (String -> String)	Fallback if key missing
-> Template	Template to apply
-> Page String	Input page
-> Page String	Resulting page

A version of applyTemplate which allows you to give a fallback option, which can produce the value for a key if it is missing.

applySelf :: Page String -> Page String Source

Apply a page as it's own template. This is often very useful to fill in certain keys like $root and $url.

templateCompiler :: Compiler Resource Template Source

Read a template. If the extension of the file we're compiling is .hml or .hamlet, it will be considered as a Hamlet template, and parsed as such.

templateCompilerWith :: HamletSettings -> Compiler Resource Template Source

Version of templateCompiler that enables custom settings.

applyTemplateCompiler Source

Arguments

:: Identifier Template	Template
-> Compiler (Page String) (Page String)	Compiler

applyTemplateCompilerWith :: (String -> String) -> Identifier Template -> Compiler (Page String) (Page String)Source

A version of applyTemplateCompiler which allows you to pass a function which is called for a key when it is missing.