Source: http://hackage.haskell.org/package/hslua-0.9.2/candidate/docs/Foreign-Lua-Api.html
Timestamp: 2019-04-21 01:30:26+00:00

Document:
Monadic functions which operate within the Lua type.
The functions in this module are mostly just thin wrappers around the respective C functions. However, C function which can throw an error are wrapped such that the error is converted into a LuaException. Memory allocation errors, however, are not caught and will cause the host program to terminate.
Returns the pseudo-index that represents the i-th upvalue of the running function (see §4.4 of the Lua 5.3 reference manual).
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.
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.
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).
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.
Pushes a copy of the element at the given index onto the stack.
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.
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.
Pops n elements from the stack.
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.
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.
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.
Returns the name of the type encoded by the value tp, which must be one the values returned by ltype.
Returns True if the value at the given index is a boolean, and False otherwise.
Returns True if the value at the given index is a C function, and False otherwise.
Returns True if the value at the given index is a function (either C or Lua), and False otherwise.
Returns True if the value at the given index is a light userdata, and False otherwise.
Returns True if the value at the given index is nil, and False otherwise.
Returns True if the given index is not valid, and False otherwise.
Returns True if the given index is not valid or if the value at the given index is nil, and False otherwise.
Returns True if the value at the given index is a number or a string convertible to a number, and False otherwise.
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.
Returns True if the value at the given index is a table, and False otherwise.
Returns True if the value at the given index is a thread, and False otherwise.
Returns True if the value at the given index is a userdata (either full or light), and False otherwise.
Converts a value at the given index to a C function. That value must be a C function; otherwise, returns NULL.
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 0.
If the number is not an integer, it is truncated in some non-specified way.
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 0.
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 NULL. 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.
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 NULL.
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 NULL.
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.
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.
This is a wrapper function of lua_compare.
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.
Tests whether the object under the first index is smaller than that under the second. Uses compare internally.
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.
Pushes a boolean value with the given value onto the stack.
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.
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.
Pushes an integer with with the given value onto the stack.
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.
Pushes a nil value onto the stack.
Pushes a float with the given value onto the stack.
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.
Pushes the current thread onto the stack. Returns True if this thread is the main thread of its state, False otherwise.
Pushes onto the stack the value of the global name. Returns the type of that value.
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).
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).
Returns the type of the pushed value.
Similar to gettable, but does a raw access (i.e., without metamethods).
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.
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.
Creates a new empty table and pushes it onto the stack. It is equivalent to createtable 0 0.
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.
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.
Pops a value from the stack and sets it as the new value of global name.
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).
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).
Similar to settable, but does a raw assignment (i.e., without metamethods).
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.
Pops a table from the stack and sets it as the new metatable for the value at the given index.
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 LuaException to be thrown.
Note that the code above is "balanced": at its end, the stack is back to its original configuration. This is considered good programming practice.
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.
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).
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.
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).
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.
Sets the C function f as the new value of global name.
Opens all standard Lua libraries into the current state.
Opens Lua's debug library into the current state.
Opens Lua's io library into the current state.
Opens Lua's math library into the current state.
Opens Lua's package library into the current state.
Opens Lua's os library into the current state.
Opens Lua's string library into the current state.
Opens Lua's table library into the current state.
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.
In both cases pushes onto the stack the final value associated with tname in the registry.
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.

References: §4
 §4
 §3
 §3
 §2
 §2
 §2
 §2
 §2
 §2
 §3