Dhall.Marshal.Encode

An (Encoder a) represents a way to marshal a value of type 'a' from Haskell into Dhall.

This class is used by FromDhall instance for functions:

instance (ToDhall a, FromDhall b) => FromDhall (a -> b)

You can convert Dhall functions with "simple" inputs (i.e. instances of this class) into Haskell functions. This works by:

• Marshaling the input to the Haskell function into a Dhall expression (i.e. x :: Expr Src Void)

• Applying the Dhall function (i.e. f :: Expr Src Void) to the Dhall input (i.e. App f x)

• Normalizing the syntax tree (i.e. normalize (App f x))

• Marshaling the resulting Dhall expression back into a Haskell value

This class auto-generates a default implementation for types that implement Generic. This does not auto-generate an instance for recursive types.

The default instance can be tweaked using genericToDhallWith/genericToDhallWithInputNormalizer and custom InterpretOptions, or using DerivingVia and Codec from Dhall.Deriving.

A compatibility alias for ToDhall

Use the default input normalizer for injecting a value.

inject = injectWith defaultInputNormalizer

This is the underlying class that powers the FromDhall class's support for automatically deriving a generic implementation.

Use the default options for injecting a value, whose structure is determined generically.

This can be used when you want to use ToDhall on types that you don't want to define orphan instances for.

Use custom options for injecting a value, whose structure is determined generically.

This can be used when you want to use ToDhall on types that you don't want to define orphan instances for.

genericToDhallWithInputNormalizer is like genericToDhallWith, but instead of using the defaultInputNormalizer it expects an custom InputNormalizer.

Use these options to tweak how Dhall derives a generic implementation of FromDhall.

This type specifies how to model a Haskell constructor with 1 field in Dhall

For example, consider the following Haskell datatype definition:

data Example = Foo { x :: Double } | Bar Double

Depending on which option you pick, the corresponding Dhall type could be:

< Foo : Double | Bar : Double >                   -- Bare

< Foo : { x : Double } | Bar : { _1 : Double } >  -- Wrapped

< Foo : { x : Double } | Bar : Double >           -- Smart

Default interpret options for generics-based instances, which you can tweak or override, like this:

genericAutoWith
    (defaultInterpretOptions { fieldModifier = Data.Text.Lazy.dropWhile (== '_') })

This is only used by the FromDhall instance for functions in order to normalize the function input before marshaling the input into a Dhall expression.

Default normalization-related settings (no custom normalization)

This type is exactly the same as Fix except with a different FromDhall instance. This intermediate type simplifies the implementation of the inner loop for the FromDhall instance for Fix.

This is an infix alias for contramap.

Infix divided

Natural number

Invariant: numbers <= 0xffffffffffffffff use the NS constructor

General-purpose finite sequences.

A space efficient, packed, unboxed Unicode text type.

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ Prelude.id
to . from ≡ Prelude.id