Safe Haskell	None
Language	Haskell2010

Hakyll.Core.Rules

Contents

Advanced usage

Description

This module provides a declarative DSL in which the user can specify the different rules used to run the compilers.

The convention is to just list all items in the Rules monad, routes and compilation rules.

A typical usage example would be:

main = hakyll $ do
    match "posts/*" $ do
        route   (setExtension "html")
        compile someCompiler
    match "css/*" $ do
        route   idRoute
        compile compressCssCompiler

Synopsis

data Rules a
match :: Pattern -> Rules () -> Rules ()
matchMetadata :: Pattern -> (Metadata -> Bool) -> Rules () -> Rules ()
create :: [Identifier] -> Rules () -> Rules ()
version :: String -> Rules () -> Rules ()
compile :: (Binary a, Typeable a, Writable a) => Compiler (Item a) -> Rules ()
route :: Routes -> Rules ()
preprocess :: IO a -> Rules a
data Dependency
rulesExtraDependencies :: [Dependency] -> Rules a -> Rules a
forceCompile :: Rules a -> Rules a

Documentation

data Rules a Source #

The monad used to compose rules

Instances

Instances details

Monad Rules Source #
Instance details Defined in Hakyll.Core.Rules.Internal Methods (>>=) :: Rules a -> (a -> Rules b) -> Rules b # (>>) :: Rules a -> Rules b -> Rules b # return :: a -> Rules a #
Functor Rules Source #
Instance details Defined in Hakyll.Core.Rules.Internal Methods fmap :: (a -> b) -> Rules a -> Rules b # (<$) :: a -> Rules b -> Rules a #
MonadFail Rules Source #
Instance details Defined in Hakyll.Core.Rules.Internal Methods fail :: String -> Rules a #
Applicative Rules Source #
Instance details Defined in Hakyll.Core.Rules.Internal Methods pure :: a -> Rules a # (<>) :: Rules (a -> b) -> Rules a -> Rules b # liftA2 :: (a -> b -> c) -> Rules a -> Rules b -> Rules c # (>) :: Rules a -> Rules b -> Rules b # (<*) :: Rules a -> Rules b -> Rules a #
MonadMetadata Rules Source #
Instance details Defined in Hakyll.Core.Rules.Internal Methods getMetadata :: Identifier -> Rules Metadata Source # getMatches :: Pattern -> Rules [Identifier] Source # getAllMetadata :: Pattern -> Rules [(Identifier, Metadata)] Source #

match :: Pattern -> Rules () -> Rules () Source #

matchMetadata :: Pattern -> (Metadata -> Bool) -> Rules () -> Rules () Source #

create :: [Identifier] -> Rules () -> Rules () Source #

version :: String -> Rules () -> Rules () Source #

compile :: (Binary a, Typeable a, Writable a) => Compiler (Item a) -> Rules () Source #

Add a compilation rule to the rules.

This instructs all resources to be compiled using the given compiler.

route :: Routes -> Rules () Source #

Add a route.

This adds a route for all items matching the current pattern.

Advanced usage

preprocess :: IO a -> Rules a Source #

Execute an IO action immediately while the rules are being evaluated. This should be avoided if possible, but occasionally comes in useful.

data Dependency Source #

Constructors

PatternDependency Pattern (Set Identifier)
IdentifierDependency Identifier
AlwaysOutOfDate

Instances

Instances details

Show Dependency Source #
Instance details Defined in Hakyll.Core.Dependencies Methods showsPrec :: Int -> Dependency -> ShowS # show :: Dependency -> String # showList :: [Dependency] -> ShowS #
Binary Dependency Source #
Instance details Defined in Hakyll.Core.Dependencies Methods put :: Dependency -> Put # get :: Get Dependency # putList :: [Dependency] -> Put #

rulesExtraDependencies :: [Dependency] -> Rules a -> Rules a Source #

Advanced usage: add extra dependencies to compilers. Basically this is needed when you're doing unsafe tricky stuff in the rules monad, but you still want correct builds.

A useful utility for this purpose is makePatternDependency.

forceCompile :: Rules a -> Rules a Source #

Force the item(s) to always be recompiled, whether or not the dependencies are out of date. This can be useful if you are using I/O to generate part (or all) of an item.