Import

Resolve all imports within an expression

See load.

Resolve all imports within an expression, importing relative to the given directory.

See loadRelativeTo.

Generalized version of load

You can configure the desired behavior through the initial Status that you supply

Construct the file path corresponding to a local import. If the import is _relative_ then the resulting path is also relative.

Hash a fully resolved expression

Convenience utility to hash a fully resolved expression and return the base-16 encoded hash with the sha256: prefix

In other words, the output of this function can be pasted into Dhall source code to add an integrity check to an import

Ensure that the given expression is present in the semantic cache. The given expression should be alpha-beta-normal.

Assert than an expression is import-free

Shared state for HTTP requests

The default HTTP Manager

Used internally to track whether or not we've already warned the user about caching issues

State threaded throughout the import process

This enables or disables the semantic cache for imports protected by integrity checks

A fully "chained" import, i.e. if it contains a relative path that path is relative to the current directory. If it is a remote import with headers those are well-typed (either of type `List { header : Text, value Text}` or `List { mapKey : Text, mapValue Text})` and in normal form. These invariants are preserved by the API exposed by Dhall.Import.

The underlying import

Given a Local import construct the corresponding unhashed Chained import (interpreting relative path as relative to the current directory).

Adjust the import mode of a chained import

Default starting Status, importing relative to the given directory.

See emptyStatus

Load headers only from the environment (used in tests)

See emptyStatus.

Default Status appropriate for a server interpreting Dhall code

Using this Status ensures that interpreted Dhall code cannot access server-local resources (like files or environment variables)

See remoteStatus

Fetch the text contents of a URL

Lens from a Status to its _stack field

Lens from a Status to its _cache field

parent imports (i.e. depends on) child

Lens from a Status to its _graph field

Lens from a Status to its _remote field

Given a well-typed (of type `List { header : Text, value Text }` or `List { mapKey : Text, mapValue Text }`) headers expressions in normal form construct the corresponding binary http headers; otherwise return the empty list.

Lens from a Status to its _substitutions field

Lens from a Status to its _normalizer field

Lens from a Status to its _startingContext field

Chain imports, also typecheck and normalize headers if applicable.

This function is used by the --transitive option of the dhall {freeze,format,lint} subcommands to determine which dependencies to descend into

>>> dependencyToFile (emptyStatus ".") Import{ importHashed = ImportHashed{ hash = Nothing, importType = Local Here (File (Directory []) "foo") }, importMode = Code }
Just "./foo"

>>> dependencyToFile (emptyStatus "./foo") Import{ importHashed = ImportHashed{ hash = Nothing, importType = Local Here (File (Directory []) "bar") }, importMode = Code }
Just "./foo/bar"

>>> dependencyToFile (emptyStatus "./foo") Import{ importHashed = ImportHashed{ hash = Nothing, importType = Remote (URL HTTPS "example.com" (File (Directory []) "") Nothing Nothing) }, importMode = Code }
Nothing

>>> dependencyToFile (emptyStatus ".") Import{ importHashed = ImportHashed{ hash = Nothing, importType = Env "foo" }, importMode = Code }
Nothing

An import that has been fully interpeted

HTTP headers

An import failed because of a cycle in the import graph

Dhall tries to ensure that all expressions hosted on network endpoints are weakly referentially transparent, meaning roughly that any two clients will compile the exact same result given the same URL.

To be precise, a strong interpretaton of referential transparency means that if you compiled a URL you could replace the expression hosted at that URL with the compiled result. Let's call this "static linking". Dhall (very intentionally) does not satisfy this stronger interpretation of referential transparency since "statically linking" an expression (i.e. permanently resolving all imports) means that the expression will no longer update if its dependencies change.

In general, either interpretation of referential transparency is not enforceable in a networked context since one can easily violate referential transparency with a custom DNS, but Dhall can still try to guard against common unintentional violations. To do this, Dhall enforces that a non-local import may not reference a local import.

Local imports are defined as:

• A file
• A URL with a host of localhost or 127.0.0.1

All other imports are defined to be non-local

Extend another exception with the current import stack

A call to assertNoImports failed because there was at least one import

Wrapper around HttpExceptions with a prettier Show instance

In order to keep the library API constant even when the with-http Cabal flag is disabled the pretty error message is pre-rendered and the real HttpException is stored in a Dynamic

Exception thrown when an imported file is missing

Exception thrown when an environment variable is missing

List of Exceptions we encounter while resolving Import Alternatives

Exception thrown when an integrity check fails