Call a function by its name, similar to funcallPrimitive.

Call a function by its name, similar to funcallPrimitiveUnchecked.

Call a function by its name and ignore its result, similar to funcallPrimitiveSym.

Assign a name to function value.

Signal to Emacs that certain feature is being provided. Returns provided symbol.

Pack a stable pointer as Emacs user_ptr.

Try to obtain an Int from Emacs value.

This function will fail if Emacs value is not an integer or contains value too big to fit into Int on current architecture.

Pack an Int integer for Emacs.

Convert a Text into an Emacs string value.

Convert a ShortByteString into an Emacs string value.

Extract a boolean from an Emacs value.

Convert a Bool into an Emacs string value.

Get all elements form an Emacs vector.

Get all elements form an Emacs vector.

Get all elements form an Emacs vector.

Create an Emacs vector.

Concatenate two vectors.

Make a cons pair out of two values.

Take first element of a pair.

Take second element of a pair.

A nil symbol aka empty list.

Mutate first element of a cons pair.

Mutate second element of a cons pair.

Construct vanilla Emacs list from a Haskell list.

Extract vanilla Emacs list as Haskell list.

Extract vanilla Emacs list as a Haskell list.

Fold Emacs list starting from the left.

Fold Emacs list starting from the left.

Add new 'face property to a string.

Add new 'face property to a string.

Concatenate two strings.

Convert an Emacs value into a string using prin1-to-string.

Wrapper around Emacs symbol-name function - take a symbol and produce an Emacs string with its textual name.

A class for monads which provide for the ability to account for all possible exit points from a computation, and to mask asynchronous exceptions. Continuation-based monads are invalid instances of this class.

Instances should ensure that, in the following code:

fg = f `finally` g

The action g is called regardless of what occurs within f, including async exceptions. Some monads allow f to abort the computation via other effects than throwing an exception. For simplicity, we will consider aborting and throwing an exception to be two forms of "throwing an error".

If f and g both throw an error, the error thrown by fg depends on which errors we're talking about. In a monad transformer stack, the deeper layers override the effects of the inner layers; for example, ExceptT e1 (Except e2) a represents a value of type Either e2 (Either e1 a), so throwing both an e1 and an e2 will result in Left e2. If f and g both throw an error from the same layer, instances should ensure that the error from g wins.

Effects other than throwing an error are also overridden by the deeper layers. For example, StateT s Maybe a represents a value of type s -> Maybe (a, s), so if an error thrown from f causes this function to return Nothing, any changes to the state which f also performed will be erased. As a result, g will see the state as it was before f. Once g completes, f's error will be rethrown, so g' state changes will be erased as well. This is the normal interaction between effects in a monad transformer stack.

By contrast, lifted-base's version of finally always discards all of g's non-IO effects, and g never sees any of f's non-IO effects, regardless of the layer ordering and regardless of whether f throws an error. This is not the result of interacting effects, but a consequence of MonadBaseControl's approach.