Assign a name to function value.

Make Haskell function available as an anonymoucs Emacs function. In order to be able to use it later from Emacs it should be fed into bindFunction.

This is a simplified version of makeFunctionExtra.

Feed a value into a function and clean it up afterwards.

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.

Extract string contents as Text from an Emacs value.

Convert a Text into an Emacs string value.

Extract string contents as ShortByteString from an Emacs 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 using specific function to convert elements.

Get all elements form an Emacs vector using specific function to convert elements.

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.

Extract vanilla Emacs list as a reversed Haskell list. It's more efficient than extractList but doesn't preserve order of elements that was specified from Emacs side.

Fold Emacs list starting from the left.

Fold Emacs list starting from the left.

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 overriden 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.