Hakyll.Core.Compiler.Internal

Internally used compiler module

Types

type Snapshot = String

Whilst compiling an item, it possible to save multiple snapshots of it, and not just the final result.

data CompilerRead

Environment in which a compiler runs

Constructors

CompilerRead

Fields

• compilerConfig :: Configuration

  Main configuration

• compilerUnderlying :: Identifier

  Underlying identifier

• compilerProvider :: Provider

  Resource provider

• compilerUniverse :: Set Identifier

  List of all known identifiers

• compilerRoutes :: Routes

  Site routes

• compilerStore :: Store

  Compiler store

• compilerLogger :: Logger

  Logger

data CompilerWrite

Constructors

CompilerWrite

Fields

• compilerDependencies :: [Dependency]
• compilerCacheHits :: Int

Instances

Show CompilerWrite

Defined in Hakyll.Core.Compiler.Internal

Methods

showsPrec :: Int -> CompilerWrite -> ShowS

show :: CompilerWrite -> String

showList :: [CompilerWrite] -> ShowS

Semigroup CompilerWrite

Defined in Hakyll.Core.Compiler.Internal

Methods

(<>) :: CompilerWrite -> CompilerWrite -> CompilerWrite

sconcat :: NonEmpty CompilerWrite -> CompilerWrite

stimes :: Integral b => b -> CompilerWrite -> CompilerWrite

Monoid CompilerWrite

Defined in Hakyll.Core.Compiler.Internal

Methods

mempty :: CompilerWrite

mappend :: CompilerWrite -> CompilerWrite -> CompilerWrite

mconcat :: [CompilerWrite] -> CompilerWrite

data CompilerErrors a

Distinguishes reasons in a CompilerError

Constructors

CompilationFailure (NonEmpty a)

One or more exceptions occured during compilation

CompilationNoResult [a]

Absence of any result, most notably in template contexts. May still have error messages.

Instances

Functor CompilerErrors

Defined in Hakyll.Core.Compiler.Internal

Methods

fmap :: (a -> b) -> CompilerErrors a -> CompilerErrors b

(<$) :: a -> CompilerErrors b -> CompilerErrors a

data CompilerResult a

An intermediate result of a compilation step

Constructors

CompilerDone a CompilerWrite

CompilerSnapshot Snapshot (Compiler a)

CompilerRequire [(Identifier, Snapshot)] (Compiler a)

CompilerError (CompilerErrors String)

newtype Compiler a

A monad which lets you compile items and takes care of dependency tracking for you.

Constructors

Compiler

Fields

• unCompiler :: CompilerRead -> IO (CompilerResult a)

Instances

Monad Compiler

Defined in Hakyll.Core.Compiler.Internal

Methods

(>>=) :: Compiler a -> (a -> Compiler b) -> Compiler b

(>>) :: Compiler a -> Compiler b -> Compiler b

return :: a -> Compiler a

Functor Compiler

Defined in Hakyll.Core.Compiler.Internal

Methods

fmap :: (a -> b) -> Compiler a -> Compiler b

(<$) :: a -> Compiler b -> Compiler a

MonadFail Compiler

Defined in Hakyll.Core.Compiler.Internal

Methods

fail :: String -> Compiler a

Applicative Compiler

Defined in Hakyll.Core.Compiler.Internal

Methods

pure :: a -> Compiler a

(<*>) :: Compiler (a -> b) -> Compiler a -> Compiler b

liftA2 :: (a -> b -> c) -> Compiler a -> Compiler b -> Compiler c

(*>) :: Compiler a -> Compiler b -> Compiler b

(<*) :: Compiler a -> Compiler b -> Compiler a

Alternative Compiler

Trying alternative compilers if the first fails, regardless whether through fail, throwError or noResult. Aggregates error messages if all fail.

Defined in Hakyll.Core.Compiler.Internal

Methods

empty :: Compiler a

(<|>) :: Compiler a -> Compiler a -> Compiler a

some :: Compiler a -> Compiler [a]

many :: Compiler a -> Compiler [a]

MonadMetadata Compiler

Access provided metadata from anywhere

Defined in Hakyll.Core.Compiler.Internal

Methods

getMetadata :: Identifier -> Compiler Metadata

getMatches :: Pattern -> Compiler [Identifier]

getAllMetadata :: Pattern -> Compiler [(Identifier, Metadata)]

MonadError [String] Compiler

Compilation may fail with multiple error messages. catchError handles errors from throwError, fail and noResult

Defined in Hakyll.Core.Compiler.Internal

Methods

throwError :: [String] -> Compiler a

catchError :: Compiler a -> ([String] -> Compiler a) -> Compiler a

runCompiler :: Compiler a -> CompilerRead -> IO (CompilerResult a)

Like unCompiler but treating IO exceptions as CompilerErrors

Core operations

compilerResult :: CompilerResult a -> Compiler a

Put the result back in a compiler

compilerTell :: CompilerWrite -> Compiler ()

Put a CompilerWrite

compilerAsk :: Compiler CompilerRead

Get the current environment

compilerUnsafeIO :: IO a -> Compiler a

Run an IO computation without dependencies in a Compiler

Error operations

compilerThrow :: [String] -> Compiler a

Throw errors in the Compiler.

If no messages are given, this is considered a CompilationNoResult error. Otherwise, it is treated as a proper compilation failure.

compilerNoResult :: [String] -> Compiler a

Put a CompilerError with multiple messages as CompilationNoResult

compilerCatch :: Compiler a -> (CompilerErrors String -> Compiler a) -> Compiler a

Allows you to recover from CompilerErrors. Uses the same parameter order as catchError so that it can be used infix.

c `compilerCatch` f = compilerTry c >>= either f return

compilerTry :: Compiler a -> Compiler (Either (CompilerErrors String) a)

Allows to distinguish CompilerErrors and branch on them with Either

compilerTry = (`compilerCatch` return . Left) . fmap Right

compilerErrorMessages :: CompilerErrors a -> [a]

Unwrap a CompilerErrors

Utilities

compilerDebugEntries :: String -> [String] -> Compiler ()

Pass a list of messages with a heading to the debug logger

compilerTellDependencies :: [Dependency] -> Compiler ()

compilerTellCacheHits :: Int -> Compiler ()