Evaluate each of the bindings in a compiled PureScript module, and store the evaluated values in the environment, without evaluating any main expression.

Create an environment from a Haskell value.

It is recommended that a type annotation is given for the type of the value being provided.

For example:

builtIn (ModuleName Main) "greeting" ("Hello, World!" :: Text)
builtIn (ModuleName Main) "somePrimes" ([2, 3, 5, 7, 11] :: Vector Integer)

Functions can be provided as built-ins, but the EvalT monad needs to be used to wrap any outputs (or values in positive position):

builtIn (ModuleName Main) "strip" ((pure . Text.strip) :: Text -> EvalT m Text)
builtIn (ModuleName Main) "map" (traverse :: (Value -> EvalT m Value) -> Vector Value -> EvalT m (Vector Value))

Polymorphic functions can also be provided as built-ins, but values with polymoprhic types will need to be passed across the FFI boundary with monomorphic types. The type Value can always be used to represent values of unknown or polymorphic type, as in the map example above.

Evaluate a PureScript CoreFn expression in the given environment.

Note: it should not be necessary to call this function directly in most circumstances. It is provided as a helper function, for some more advanced use cases, such as setting up a custom environment.

Apply a value which represents an unevaluated closure to an argument.

Values which can be communicated across the FFI boundary from Haskell to PureScript.

Instances should identify and document any valid representations as a subset of the semantic domain Value. Such a subset can be identified by an injective function toValue, and a partial inverse, fromValue, defined on the image of toValue.

Laws:

fromValue . toValue = pure

ToValue should support functions with types such as

a -> EvalT m b
a -> b -> EvalT m c
a -> b -> c -> EvalT m d
(a -> EvalT m b) -> EvalT m c
(a -> b -> EvalT m c) -> EvalT m d

Note that every type in a return position is wrapped in the EvalT monad transformer. This is because evaluation in general may result in errors. However, a naive translation would result in too many applications of EvalT.

Specifically, we do not want to require types such as these, in which EvalT appears on the right hand side of every function arrow:

a -> EvalT m b (b -> EvalT m c)
a -> EvalT m b (b -> EvalT m (c -> EvalT m d))

For this reason, the ToValue instance for functions delegates to this type class for the type on the right hand side of the function. It skips the application of EvalT for nested function types.

Options for customizing generic deriving of record instances

• Maps Haskell field names to PureScript field names, unmodified.

Derived toValue function for Haskell record types which should map to corresponding PureScript record types.

Derived fromValue function for Haskell record types which should map to corresponding PureScript record types.

This class is used in the default instance for ToValue, via generic deriving, in order to identify a Haskell record type (with a single data constructor and named fields) with values in the semantic domain corresponding to a PureScript record type with the same field names.