Function to retrieve a value from Lua's stack.

Runs the peeker function.

Record to keep track of failure contexts while retrieving objects from the Lua stack.

Force creation of an unwrapped result, throwing an exception if that's not possible.

Add context information to the peek traceback stack.

Create a peek failure record from an error message.

Converts a Result into an Either, where Left holds the reportable string in case of an failure.

Succeeds if the value at the given index is nil.

Succeeds if the given index is not valid or if the value at this index is nil.

Retrieves a Bool as a Lua boolean.

Retrieves an Integral value from the Lua stack.

Retrieve a RealFloat (e.g., Float or Double) from the stack.

Retrieves a ByteString as a raw string.

Retrieves a lazy ByteString as a raw string.

Retrieves a String from an UTF-8 encoded Lua string.

Retrieves a Text value as an UTF-8 encoded string.

Retrieves a String-like value from an UTF-8 encoded Lua string.

This should not be used to peek ByteString values or other values for which construction via fromString can result in loss of information.

Retrieves a Lua string as Name.

Retrieves a value by getting a String from Lua, then using readMaybe to convert the String into a Haskell value.

Read a table into a list of pairs.

Reads a numerically indexed table t into a list, where the length of the list is equal to rawlen(t). The operation will fail unless all numerical fields between 1 and rawlen(t) can be retrieved.

Retrieves a key-value Lua table as Map.

Retrieves a Set from an idiomatic Lua representation. A set in Lua is idiomatically represented as a table with the elements as keys. Elements with falsy values are omitted.

Try all peekers and return the result of the first to succeed.

Get value at key from a table.

Retrieves a value pair from a table. Expects the values to be stored in a numerically indexed table; does not access metamethods.

Retrieves a value triple from a table. Expects the values to be stored in a numerically indexed table, with no metamethods.

Lua operation with an additional failure mode that can stack errors from different contexts; errors are not based on exceptions).

Converts a Peek action into a LuaE action, throwing an exception in case of a peek failure.

Lifts a Lua operation into the Peek monad.

Transform the result using the given function.

Fails the peek operation.

Runs the peek action and Lua action in sequence, even if the peek action fails.

Runs the peek action, resetting the stack top afterwards. This can be used with peek actions that might otherwise leave elements on the stack in case of a failure.

Use test to check whether the value at stack index n has the correct type and use peekfn to convert it to a Haskell value if possible. A successfully received value is wrapped using the Right constructor, while a type mismatch results in Left PeekError with the given error message.

Generate a type mismatch error.

Report the expected and actual type of the value under the given index if conversion failed.

Pushes three values to the stack that can be used in a generic for loop to lazily iterate over all values in the list. Keeps the remaining list in a userdata state.

If the values pusher function returns NumResults 0 for a list item, then this item will be skipped and the values for the next item will be pushed.