Nix.Value

An NValueF p m r represents all the possible types of Nix values.

Is is the base functor to form the Free monad of nix expressions. The parameter r represents Nix values in their final form (NValue). The parameter p represents exactly the same type, but is kept separate or it would prevent NValueF from being a proper functor. It is intended to be hard-coded to the same final type as r. m is the monad in which evaluations will run.

An NValue' t f m a is a magic layer between NValueF and the Free monad construction.

It fixes the p parameter of NValueF to the final NValue type, making the definition of NValue' and NValue depend on each other in a recursive fashion.

It also introduces a f parameter for a custom functor that can be used to wrap each intermediate value in the reduced expression tree. This is where expression evaluations can store annotations and other useful information.

t is not really used here, but is needed to type the (NValue t f m) used to tie the knot of the p parameter in the inner NValueF.

a is will be an `NValue t f m` when NValue' functor is turned into a Free monad.

'NValue t f m' is the most reduced form of a NExpr after evaluation is completed. It is a layer cake of NValueF base values, wrapped in the f functor and into the Free recursive construction.

Concretely, an NValue t f m can either be a thunk, representing a value yet to be evaluated (Pure t), or a know value in WHNF (Free (NValue' t f m (NValue t f m))) = (Free (f (NValueF NValue m NValue)) That is, a base value type, wrapped into the generic f functor, and based on other NValue's, which can in turn be either thunks, or more already WHNF evaluated values.

As an example, the value `[1]` will be represented as

Free (f (NVListF [ (Free (f (NVConstantF (NInt 1)))) ]))

Should this 1 be a laziy and yet unevaluated value, it would be represented as

Free (f (NVListF [ (Pure t) ]))

Where the t is evaluator dependant, and should contain anough information to be evaluated to an NValue when needed. demand of force are used to turn a potential thunk into a `m (NValue t f m)`.

Of course, trees can be much bigger.

The number of layers and type aliases for similar things is huge, so this module provides ViewPatterns for each NValueF constructor.

For example, the pattern NVStr' ns matches a NValue' containing an NVStrF, and bind that NVStrF to ns, ignoring the f functor inside. Similarly, the pattern NVStr ns (without prime mark) will match the inner NVstrF value inside an NValue. Of course, the patterns are declined for all the NValueF constructors. The non primed version also has an NVThunk t pattern to account for the possibility of an NValue to no be fully evaluated yet, as opposed to an NValue'.

NVConstraint constraint the f layer in NValue'. It makes bijection between sub category of Hask and Nix Value possible. Comonad enable Nix Value to Hask part. Applicative enable Hask to Nix Value part.

At the time of constructor, the expected arguments to closures are values that may contain thunks. The type of such thunks are fixed at that time.

'NValue t f m' is a value in head normal form (it means only the tip of it has been evaluated to the normal form, while the rest of it is in lazy not evaluated form (thunk), this known as WHNF).

An action 'm (NValue t f m)' is a pending evaluation that has yet to be performed.

An t is either: * a pending evaluation. * a value in head normal form.

The Free structure is used here to represent the possibility that Nix language allows cycles that may appear during normalization.

Determine type of a value

Describe type value

Make traversals for Nix traversable structures.

Make lenses for the Nix values

Lens-generated getter-setter function for a traversable NValue' key-val structures. Nix value analogue of the Data-Aeson-Lens:key :: AsValue t => Text -> Traversal' t Value.