Newtype wrapper over Expr Src a (A Dhall expression) with an appropriate Binary instance, meant to be usable as a compilable Hakyll result that can be saved with saveSnapshot, load, etc.

Compile the underlying text file as a Dhall expression, wrapped in a DExpr newtype. Mostly useful for pre-cacheing fully resolved Dhall expressions into the Hakyll cache, which you can later interpret and load with loadDhall or loadDhallSnapshot. A DExpr a is an Expr Src a, but wrapped so that it has a Binary instance that is usable by the Hakyll cache. Tracks all dependencies, so will trigger rebuilds of items that depend on it if any downstream dhall files are modified.

For example, here is a rule to parse and cache all Dhall files in the directory ./config:

match "config/**.dhall" $ do
    route mempty
    compile $ dExprCompiler @Void

This will save all of the dhall files in the directory ./config in the Hakyll cache. They can later be loaded and interpreted in the Compiler monad using:

loadDhall auto "config/my_config.dhall"

This is mostly useful for routes that match many different files which will be interpreted as values of different types, or for caching a single expression that you might want to interpret as different types later. If you want to parse and immediately interpret, see dhallCompiler.

_Note:_ If the a is not inferrable by type inference (like in the situation above), you can specify the a using type application syntax (like above).

_Note:_ This isn't really meant to be a "final end-point", but if it is used as such, a pretty-printed version will be rendered to the output directory, based on the Writable instance of DExpr.

dExprCompiler, but with custom DhallCompilerOptions.

Wrapper over load and interpretDhallCompiler. Pulls up a DExpr compiled or saved into the Hakyll cache and interprets it as a value.

Expects item at identifier to be saved as DExpr Void (possibly using dExprCompiler @Void)

Tracks dependencies properly, so any pages or routes that use the saved Dhall expression will re-build if any of the downstream Dhall files are edited.

Wrapper over loadSnapshot and interpretDhallCompiler. Pulls up a DExpr saved into the Hakyll cache as a snapshot and interprets it as a value.

Expects item at identifier to be saved as DExpr Void (possibly using dExprCompiler @Void)

Tracks dependencies properly, so any pages or routes that use the saved Dhall expression will re-build if any of the downstream Dhall files are edited.

Parse the underlying text file as a Dhall expression and directly interpret it as a value of the given type. Tracks all dependencies, so will trigger rebuilds based on downstream changes.

dhallCompiler, but with custom DhallCompilerOptions.

Parse a Dhall source. Meant to be useful for patterns similar to dhall-to-text. If using examples from https://github.com/dhall-lang/dhall-text, you can use:

parseDhallExpr Nothing "./make-items ./people"

Any local dependencies within the project directory (./make-items and ./people above, for example) are tracked by Hakyll, and so modifications to required files will also cause upstream files to be rebuilt.

To directly obtain a Dhall expression, see parseDhallExpr.

Version of parseDhall taking custom DhallCompilerOptions.

Version of parseDhall that directly returns a Dhall expression, instead of trying to interpret it into a custom Haskell type.

Any local dependencies within the project directory (./make-items and ./people above, for example) are tracked by Hakyll, and so modifications to required files will also cause upstream files to be rebuilt.

Version of parseDhallExpr taking custom DhallCompilerOptions.

Essentially a Dhall pretty-printer, (optional) normalizer, and re-formatter. Compile the Dhall file as text according to default DhallCompilerOptions. Note that this is polymorphic over both "raw" and "fully resolved" versions; it must be called with TypeApplications.

dhallRawPrettyCompiler  = dhallPrettyCompiler @Import
dhallFullPrettyCompiler = dhallPrettyCompiler @Void

It might be more convenient to just use dhallRawCompiler or dhallFullCompiler.

Compile the Dhall file as text according to default DhallCompilerOptions while leaving all imports unchanged and unresolved. Essentially a Dhall pretty-printer, (optional) normalizer, and re-formatter.

Compile the Dhall file as text according to default DhallCompilerOptions, resolving all imports in IO and tracking dependencies. Essentially a Dhall pretty-printer, (optional) normalizer, and re-formatter.

dhallPrettyCompiler, but with custom DhallCompilerOptions.

Format and pretty-print an Expr according to options in a given DhallCompilerOptions.

Options for loading Dhall files.

Types of external imports that a Dhall file may have.

Default DhallCompilerOptions. If the type variable is not inferrable, it can be helpful to use TypeApplications syntax:

defaultDhallCompilerOptions @Import     -- do not resolve imports
defaultDhallCompilerOptions @Void          -- resolve imports

Default values are:

DCO
  { _dcoResolver  = defaultDhallResolver
  , _dcoMinimize  = False
  , _dcoNormalize = True
  }

Method for resolving imports.

The choice will determine the type of expression that loadDhallExpr and family will produce.

Note that at this moment, the only available options are "all or nothing" --- either resolve all types imports completely and fully, or none of them. Hopefully one day this library will offer the ability to resolve only certain types of imports (environment variables, absolute paths) and not others (remote network, local paths).

Helper typeclass to allow functions to be polymorphic over different DhallResolver types.

Provides default behavior for each resolver type.

Lens for _drRemap field of DhallResolver.

Lens for _drFull field of DhallResolver.

Interpret a fully resolved Dhall expression as a value of a type, given a Decoder. You can use this to integrate error handling with Hakyll, since it is run in a Compiler.

Version of parseDhallExprWith that only acceps the DRRaw resolver, remapping the imports with the function in the DRRaw. Does not perform any normalization.

Resolve all imports in a parsed Dhall expression.

This implements the "magic" of dependency tracking: implemented so that any local dependencies within the project directory are tracked by Hakyll, and so modifications to required files will also cause upstream files to be rebuilt.