Foreign.Lua.Core

Core Lua API. This module provides thin wrappers around the respective functions of the Lua C API. C function which can throw an error are wrapped such that the error is converted into an Exception. However, memory allocation errors are not caught and will cause the host program to terminate.

Lua Computations

newtype Lua a

A Lua computation. This is the base type used to run Lua programs of any kind. The Lua state is handled automatically, but can be retrieved via state.

Constructors

Lua

Fields

• unLua :: ReaderT State IO a

Instances

Monad Lua

Defined in Foreign.Lua.Core.Types

Methods

(>>=) :: Lua a -> (a -> Lua b) -> Lua b

(>>) :: Lua a -> Lua b -> Lua b

return :: a -> Lua a

fail :: String -> Lua a

Functor Lua

Defined in Foreign.Lua.Core.Types

Methods

fmap :: (a -> b) -> Lua a -> Lua b

(<$) :: a -> Lua b -> Lua a

Applicative Lua

Defined in Foreign.Lua.Core.Types

Methods

pure :: a -> Lua a

(<*>) :: Lua (a -> b) -> Lua a -> Lua b

liftA2 :: (a -> b -> c) -> Lua a -> Lua b -> Lua c

(*>) :: Lua a -> Lua b -> Lua b

(<*) :: Lua a -> Lua b -> Lua a

MonadIO Lua

Defined in Foreign.Lua.Core.Types

Methods

liftIO :: IO a -> Lua a

Alternative Lua

Defined in Foreign.Lua.Core.Error

Methods

empty :: Lua a

(<|>) :: Lua a -> Lua a -> Lua a

some :: Lua a -> Lua [a]

many :: Lua a -> Lua [a]

MonadThrow Lua

Defined in Foreign.Lua.Core.Types

Methods

throwM :: Exception e => e -> Lua a

MonadCatch Lua

Defined in Foreign.Lua.Core.Types

Methods

catch :: Exception e => Lua a -> (e -> Lua a) -> Lua a

MonadMask Lua

Defined in Foreign.Lua.Core.Types

Methods

mask :: ((forall a. Lua a -> Lua a) -> Lua b) -> Lua b

uninterruptibleMask :: ((forall a. Lua a -> Lua a) -> Lua b) -> Lua b

generalBracket :: Lua a -> (a -> ExitCase b -> Lua c) -> (a -> Lua b) -> Lua (b, c)

ToHaskellFunction HaskellFunction

Defined in Foreign.Lua.FunctionCalling

Methods

toHsFun :: StackIndex -> HaskellFunction -> Lua NumResults

MonadReader State Lua

Defined in Foreign.Lua.Core.Types

Methods

ask :: Lua State

local :: (State -> State) -> Lua a -> Lua a

reader :: (State -> a) -> Lua a

Peekable a => LuaCallFunc (Lua a)

Defined in Foreign.Lua.FunctionCalling

Methods

callFunc' :: String -> Lua () -> NumArgs -> Lua a

Pushable a => ToHaskellFunction (Lua a)

Defined in Foreign.Lua.FunctionCalling

Methods

toHsFun :: StackIndex -> Lua a -> Lua NumResults

runWith :: State -> Lua a -> IO a

Run lua computation with custom lua state. Errors are left unhandled, the caller of this function is responsible to catch lua errors.

liftIO :: MonadIO m => IO a -> m a

Lift a computation from the IO monad.

state :: Lua State

Get the lua state of this lua computation.

Lua API types

type CFunction = FunPtr (State -> IO NumResults)

Type for C functions.

In order to communicate properly with Lua, a C function must use the following protocol, which defines the way parameters and results are passed: a C function receives its arguments from Lua in its stack in direct order (the first argument is pushed first). So, when the function starts, gettop returns the number of arguments received by the function. The first argument (if any) is at index 1 and its last argument is at index gettop. To return values to Lua, a C function just pushes them onto the stack, in direct order (the first result is pushed first), and returns the number of results. Any other value in the stack below the results will be properly discarded by Lua. Like a Lua function, a C function called by Lua can also return many results.

See lua_CFunction.

newtype Integer

The type of integers in Lua.

By default this type is Int64, but that can be changed to different values in lua. (See LUA_INT_TYPE in luaconf.h.)

See lua_Integer.

Constructors

Integer Int64

Instances

Bounded Integer

Defined in Foreign.Lua.Core.Types

Methods

minBound :: Integer

maxBound :: Integer

Enum Integer

Defined in Foreign.Lua.Core.Types

Methods

succ :: Integer -> Integer

pred :: Integer -> Integer

toEnum :: Int -> Integer

fromEnum :: Integer -> Int

enumFrom :: Integer -> [Integer]

enumFromThen :: Integer -> Integer -> [Integer]

enumFromTo :: Integer -> Integer -> [Integer]

enumFromThenTo :: Integer -> Integer -> Integer -> [Integer]

Eq Integer

Defined in Foreign.Lua.Core.Types

Methods

(==) :: Integer -> Integer -> Bool

(/=) :: Integer -> Integer -> Bool

Integral Integer

Defined in Foreign.Lua.Core.Types

Methods

quot :: Integer -> Integer -> Integer

rem :: Integer -> Integer -> Integer

div :: Integer -> Integer -> Integer

mod :: Integer -> Integer -> Integer

quotRem :: Integer -> Integer -> (Integer, Integer)

divMod :: Integer -> Integer -> (Integer, Integer)

toInteger :: Integer -> Integer0

Num Integer

Defined in Foreign.Lua.Core.Types

Methods

(+) :: Integer -> Integer -> Integer

(-) :: Integer -> Integer -> Integer

(*) :: Integer -> Integer -> Integer

negate :: Integer -> Integer

abs :: Integer -> Integer

signum :: Integer -> Integer

fromInteger :: Integer0 -> Integer

Ord Integer

Defined in Foreign.Lua.Core.Types

Methods

compare :: Integer -> Integer -> Ordering

(<) :: Integer -> Integer -> Bool

(<=) :: Integer -> Integer -> Bool

(>) :: Integer -> Integer -> Bool

(>=) :: Integer -> Integer -> Bool

max :: Integer -> Integer -> Integer

min :: Integer -> Integer -> Integer

Real Integer

Defined in Foreign.Lua.Core.Types

Methods

toRational :: Integer -> Rational

Show Integer

Defined in Foreign.Lua.Core.Types

Methods

showsPrec :: Int -> Integer -> ShowS

show :: Integer -> String

showList :: [Integer] -> ShowS

Pushable Integer

Defined in Foreign.Lua.Types.Pushable

Methods

push :: Integer -> Lua ()

Peekable Integer

Defined in Foreign.Lua.Types.Peekable

Methods

peek :: StackIndex -> Lua Integer

newtype Number

The type of floats in Lua.

By default this type is Double, but that can be changed in Lua to a single float or a long double. (See LUA_FLOAT_TYPE in luaconf.h.)

See lua_Number.

Constructors

Number Double

Instances

Eq Number

Defined in Foreign.Lua.Core.Types

Methods

(==) :: Number -> Number -> Bool

(/=) :: Number -> Number -> Bool

Floating Number

Defined in Foreign.Lua.Core.Types

Methods

pi :: Number

exp :: Number -> Number

log :: Number -> Number

sqrt :: Number -> Number

(**) :: Number -> Number -> Number

logBase :: Number -> Number -> Number

sin :: Number -> Number

cos :: Number -> Number

tan :: Number -> Number

asin :: Number -> Number

acos :: Number -> Number

atan :: Number -> Number

sinh :: Number -> Number

cosh :: Number -> Number

tanh :: Number -> Number

asinh :: Number -> Number

acosh :: Number -> Number

atanh :: Number -> Number

log1p :: Number -> Number

expm1 :: Number -> Number

log1pexp :: Number -> Number

log1mexp :: Number -> Number

Fractional Number

Defined in Foreign.Lua.Core.Types

Methods

(/) :: Number -> Number -> Number

recip :: Number -> Number

fromRational :: Rational -> Number

Num Number

Defined in Foreign.Lua.Core.Types

Methods

(+) :: Number -> Number -> Number

(-) :: Number -> Number -> Number

(*) :: Number -> Number -> Number

negate :: Number -> Number

abs :: Number -> Number

signum :: Number -> Number

fromInteger :: Integer -> Number

Ord Number

Defined in Foreign.Lua.Core.Types

Methods

compare :: Number -> Number -> Ordering

(<) :: Number -> Number -> Bool

(<=) :: Number -> Number -> Bool

(>) :: Number -> Number -> Bool

(>=) :: Number -> Number -> Bool

max :: Number -> Number -> Number

min :: Number -> Number -> Number

Real Number

Defined in Foreign.Lua.Core.Types

Methods

toRational :: Number -> Rational

RealFloat Number

Defined in Foreign.Lua.Core.Types

Methods

floatRadix :: Number -> Integer

floatDigits :: Number -> Int

floatRange :: Number -> (Int, Int)

decodeFloat :: Number -> (Integer, Int)

encodeFloat :: Integer -> Int -> Number

exponent :: Number -> Int

significand :: Number -> Number

scaleFloat :: Int -> Number -> Number

isNaN :: Number -> Bool

isInfinite :: Number -> Bool

isDenormalized :: Number -> Bool

isNegativeZero :: Number -> Bool

isIEEE :: Number -> Bool

atan2 :: Number -> Number -> Number

RealFrac Number

Defined in Foreign.Lua.Core.Types

Methods

properFraction :: Integral b => Number -> (b, Number)

truncate :: Integral b => Number -> b

round :: Integral b => Number -> b

ceiling :: Integral b => Number -> b

floor :: Integral b => Number -> b

Show Number

Defined in Foreign.Lua.Core.Types

Methods

showsPrec :: Int -> Number -> ShowS

show :: Number -> String

showList :: [Number] -> ShowS

Pushable Number

Defined in Foreign.Lua.Types.Pushable

Methods

push :: Number -> Lua ()

Peekable Number

Defined in Foreign.Lua.Types.Peekable

Methods

peek :: StackIndex -> Lua Number

Stack index

newtype StackIndex

A stack index

Constructors

StackIndex

Fields

• fromStackIndex :: CInt

Instances

Enum StackIndex

Defined in Foreign.Lua.Core.Types

Methods

succ :: StackIndex -> StackIndex

pred :: StackIndex -> StackIndex

toEnum :: Int -> StackIndex

fromEnum :: StackIndex -> Int

enumFrom :: StackIndex -> [StackIndex]

enumFromThen :: StackIndex -> StackIndex -> [StackIndex]

enumFromTo :: StackIndex -> StackIndex -> [StackIndex]

enumFromThenTo :: StackIndex -> StackIndex -> StackIndex -> [StackIndex]

Eq StackIndex

Defined in Foreign.Lua.Core.Types

Methods

(==) :: StackIndex -> StackIndex -> Bool

(/=) :: StackIndex -> StackIndex -> Bool

Num StackIndex

Defined in Foreign.Lua.Core.Types

Methods

(+) :: StackIndex -> StackIndex -> StackIndex

(-) :: StackIndex -> StackIndex -> StackIndex

(*) :: StackIndex -> StackIndex -> StackIndex

negate :: StackIndex -> StackIndex

abs :: StackIndex -> StackIndex

signum :: StackIndex -> StackIndex

fromInteger :: Integer -> StackIndex

Ord StackIndex

Defined in Foreign.Lua.Core.Types

Methods

compare :: StackIndex -> StackIndex -> Ordering

(<) :: StackIndex -> StackIndex -> Bool

(<=) :: StackIndex -> StackIndex -> Bool

(>) :: StackIndex -> StackIndex -> Bool

(>=) :: StackIndex -> StackIndex -> Bool

max :: StackIndex -> StackIndex -> StackIndex

min :: StackIndex -> StackIndex -> StackIndex

Show StackIndex

Defined in Foreign.Lua.Core.Types

Methods

showsPrec :: Int -> StackIndex -> ShowS

show :: StackIndex -> String

showList :: [StackIndex] -> ShowS

nthFromBottom :: CInt -> StackIndex

Stack index of the nth element from the bottom of the stack.

nthFromTop :: CInt -> StackIndex

Stack index of the nth element from the top of the stack.

stackTop :: StackIndex

Top of the stack

stackBottom :: StackIndex

Bottom of the stack

Number of arguments and return values

newtype NumArgs

The number of arguments expected a function.

Constructors

NumArgs

Fields

• fromNumArgs :: CInt

Instances

Eq NumArgs

Defined in Foreign.Lua.Core.Types

Methods

(==) :: NumArgs -> NumArgs -> Bool

(/=) :: NumArgs -> NumArgs -> Bool

Num NumArgs

Defined in Foreign.Lua.Core.Types

Methods

(+) :: NumArgs -> NumArgs -> NumArgs

(-) :: NumArgs -> NumArgs -> NumArgs

(*) :: NumArgs -> NumArgs -> NumArgs

negate :: NumArgs -> NumArgs

abs :: NumArgs -> NumArgs

signum :: NumArgs -> NumArgs

fromInteger :: Integer -> NumArgs

Ord NumArgs

Defined in Foreign.Lua.Core.Types

Methods

compare :: NumArgs -> NumArgs -> Ordering

(<) :: NumArgs -> NumArgs -> Bool

(<=) :: NumArgs -> NumArgs -> Bool

(>) :: NumArgs -> NumArgs -> Bool

(>=) :: NumArgs -> NumArgs -> Bool

max :: NumArgs -> NumArgs -> NumArgs

min :: NumArgs -> NumArgs -> NumArgs

Show NumArgs

Defined in Foreign.Lua.Core.Types

Methods

showsPrec :: Int -> NumArgs -> ShowS

show :: NumArgs -> String

showList :: [NumArgs] -> ShowS

newtype NumResults

The number of results returned by a function call.

Constructors

NumResults

Fields

• fromNumResults :: CInt

Instances

Eq NumResults

Defined in Foreign.Lua.Core.Types

Methods

(==) :: NumResults -> NumResults -> Bool

(/=) :: NumResults -> NumResults -> Bool

Num NumResults

Defined in Foreign.Lua.Core.Types

Methods

(+) :: NumResults -> NumResults -> NumResults

(-) :: NumResults -> NumResults -> NumResults

(*) :: NumResults -> NumResults -> NumResults

negate :: NumResults -> NumResults

abs :: NumResults -> NumResults

signum :: NumResults -> NumResults

fromInteger :: Integer -> NumResults

Ord NumResults

Defined in Foreign.Lua.Core.Types

Methods

compare :: NumResults -> NumResults -> Ordering

(<) :: NumResults -> NumResults -> Bool

(<=) :: NumResults -> NumResults -> Bool

(>) :: NumResults -> NumResults -> Bool

(>=) :: NumResults -> NumResults -> Bool

max :: NumResults -> NumResults -> NumResults

min :: NumResults -> NumResults -> NumResults

Show NumResults

Defined in Foreign.Lua.Core.Types

Methods

showsPrec :: Int -> NumResults -> ShowS

show :: NumResults -> String

showList :: [NumResults] -> ShowS

Pushable CFunction

Defined in Foreign.Lua.Types.Pushable

Methods

push :: CFunction -> Lua ()

Peekable CFunction

Defined in Foreign.Lua.Types.Peekable

Methods

peek :: StackIndex -> Lua CFunction

ToHaskellFunction HaskellFunction

Defined in Foreign.Lua.FunctionCalling

Methods

toHsFun :: StackIndex -> HaskellFunction -> Lua NumResults

Lua API

Constants and pseudo-indices

multret :: NumResults

Alias for C constant LUA_MULTRET. See lua_call.

registryindex :: StackIndex

Alias for C constant LUA_REGISTRYINDEX. See Lua registry.

upvalueindex :: StackIndex -> StackIndex

Returns the pseudo-index that represents the i-th upvalue of the running function (see §4.4 of the Lua 5.3 reference manual).

See also: lua_upvalueindex.

State manipulation

newtype State

An opaque structure that points to a thread and indirectly (through the thread) to the whole state of a Lua interpreter. The Lua library is fully reentrant: it has no global variables. All information about a state is accessible through this structure.

Synonym for lua_State *. See lua_State.

Constructors

State (Ptr ())

Instances

Eq State

Defined in Foreign.Lua.Core.Types

Methods

(==) :: State -> State -> Bool

(/=) :: State -> State -> Bool

Generic State

Defined in Foreign.Lua.Core.Types

Associated Types

type Rep State :: * -> *

Methods

from :: State -> Rep State x

to :: Rep State x -> State

Pushable CFunction

Defined in Foreign.Lua.Types.Pushable

Methods

push :: CFunction -> Lua ()

Peekable CFunction

Defined in Foreign.Lua.Types.Peekable

Methods

peek :: StackIndex -> Lua CFunction

Peekable State

Defined in Foreign.Lua.Types.Peekable

Methods

peek :: StackIndex -> Lua State

MonadReader State Lua

Defined in Foreign.Lua.Core.Types

Methods

ask :: Lua State

local :: (State -> State) -> Lua a -> Lua a

reader :: (State -> a) -> Lua a

type Rep State

Defined in Foreign.Lua.Core.Types

type Rep State = D1 (MetaData "State" "Foreign.Lua.Core.Types" "hslua-1.0.1-8Cj9Opor1FiBQKiqjVcZgD" True) (C1 (MetaCons "State" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ptr ()))))

newstate :: IO State

Creates a new Lua state. It calls lua_newstate with an allocator based on the standard C realloc function and then sets a panic function (see §4.6 of the Lua 5.3 Reference Manual) that prints an error message to the standard error output in case of fatal errors.

See also: luaL_newstate.

close :: State -> IO ()

Destroys all objects in the given Lua state (calling the corresponding garbage-collection metamethods, if any) and frees all dynamic memory used by this state. On several platforms, you may not need to call this function, because all resources are naturally released when the host program ends. On the other hand, long-running programs that create multiple states, such as daemons or web servers, will probably need to close states as soon as they are not needed.

This is a wrapper function of lua_close.

Basic stack manipulation

absindex :: StackIndex -> Lua StackIndex

Converts the acceptable index idx into an equivalent absolute index (that is, one that does not depend on the stack top).

gettop :: Lua StackIndex

Returns the index of the top element in the stack. Because indices start at 1, this result is equal to the number of elements in the stack (and so 0 means an empty stack).

See also: lua_gettop.

settop :: StackIndex -> Lua ()

Accepts any index, or 0, and sets the stack top to this index. If the new top is larger than the old one, then the new elements are filled with nil. If index is 0, then all stack elements are removed.

See also: lua_settop.

pushvalue :: StackIndex -> Lua ()

Pushes a copy of the element at the given index onto the stack.

See lua_pushvalue.

copy :: StackIndex -> StackIndex -> Lua ()

Copies the element at index fromidx into the valid index toidx, replacing the value at that position. Values at other positions are not affected.

See also lua_copy in the lua manual.

insert :: StackIndex -> Lua ()

Moves the top element into the given valid index, shifting up the elements above this index to open space. This function cannot be called with a pseudo-index, because a pseudo-index is not an actual stack position.

See also: lua_insert.

pop :: StackIndex -> Lua ()

Pops n elements from the stack.

See also: lua_pop.

remove :: StackIndex -> Lua ()

Removes the element at the given valid index, shifting down the elements above this index to fill the gap. This function cannot be called with a pseudo-index, because a pseudo-index is not an actual stack position.

See lua_remove.

replace :: StackIndex -> Lua ()

Moves the top element into the given valid index without shifting any element (therefore replacing the value at that given index), and then pops the top element.

See lua_replace.

checkstack :: Int -> Lua Bool

Ensures that the stack has space for at least n extra slots (that is, that you can safely push up to n values into it). It returns false if it cannot fulfill the request, either because it would cause the stack to be larger than a fixed maximum size (typically at least several thousand elements) or because it cannot allocate memory for the extra space. This function never shrinks the stack; if the stack already has space for the extra slots, it is left unchanged.

This is a wrapper function of lua_checkstack.

types and type checks

data Type

Enumeration used as type tag. See lua_type.

Constructors

TypeNone

non-valid stack index

TypeNil

type of lua's nil value

TypeBoolean

type of lua booleans

TypeLightUserdata

type of light userdata

TypeNumber

type of lua numbers. See Number

TypeString

type of lua string values

TypeTable

type of lua tables

TypeFunction

type of functions, either normal or CFunction

TypeUserdata

type of full user data

TypeThread

type of lua threads

Instances

Bounded Type

Defined in Foreign.Lua.Core.Types

Methods

minBound :: Type

maxBound :: Type

Enum Type

Defined in Foreign.Lua.Core.Types

Methods

succ :: Type -> Type

pred :: Type -> Type

toEnum :: Int -> Type

fromEnum :: Type -> Int

enumFrom :: Type -> [Type]

enumFromThen :: Type -> Type -> [Type]

enumFromTo :: Type -> Type -> [Type]

enumFromThenTo :: Type -> Type -> Type -> [Type]

Eq Type

Defined in Foreign.Lua.Core.Types

Methods

(==) :: Type -> Type -> Bool

(/=) :: Type -> Type -> Bool

Ord Type

Defined in Foreign.Lua.Core.Types

Methods

compare :: Type -> Type -> Ordering

(<) :: Type -> Type -> Bool

(<=) :: Type -> Type -> Bool

(>) :: Type -> Type -> Bool

(>=) :: Type -> Type -> Bool

max :: Type -> Type -> Type

min :: Type -> Type -> Type

Show Type

Defined in Foreign.Lua.Core.Types

Methods

showsPrec :: Int -> Type -> ShowS

show :: Type -> String

showList :: [Type] -> ShowS

newtype TypeCode

Integer code used to encode the type of a lua value.

Constructors

TypeCode

Fields

• fromTypeCode :: CInt

Instances

Eq TypeCode

Defined in Foreign.Lua.Core.Types

Methods

(==) :: TypeCode -> TypeCode -> Bool

(/=) :: TypeCode -> TypeCode -> Bool

Ord TypeCode

Defined in Foreign.Lua.Core.Types

Methods

compare :: TypeCode -> TypeCode -> Ordering

(<) :: TypeCode -> TypeCode -> Bool

(<=) :: TypeCode -> TypeCode -> Bool

(>) :: TypeCode -> TypeCode -> Bool

(>=) :: TypeCode -> TypeCode -> Bool

max :: TypeCode -> TypeCode -> TypeCode

min :: TypeCode -> TypeCode -> TypeCode

Show TypeCode

Defined in Foreign.Lua.Core.Types

Methods

showsPrec :: Int -> TypeCode -> ShowS

show :: TypeCode -> String

showList :: [TypeCode] -> ShowS

fromType :: Type -> TypeCode

Convert a lua Type to a type code which can be passed to the C API.

toType :: TypeCode -> Type

Convert numerical code to lua type.

ltype :: StackIndex -> Lua Type

Returns the type of the value in the given valid index, or TypeNone for a non-valid (but acceptable) index.

See lua_type.

typename :: Type -> Lua String

Returns the name of the type encoded by the value tp, which must be one the values returned by ltype.

See also: lua_typename.

isboolean :: StackIndex -> Lua Bool

Returns True if the value at the given index is a boolean, and False otherwise.

See also: lua_isboolean.

iscfunction :: StackIndex -> Lua Bool

Returns True if the value at the given index is a C function, and False otherwise.

See also: lua_iscfunction.

isfunction :: StackIndex -> Lua Bool

Returns True if the value at the given index is a function (either C or Lua), and False otherwise.

See also: lua_isfunction.

isinteger :: StackIndex -> Lua Bool

Returns True if the value at the given index is an integer (that is, the value is a number and is represented as an integer), and False otherwise.

islightuserdata :: StackIndex -> Lua Bool

Returns True if the value at the given index is a light userdata, and False otherwise.

See also: <https://www.lua.org/manual/5.3/manual.html#lua_islightuserdata lua_islightuserdata>.

isnil :: StackIndex -> Lua Bool

Returns True if the value at the given index is nil, and False otherwise.

See also: lua_isnil.

isnone :: StackIndex -> Lua Bool

Returns True if the given index is not valid, and False otherwise.

See also: lua_isnone.

isnoneornil :: StackIndex -> Lua Bool

Returns True if the given index is not valid or if the value at the given index is nil, and False otherwise.

See also: lua_isnoneornil.

isnumber :: StackIndex -> Lua Bool

Returns True if the value at the given index is a number or a string convertible to a number, and False otherwise.

See also: lua_isnumber.

isstring :: StackIndex -> Lua Bool

Returns True if the value at the given index is a string or a number (which is always convertible to a string), and False otherwise.

See also: lua_isstring.

istable :: StackIndex -> Lua Bool

Returns True if the value at the given index is a table, and False otherwise.

See also: lua_istable.

isthread :: StackIndex -> Lua Bool

Returns True if the value at the given index is a thread, and False otherwise.

See also: lua_isthread.

isuserdata :: StackIndex -> Lua Bool

Returns True if the value at the given index is a userdata (either full or light), and False otherwise.

See also: lua_isuserdata.

access functions (stack → Haskell)

toboolean :: StackIndex -> Lua Bool

Converts the Lua value at the given index to a haskell boolean value. Like all tests in Lua, toboolean returns True for any Lua value different from false and nil; otherwise it returns False. (If you want to accept only actual boolean values, use isboolean to test the value's type.)

See also: lua_toboolean.

tocfunction :: StackIndex -> Lua (Maybe CFunction)

Converts a value at the given index to a C function. That value must be a C function; otherwise, returns Nothing.

See also: lua_tocfunction.

tointeger :: StackIndex -> Lua (Maybe Integer)

Converts the Lua value at the given acceptable index to the signed integral type lua_Integer. The Lua value must be an integer, a number or a string convertible to an integer (see §3.4.3 of the Lua 5.3 Reference Manual); otherwise, tointeger returns Nothing.

If the number is not an integer, it is truncated in some non-specified way.

See also: lua_tointeger.

tonumber :: StackIndex -> Lua (Maybe Number)

Converts the Lua value at the given index to the C type lua_Number. The Lua value must be a number or a string convertible to a number; otherwise, tonumber returns Nothing.

See lua_tonumber.

topointer :: StackIndex -> Lua (Ptr ())

Converts the value at the given index to a generic C pointer (void*). The value can be a userdata, a table, a thread, or a function; otherwise, lua_topointer returns nullPtr. Different objects will give different pointers. There is no way to convert the pointer back to its original value.

Typically this function is used only for hashing and debug information.

See also: lua_topointer.

tostring :: StackIndex -> Lua (Maybe ByteString)

Converts the Lua value at the given index to a ByteString. The Lua value must be a string or a number; otherwise, the function returns Nothing. If the value is a number, then tostring also changes the actual value in the stack to a string. (This change confuses next when tostring is applied to keys during a table traversal.)

See lua_tolstring.

tothread :: StackIndex -> Lua (Maybe State)

Converts the value at the given index to a Lua thread (represented as lua_State*). This value must be a thread; otherwise, the function returns Nothing.

See also: lua_tothread.

touserdata :: StackIndex -> Lua (Maybe (Ptr a))

If the value at the given index is a full userdata, returns its block address. If the value is a light userdata, returns its pointer. Otherwise, returns Nothing..

See also: lua_touserdata.

rawlen :: StackIndex -> Lua Int

Returns the raw "length" of the value at the given index: for strings, this is the string length; for tables, this is the result of the length operator (#) with no metamethods; for userdata, this is the size of the block of memory allocated for the userdata; for other values, it is 0.

See also: lua_rawlen.

Comparison and arithmetic functions

data RelationalOperator

Lua comparison operations.

Constructors

EQ

Correponds to lua's equality (==) operator.

LT

Correponds to lua's strictly-lesser-than (<) operator

LE

Correponds to lua's lesser-or-equal (<=) operator

Instances

Eq RelationalOperator

Defined in Foreign.Lua.Core.Types

Methods

(==) :: RelationalOperator -> RelationalOperator -> Bool

(/=) :: RelationalOperator -> RelationalOperator -> Bool

Ord RelationalOperator

Defined in Foreign.Lua.Core.Types

Methods

compare :: RelationalOperator -> RelationalOperator -> Ordering

(<) :: RelationalOperator -> RelationalOperator -> Bool

(<=) :: RelationalOperator -> RelationalOperator -> Bool

(>) :: RelationalOperator -> RelationalOperator -> Bool

(>=) :: RelationalOperator -> RelationalOperator -> Bool

max :: RelationalOperator -> RelationalOperator -> RelationalOperator

min :: RelationalOperator -> RelationalOperator -> RelationalOperator

Show RelationalOperator

Defined in Foreign.Lua.Core.Types

Methods

showsPrec :: Int -> RelationalOperator -> ShowS

show :: RelationalOperator -> String

showList :: [RelationalOperator] -> ShowS

fromRelationalOperator :: RelationalOperator -> CInt

Convert relation operator to its C representation.

compare :: StackIndex -> StackIndex -> RelationalOperator -> Lua Bool

Compares two Lua values. Returns True if the value at index idx1 satisfies op when compared with the value at index idx2, following the semantics of the corresponding Lua operator (that is, it may call metamethods). Otherwise returns False. Also returns False if any of the indices is not valid.

The value of op must be of type LuaComparerOp:

OpEQ: compares for equality (==) OpLT: compares for less than (<) OpLE: compares for less or equal (<=)

This is a wrapper function of lua_compare.

equal :: StackIndex -> StackIndex -> Lua Bool

Returns True if the two values in acceptable indices index1 and index2 are equal, following the semantics of the Lua == operator (that is, may call metamethods). Otherwise returns False. Also returns False if any of the indices is non valid. Uses compare internally.

lessthan :: StackIndex -> StackIndex -> Lua Bool

Tests whether the object under the first index is smaller than that under the second. Uses compare internally.

rawequal :: StackIndex -> StackIndex -> Lua Bool

Returns True if the two values in indices idx1 and idx2 are primitively equal (that is, without calling the __eq metamethod). Otherwise returns False. Also returns False if any of the indices are not valid.

See also: lua_rawequal.

push functions (Haskell → stack)

pushboolean :: Bool -> Lua ()

Pushes a boolean value with the given value onto the stack.

See also: lua_pushboolean.

pushcfunction :: CFunction -> Lua ()

Pushes a C function onto the stack. This function receives a pointer to a C function and pushes onto the stack a Lua value of type function that, when called, invokes the corresponding C function.

Any function to be callable by Lua must follow the correct protocol to receive its parameters and return its results (see CFunction)

See also: lua_pushcfunction.

pushcclosure :: CFunction -> NumArgs -> Lua ()

Pushes a new C closure onto the stack.

When a C function is created, it is possible to associate some values with it, thus creating a C closure (see §3.4); these values are then accessible to the function whenever it is called. To associate values with a C function, first these values should be pushed onto the stack (when there are multiple values, the first value is pushed first). Then lua_pushcclosure is called to create and push the C function onto the stack, with the argument n telling how many values should be associated with the function. lua_pushcclosure also pops these values from the stack.

The maximum value for n is 255.

See also: lua_pushcclosure.

pushinteger :: Integer -> Lua ()

Pushes an integer with with the given value onto the stack.

See also: lua_pushinteger.

pushlightuserdata :: Ptr a -> Lua ()

Pushes a light userdata onto the stack.

Userdata represent C values in Lua. A light userdata represents a pointer, a Ptr () (i.e., void* in C lingo). It is a value (like a number): you do not create it, it has no individual metatable, and it is not collected (as it was never created). A light userdata is equal to "any" light userdata with the same C address.

See also: lua_pushlightuserdata.

pushnil :: Lua ()

Pushes a nil value onto the stack.

See lua_pushnil.

pushnumber :: Number -> Lua ()

Pushes a float with the given value onto the stack.

See lua_pushnumber.

pushstring :: ByteString -> Lua ()

Pushes the zero-terminated string pointed to by s onto the stack. Lua makes (or reuses) an internal copy of the given string, so the memory at s can be freed or reused immediately after the function returns.

See also: <https://www.lua.org/manual/5.3/manual.html#lua_pushstring lua_pushstring>.

pushthread :: Lua Bool

Pushes the current thread onto the stack. Returns True if this thread is the main thread of its state, False otherwise.

See also: lua_pushthread.

get functions (Lua → stack)

getglobal :: String -> Lua ()

Pushes onto the stack the value of the global name.

Errors on the Lua side are caught and rethrown as Exception.

Wrapper of lua_getglobal.

gettable :: StackIndex -> Lua ()

Pushes onto the stack the value t[k], where t is the value at the given index and k is the value at the top of the stack.

This function pops the key from the stack, pushing the resulting value in its place. As in Lua, this function may trigger a metamethod for the "index" event (see §2.4 of lua's manual).

Errors on the Lua side are caught and rethrown as Exception.

See also: lua_gettable.

getfield :: StackIndex -> String -> Lua ()

Pushes onto the stack the value t[k], where t is the value at the given stack index. As in Lua, this function may trigger a metamethod for the "index" event (see §2.4 of lua's manual).

Errors on the Lua side are caught and rethrown as Exception.

See also: lua_getfield.

rawget :: StackIndex -> Lua ()

Similar to gettable, but does a raw access (i.e., without metamethods).

See also: lua_rawget.

rawgeti :: StackIndex -> Integer -> Lua ()

Pushes onto the stack the value t[n], where t is the table at the given index. The access is raw, that is, it does not invoke the __index metamethod.

See also: lua_rawgeti.

createtable :: Int -> Int -> Lua ()

Creates a new empty table and pushes it onto the stack. Parameter narr is a hint for how many elements the table will have as a sequence; parameter nrec is a hint for how many other elements the table will have. Lua may use these hints to preallocate memory for the new table. This preallocation is useful for performance when you know in advance how many elements the table will have. Otherwise you can use the function lua_newtable.

This is a wrapper for function lua_createtable.

newtable :: Lua ()

Creates a new empty table and pushes it onto the stack. It is equivalent to createtable 0 0.

See also: lua_newtable.

newuserdata :: Int -> Lua (Ptr ())

This function allocates a new block of memory with the given size, pushes onto the stack a new full userdata with the block address, and returns this address. The host program can freely use this memory.

See also: lua_newuserdata.

getmetatable :: StackIndex -> Lua Bool

If the value at the given index has a metatable, the function pushes that metatable onto the stack and returns True. Otherwise, the function returns False and pushes nothing on the stack.

See also: lua_getmetatable.

set functions (stack → Lua)

setglobal :: String -> Lua ()

Pops a value from the stack and sets it as the new value of global name.

Errors on the Lua side are caught and rethrown as a Exception.

See also: lua_setglobal.

settable :: StackIndex -> Lua ()

Does the equivalent to t[k] = v, where t is the value at the given index, v is the value at the top of the stack, and k is the value just below the top.

This function pops both the key and the value from the stack. As in Lua, this function may trigger a metamethod for the "newindex" event (see §2.4 of the Lua 5.3 Reference Manual).

Errors on the Lua side are caught and rethrown as a Exception.

See also: lua_settable.

setfield :: StackIndex -> String -> Lua ()

Does the equivalent to t[k] = v, where t is the value at the given index and v is the value at the top of the stack.

This function pops the value from the stack. As in Lua, this function may trigger a metamethod for the "newindex" event (see §2.4 of the Lua 5.3 Reference Manual).

Errors on the Lua side are caught and rethrown as a Exception.

See also: lua_setfield.

rawset :: StackIndex -> Lua ()

Similar to settable, but does a raw assignment (i.e., without metamethods).

See also: lua_rawset.

rawseti :: StackIndex -> Integer -> Lua ()

Does the equivalent of t[i] = v, where t is the table at the given index and v is the value at the top of the stack.

This function pops the value from the stack. The assignment is raw, that is, it does not invoke the __newindex metamethod.

See also: lua_rawseti.

setmetatable :: StackIndex -> Lua ()

Pops a table from the stack and sets it as the new metatable for the value at the given index.

See also: <https://www.lua.org/manual/5.3/manual.html#lua_setmetatable lua_setmetatable>.

load and call functions (load and run Lua code)

call :: NumArgs -> NumResults -> Lua ()

Calls a function.

To call a function you must use the following protocol: first, the function to be called is pushed onto the stack; then, the arguments to the function are pushed in direct order; that is, the first argument is pushed first. Finally you call call; nargs is the number of arguments that you pushed onto the stack. All arguments and the function value are popped from the stack when the function is called. The function results are pushed onto the stack when the function returns. The number of results is adjusted to nresults, unless nresults is multret. In this case, all results from the function are pushed. Lua takes care that the returned values fit into the stack space. The function results are pushed onto the stack in direct order (the first result is pushed first), so that after the call the last result is on the top of the stack.

Any error inside the called function cause a Exception to be thrown.

The following example shows how the host program can do the equivalent to this Lua code:

a = f("how", t.x, 14)

Here it is in Haskell (assuming the OverloadedStrings language extension):

getglobal "f"         -- function to be called
pushstring  "how"     -- 1st argument
getglobal "t"         -- table to be indexed
getfield (-1) "x"     -- push result of t.x (2nd arg)
remove (-2)           -- remove 't' from the stack
pushinteger 14        -- 3rd argument
call 3 1              -- call 'f' with 3 arguments and 1 result
setglobal "a"         -- set global 'a'

Note that the code above is "balanced": at its end, the stack is back to its original configuration. This is considered good programming practice.

See lua_call.

pcall :: NumArgs -> NumResults -> Maybe StackIndex -> Lua Status

Calls a function in protected mode.

Both nargs and nresults have the same meaning as in call. If there are no errors during the call, pcall behaves exactly like call. However, if there is any error, pcall catches it, pushes a single value on the stack (the error message), and returns the error code. Like call, pcall always removes the function and its arguments from the stack.

If msgh is Nothing, then the error object returned on the stack is exactly the original error object. Otherwise, when msgh is Just idx, the stack index idx is the location of a message handler. (This index cannot be a pseudo-index.) In case of runtime errors, this function will be called with the error object and its return value will be the object returned on the stack by pcall.

Typically, the message handler is used to add more debug information to the error object, such as a stack traceback. Such information cannot be gathered after the return of pcall, since by then the stack has unwound.

See lua_pcall.

load :: Reader -> Ptr () -> ByteString -> Lua Status

Loads a Lua chunk (without running it). If there are no errors, load pushes the compiled chunk as a Lua function on top of the stack. Otherwise, it pushes an error message.

The return values of load are:

• OK: no errors;
• ErrSyntax: syntax error during pre-compilation;
• ErrMem: memory allocation error;
• ErrGcmm: error while running a __gc metamethod. (This error has no relation with the chunk being loaded. It is generated by the garbage collector.)

This function only loads a chunk; it does not run it.

load automatically detects whether the chunk is text or binary, and loads it accordingly (see program luac).

The load function uses a user-supplied reader function to read the chunk (see Reader). The data argument is an opaque value passed to the reader function.

The chunkname argument gives a name to the chunk, which is used for error messages and in debug information (see §4.9). Note that the chunkname is used as a C string, so it may not contain null-bytes.

loadbuffer

Arguments

:: ByteString

Program to load

-> String

chunk name

-> Lua Status

Loads a ByteString as a Lua chunk.

This function returns the same results as load. name is the chunk name, used for debug information and error messages. Note that name is used as a C string, so it may not contain null-bytes.

See luaL_loadbuffer.

loadfile

Arguments

:: FilePath

filename

-> Lua Status

Loads a file as a Lua chunk. This function uses lua_load (see load) to load the chunk in the file named filename. The first line in the file is ignored if it starts with a #.

The string mode works as in function load.

This function returns the same results as load, but it has an extra error code ErrFile for file-related errors (e.g., it cannot open or read the file).

As load, this function only loads the chunk; it does not run it.

Note that the file is opened by Haskell, not Lua.

See luaL_loadfile.

loadstring :: ByteString -> Lua Status

Loads a string as a Lua chunk. This function uses lua_load to load the chunk in the given ByteString. The given string may not contain any NUL characters.

This function returns the same results as lua_load (see load).

Also as load, this function only loads the chunk; it does not run it.

See luaL_loadstring.

Coroutine functions

data Status

Lua status values.

Constructors

OK

success

Yield

yielding / suspended coroutine

ErrRun

a runtime rror

ErrSyntax

syntax error during precompilation

ErrMem

memory allocation (out-of-memory) error.

ErrErr

error while running the message handler.

ErrGcmm

error while running a __gc metamethod.

ErrFile

opening or reading a file failed.

Instances

Eq Status

Defined in Foreign.Lua.Core.Types

Methods

(==) :: Status -> Status -> Bool

(/=) :: Status -> Status -> Bool

Show Status

Defined in Foreign.Lua.Core.Types

Methods

showsPrec :: Int -> Status -> ShowS

show :: Status -> String

showList :: [Status] -> ShowS

toStatus :: StatusCode -> Status

Convert C integer constant to LuaStatus.

status :: Lua Status

Returns the status of this Lua thread.

The status can be OK for a normal thread, an error value if the thread finished the execution of a lua_resume with an error, or Yield if the thread is suspended.

You can only call functions in threads with status OK. You can resume threads with status OK (to start a new coroutine) or Yield (to resume a coroutine).

See also: lua_status.

garbage-collection function and options

data GCCONTROL

Enumeration used by gc function.

Constructors

GCSTOP

GCRESTART

GCCOLLECT

GCCOUNT

GCCOUNTB

GCSTEP

GCSETPAUSE

GCSETSTEPMUL

Instances

Enum GCCONTROL

Defined in Foreign.Lua.Core.Types

Methods

succ :: GCCONTROL -> GCCONTROL

pred :: GCCONTROL -> GCCONTROL

toEnum :: Int -> GCCONTROL

fromEnum :: GCCONTROL -> Int

enumFrom :: GCCONTROL -> [GCCONTROL]

enumFromThen :: GCCONTROL -> GCCONTROL -> [GCCONTROL]

enumFromTo :: GCCONTROL -> GCCONTROL -> [GCCONTROL]

enumFromThenTo :: GCCONTROL -> GCCONTROL -> GCCONTROL -> [GCCONTROL]

Eq GCCONTROL

Defined in Foreign.Lua.Core.Types

Methods

(==) :: GCCONTROL -> GCCONTROL -> Bool

(/=) :: GCCONTROL -> GCCONTROL -> Bool

Ord GCCONTROL

Defined in Foreign.Lua.Core.Types

Methods

compare :: GCCONTROL -> GCCONTROL -> Ordering

(<) :: GCCONTROL -> GCCONTROL -> Bool

(<=) :: GCCONTROL -> GCCONTROL -> Bool

(>) :: GCCONTROL -> GCCONTROL -> Bool

(>=) :: GCCONTROL -> GCCONTROL -> Bool

max :: GCCONTROL -> GCCONTROL -> GCCONTROL

min :: GCCONTROL -> GCCONTROL -> GCCONTROL

Show GCCONTROL

Defined in Foreign.Lua.Core.Types

Methods

showsPrec :: Int -> GCCONTROL -> ShowS

show :: GCCONTROL -> String

showList :: [GCCONTROL] -> ShowS

gc :: GCCONTROL -> Int -> Lua Int

Controls the garbage collector.

This function performs several tasks, according to the value of the parameter what:

• GCSTOP: stops the garbage collector.
• GCRESTART: restarts the garbage collector.
• GCCOLLECT: performs a full garbage-collection cycle.
• GCCOUNT: returns the current amount of memory (in Kbytes) in use by Lua.
• GCCOUNTB: returns the remainder of dividing the current amount of bytes of memory in use by Lua by 1024.
• GCSTEP: performs an incremental step of garbage collection. The step "size" is controlled by data (larger values mean more steps) in a non-specified way. If you want to control the step size you must experimentally tune the value of data. The function returns 1 if the step finished a garbage-collection cycle.
• 'GCSETPAUSE': sets data as the new value for the pause of the collector (see §2.10). The function returns the previous value of the pause.
• GCSETSTEPMUL: sets data as the new value for the step multiplier of the collector (see §2.10). The function returns the previous value of the step multiplier.

See lua_gc.

miscellaneous and helper functions

next :: StackIndex -> Lua Bool

Pops a key from the stack, and pushes a key–value pair from the table at the given index (the "next" pair after the given key). If there are no more elements in the table, then next returns False (and pushes nothing).

Errors on the Lua side are caught and rethrown as a Exception.

See also: lua_next.

error :: Lua NumResults

This is a convenience function to implement error propagation convention described in Error handling in hslua. hslua doesn't implement lua_error function from Lua C API because it's never safe to use. (see Error handling in hslua for details)

concat :: NumArgs -> Lua ()

Concatenates the n values at the top of the stack, pops them, and leaves the result at the top. If n is 1, the result is the single value on the stack (that is, the function does nothing); if n is 0, the result is the empty string. Concatenation is performed following the usual semantics of Lua (see §3.4.6 of the lua manual).

This is a wrapper function of lua_concat.

pushglobaltable :: Lua ()

register :: String -> CFunction -> Lua ()

Sets the C function f as the new value of global name.

See lua_register.

loading libraries

openbase :: Lua ()

Opens all standard Lua libraries into the current state.

| See luaopen_base.

opendebug :: Lua ()

Opens Lua's debug library into the current state.

See also: luaopen_debug.

openio :: Lua ()

Opens Lua's io library into the current state.

See also: luaopen_io.

openlibs :: Lua ()

Opens all standard Lua libraries into the current state.

See also: luaL_openlibs.

openmath :: Lua ()

Opens Lua's math library into the current state.

See also: luaopen_math.

openpackage :: Lua ()

Opens Lua's package library into the current state.

See also: luaopen_package.

openos :: Lua ()

Opens Lua's os library into the current state.

See also: luaopen_os.

openstring :: Lua ()

Opens Lua's string library into the current state.

See also: luaopen_string.

opentable :: Lua ()

Opens Lua's table library into the current state.

See also: luaopen_table.

Auxiliary library

dostring :: ByteString -> Lua Status

Loads and runs the given string.

Returns OK on success, or an error if either loading of the string or calling of the thunk failed.

dofile :: FilePath -> Lua Status

Loads and runs the given file. Note that the filepath is interpreted by Haskell, not Lua. The resulting chunk is named using the UTF8 encoded filepath.

getmetafield

Arguments

:: StackIndex

obj

-> String

e

-> Lua Type

Pushes onto the stack the field e from the metatable of the object at index obj and returns the type of the pushed value. If the object does not have a metatable, or if the metatable does not have this field, pushes nothing and returns TypeNil.

getmetatable'

Arguments

:: String

tname

-> Lua Type

Pushes onto the stack the metatable associated with name tname in the registry (see newmetatable) (nil if there is no metatable associated with that name). Returns the type of the pushed value.

getsubtable :: StackIndex -> String -> Lua Bool

Ensures that the value t[fname], where t is the value at index idx, is a table, and pushes that table onto the stack. Returns True if it finds a previous table there and False if it creates a new table.

newmetatable :: String -> Lua Bool

If the registry already has the key tname, returns False. Otherwise, creates a new table to be used as a metatable for userdata, adds to this new table the pair __name = tname, adds to the registry the pair [tname] = new table, and returns True. (The entry __name is used by some error-reporting functions.)

In both cases pushes onto the stack the final value associated with tname in the registry.

The value of tname is used as a C string and hence must not contain null bytes.

See also: luaL_newmetatable.

tostring' :: StackIndex -> Lua ByteString

Converts any Lua value at the given index to a ByteString in a reasonable format. The resulting string is pushed onto the stack and also returned by the function.

If the value has a metatable with a __tostring field, then tolstring' calls the corresponding metamethod with the value as argument, and uses the result of the call as its result.

traceback :: State -> Maybe String -> Int -> Lua ()

Creates and pushes a traceback of the stack L1. If a message is given it appended at the beginning of the traceback. The level parameter tells at which level to start the traceback.

References

data Reference

Reference to a stored value.

Constructors

Reference CInt

Reference to a stored value

RefNil

Reference to a nil value

Instances

Eq Reference

Defined in Foreign.Lua.Core.Types

Methods

(==) :: Reference -> Reference -> Bool

(/=) :: Reference -> Reference -> Bool

Show Reference

Defined in Foreign.Lua.Core.Types

Methods

showsPrec :: Int -> Reference -> ShowS

show :: Reference -> String

showList :: [Reference] -> ShowS

ref :: StackIndex -> Lua Reference

Creates and returns a reference, in the table at index t, for the object at the top of the stack (and pops the object).

A reference is a unique integer key. As long as you do not manually add integer keys into table t, ref ensures the uniqueness of the key it returns. You can retrieve an object referred by reference r by calling rawgeti t r. Function unref frees a reference and its associated object.

If the object at the top of the stack is nil, ref returns the constant refnil. The constant noref is guaranteed to be different from any reference returned by ref.

See also: luaL_ref.

getref :: StackIndex -> Reference -> Lua ()

Push referenced value from the table at the given index.

unref

Arguments

:: StackIndex

idx

-> Reference

ref

-> Lua ()

Releases reference ref from the table at index idx (see ref). The entry is removed from the table, so that the referred object can be collected. The reference ref is also freed to be used again.

See also: luaL_unref.

fromReference :: Reference -> CInt

Convert a reference to its C representation.

toReference :: CInt -> Reference

Create a reference from its C representation.

noref :: Int

Value signaling that no reference was found.

refnil :: Int

Value signaling that no reference was created.

Registry fields

loadedTableRegistryField :: String

Key, in the registry, for table of loaded modules.

preloadTableRegistryField :: String

Key, in the registry, for table of preloaded loaders.

Error handling

newtype Exception

Exceptions raised by Lua-related operations.

Constructors

Exception

Fields

• exceptionMessage :: String

Instances

Eq Exception

Defined in Foreign.Lua.Core.Error

Methods

(==) :: Exception -> Exception -> Bool

(/=) :: Exception -> Exception -> Bool

Show Exception

Defined in Foreign.Lua.Core.Error

Methods

showsPrec :: Int -> Exception -> ShowS

show :: Exception -> String

showList :: [Exception] -> ShowS

Exception Exception

Defined in Foreign.Lua.Core.Error

Methods

toException :: Exception -> SomeException

fromException :: SomeException -> Maybe Exception

displayException :: Exception -> String

throwException :: String -> Lua a

Raise a Lua Exception containing the given error message.

catchException :: Lua a -> (Exception -> Lua a) -> Lua a

Catch a Lua Exception.

withExceptionMessage :: (String -> String) -> Lua a -> Lua a

Catch Lua Exception, alter the message and rethrow.

try :: Lua a -> Lua (Either Exception a)

Return either the result of a Lua computation or, if an exception was thrown, the error.

throwTopMessage :: Lua a

Convert the object at the top of the stack into a string and throw it as an Exception.