h$#8      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                             2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None 8,hslua2The number of results returned by a function call.hslua8The number of arguments consumed curing a function call.hslua A stack index hsluaEnumeration used by gc function.hsluaInteger code used to signal the status of a thread or computation. See .hsluaLua status values.hsluasuccesshsluayielding / suspended coroutinehsluaa runtime rrorhslua"syntax error during precompilationhslua(memory allocation (out-of-memory) error.hslua(error while running the message handler.hsluaerror while running a __gc metamethod.hslua!opening or reading a file failed.hsluaLua comparison operations.hslua+Correponds to lua's equality (==) operator. hslua5Correponds to lua's strictly-lesser-than (<) operator!hslua1Correponds to lua's lesser-or-equal (<=) operator"hslua4Integer code used to encode the type of a lua value.%hslua#Enumeration used as type tag. See  3https://www.lua.org/manual/5.3/manual.html#lua_typelua_type.&hsluanon-valid stack index'hsluatype of lua's nil value(hsluatype of lua booleans)hsluatype of light userdata*hsluatype of lua numbers. See +hsluatype of lua string values,hsluatype of lua tables-hslua$type of functions, either normal or 7.hsluatype of full user data/hsluatype of lua threads0hslua:Boolean value returned by a Lua C API function. This is a  and interpreted as  iff the value is 0,  otherwise.2hsluaThe type of floats in Lua.By default this type is , but that can be changed in Lua to a single float or a long double. (See LUA_FLOAT_TYPE in  luaconf.h.)See  5https://www.lua.org/manual/5.3/manual.html#lua_Number lua_Number.4hsluaThe type of integers in Lua.By default this type is <, but that can be changed to different values in lua. (See  LUA_INT_TYPE in  luaconf.h.)See  6https://www.lua.org/manual/5.3/manual.html#lua_Integer lua_Integer.6hsluaThe reader function used by . Every time it needs another piece of the chunk, lua_load calls the reader, passing along its data parameter. The reader must return a pointer to a block of memory with a new piece of the chunk and set size to the block size. The block must exist until the reader function is called again. To signal the end of the chunk, the reader must return NULL or set size to zero. The reader function may return pieces of any size greater than zero.See  5https://www.lua.org/manual/5.3/manual.html#lua_Reader lua_Reader.7hsluaType 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,  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 . 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  8https://www.lua.org/manual/5.3/manual.html#lua_CFunction lua_CFunction.8hsluaAn 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  )https://www.lua.org/manual/5.3/#lua_State lua_State.:hsluaGeneric Lua representation of a value interpreted as being true.;hslua5Lua representation of the value interpreted as false.<hslua Convert a 0 to a Haskell .=hsluaConvert a Haskell  to a 0.>hsluaConvert a lua Type to a type code which can be passed to the C API.?hslua#Convert numerical code to lua type.@hslua2Convert relation operator to its C representation.AhsluaConvert C integer constant to .  !"#$%&'()*+,-./0123456789:;<=>?@A896 %&'()*+,-./"#$>?701;:<=4523  !@A 2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betaForeignFunctionInterface, CPPNone 6rxhslua.Point to function opening the package library.yhslua,Point to function opening the debug library.zhslua+Point to function opening the math library.{hslua-Point to function opening the string library.|hslua)Point to function opening the os library.}hslua)Point to function opening the io library.~hslua,Point to function opening the table library.hslua+Point to function opening the base library.hsluaSee 8https://www.lua.org/manual/5.3/manual.html#luaL_openlibs luaL_openlibshsluaSee >https://www.lua.org/manual/5.3/manual.html#lua_pushglobaltable-- lua_pushglobaltablehsluaWrapper around  1https://lua.org/manual/5.3/manual.html#lua_concat-- @lua_concat@ which catches any longjmps.hsluaWrapper around  /https://lua.org/manual/5.3/manual.html#lua_next -- @lua_next@ which catches any longjmps.hsluaReplacement for  0https://lua.org/manual/5.3/manual.html#lua_error-- @lua_error@=; it uses the HsLua error signaling convention instead of rawhsluaSee 1https://www.lua.org/manual/5.3/manual.html#lua_gclua_gchsluaSee 5https://www.lua.org/manual/5.3/manual.html#lua_status lua_statushsluaSee 3https://www.lua.org/manual/5.3/manual.html#lua_loadlua_loadhsluaSee 4https://www.lua.org/manual/5.1/manual.html#lua_pcall lua_pcallhsluaWrapper around  4https://lua.org/manual/5.3/manual.html#lua_setglobal-- @lua_setglobal@ which catches any longjmps.hsluaSee ;https://www.lua.org/manual/5.3/manual.html#lua_setmetatablelua_setmetatablehsluaSee 6https://www.lua.org/manual/5.3/manual.html#lua_rawseti lua_rawsetihsluaSee 5https://www.lua.org/manual/5.3/manual.html#lua_rawset lua_rawsethsluaWrapper around  3https://lua.org/manual/5.3/manual.html#lua_settable-- @lua_settable@ which catches any longjmps.hsluaWrapper around  4https://lua.org/manual/5.3/manual.html#lua_getglobal-- @lua_getglobal@ which catches any longjmps.hsluaSee ;https://www.lua.org/manual/5.3/manual.html#lua_getmetatablelua_getmetatablehsluaSee :https://www.lua.org/manual/5.3/manual.html#lua_newuserdatalua_newuserdatahsluaSee :https://www.lua.org/manual/5.3/manual.html#lua_createtablelua_createtablehsluaSee 6https://www.lua.org/manual/5.3/manual.html#lua_rawgeti lua_rawgetihsluaSee 5https://www.lua.org/manual/5.3/manual.html#lua_rawget lua_rawgethsluaWrapper around  3https://lua.org/manual/5.3/manual.html#lua_gettable-- @lua_gettable@ which catches any longjmps.hsluaSee 9https://www.lua.org/manual/5.3/manual.html#lua_pushthreadlua_pushthreadhsluaSee https://www.lua.org/manual/5.3/manual.html#lua_pushlightuserdatalua_pushlightuserdatahsluaSee :https://www.lua.org/manual/5.3/manual.html#lua_pushbooleanlua_pushbooleanhsluaSee ;https://www.lua.org/manual/5.3/manual.html#lua_pushcclosurelua_pushcclosurehsluaSee :https://www.lua.org/manual/5.3/manual.html#lua_pushlstringlua_pushlstringhsluaSee :https://www.lua.org/manual/5.3/manual.html#lua_pushintegerlua_pushintegerhsluaSee 9https://www.lua.org/manual/5.3/manual.html#lua_pushnumberlua_pushnumberhsluaSee 6https://www.lua.org/manual/5.3/manual.html#lua_pushnil lua_pushnilhsluaSee 5https://www.lua.org/manual/5.3/manual.html#lua_rawlen lua_rawlenhsluaSee 9https://www.lua.org/manual/5.3/manual.html#lua_touserdatalua_touserdatahsluaSee 7https://www.lua.org/manual/5.3/manual.html#lua_tothread lua_tothreadhsluaSee 8https://www.lua.org/manual/5.3/manual.html#lua_topointer lua_topointerhsluaSee 8https://www.lua.org/manual/5.3/manual.html#lua_tolstring lua_tolstringhsluaSee 8https://www.lua.org/manual/5.3/manual.html#lua_tonumberx lua_tonumberxhsluaSee 9https://www.lua.org/manual/5.3/manual.html#lua_tointegerxlua_tointegerxhsluaSee :https://www.lua.org/manual/5.3/manual.html#lua_tocfunctionlua_tocfunctionhsluaSee 8https://www.lua.org/manual/5.3/manual.html#lua_toboolean lua_tobooleanhsluaSee 7https://www.lua.org/manual/5.3/manual.html#lua_rawequal lua_rawequalhsluaWrapper around  2https://lua.org/manual/5.3/manual.html#lua_compare-- @lua_compare@ which catches any longjmps.hsluaSee 7https://www.lua.org/manual/5.3/manual.html#lua_typename lua_typenamehsluaSee 3https://www.lua.org/manual/5.3/manual.html#lua_typelua_typehsluaSee 9https://www.lua.org/manual/5.3/manual.html#lua_isuserdatalua_isuserdatahsluaSee :https://www.lua.org/manual/5.3/manual.html#lua_iscfunctionlua_iscfunctionhsluaSee 7https://www.lua.org/manual/5.3/manual.html#lua_isstring lua_isstringhsluaSee 8https://www.lua.org/manual/5.3/manual.html#lua_isinteger lua_isintegerhsluaSee 7https://www.lua.org/manual/5.3/manual.html#lua_isnumber lua_isnumberhsluaSee 9https://www.lua.org/manual/5.3/manual.html#lua_checkstacklua_checkstackhsluaSee 6https://www.lua.org/manual/5.2/manual.html#lua_replace lua_replacehsluaSee 5https://www.lua.org/manual/5.2/manual.html#lua_insert lua_inserthsluaSee 5https://www.lua.org/manual/5.2/manual.html#lua_remove lua_removehsluaSee 3https://www.lua.org/manual/5.3/manual.html#lua_copylua_copyhsluaSee 2https://www.lua.org/manual/5.3/manual.html#lua_poplua_pophsluaSee 8https://www.lua.org/manual/5.3/manual.html#lua_pushvalue lua_pushvaluehsluaSee 5https://www.lua.org/manual/5.3/manual.html#lua_settop lua_settophsluaSee 5https://www.lua.org/manual/5.3/manual.html#lua_gettop lua_gettophsluaSee 7https://www.lua.org/manual/5.3/manual.html#lua_absindex lua_absindexhsluaSee 4https://www.lua.org/manual/5.3/manual.html#lua_close lua_closexyz{|}~~}|{zyx 2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betaForeignFunctionInterfaceNone 8Txyz{|}~ 2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betaForeignFunctionInterfaceNone ;hslua,Value signaling that no reference was found.hslua.Value signaling that no reference was created.hsluaAlias for C constant LUA_REGISTRYINDEX. See  #https://www.lua.org/manual/5.3/#3.5 Lua registry.hsluaAlias for C constant  LUA_MULTRET. See  (https://www.lua.org/manual/5.3/#lua_calllua_call. 2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betaForeignFunctionInterfaceNone < 2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None =hslua5Type of raw Haskell functions that can be made into  CFunctions.hslua(Pushes a new C function created from an . 2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None @ghsluaReference to a stored value.hsluaReference to a stored valuehsluaReference to a nil valuehsluaSee 9https://www.lua.org/manual/5.3/manual.html#luaL_testudataluaL_testudatahslua2Key, in the registry, for table of loaded modules.hslua5Key, in the registry, for table of preloaded loaders.hslua,Convert a reference to its C representation.hslua-Create a reference from its C representation. 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betaportableNone AhsluaRetrieve and pop the top object as an error message. This is very similar to tostring', but ensures that we don't recurse if getting the message failed. 2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None I%hsluaA 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 .hslua4Environment in which Lua computations are evaluated.hslua9Functions for error and exception handling and conversionhsluaLua interpreter statehslua;Define the ways in which exceptions and errors are handled.hslua*Translate Lua errors to Haskell exceptionshslua7Add information on the current context to an exception.hsluaRuns the second computation only if the first fails; returns the result of the first successful computation, if any.hslua*Translate Haskell exceptions to Lua errorshsluaTurn a function of typ Lua.State -> IO a into a monadic Lua operation.hsluaTurn a function of typ Lua.State -> a -> IO b into a monadic Lua operation.hslua*Get the Lua state of this Lua computation.hslua$Get the error-to-exception function.hsluaRun Lua computation with the given Lua state and error-to-exception converter. Any resulting exceptions are left unhandled.hsluaRun the given operation, but crash if any Haskell exceptions occur.hsluaUnsafe ; no proper error handling is attempted, any error leads to a crash.hslua9Stack index of the nth element from the top of the stack.hslua9Stack index of the nth element from the top of the stack.hslua?@A896 %&'()*+,-./"#$>?701;:<=4523  !@A 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betaForeignFunctionInterfaceNone LhsluaCreates and registers a new metatable for a userdata-wrapped Haskell value; checks whether a metatable of that name has been registered yet and uses the registered table if possible.hslua9Creates a new userdata wrapping the given Haskell object.hsluaRetrieves a Haskell object from userdata at the given index. The userdata must have the given name.hslua Lua statehsluaUserdata name (__name)hslua&True iff new metatable was created.hsluauserdata indexhsluaname  2018-2020 Albert KrewinkelMIT,Albert Krewinkel betaportable Safe-Inferred NhsluaDecode  to  using UTF-8. Invalid input bytes are replaced with the Unicode replacement character U+FFFD.hsluaDecode  to  using UTF-8. Invalid input bytes are replaced with the Unicode replacement character U+FFFD.hsluaEncode  to  using UTF-8.hsluaEncode  to  using UTF-8.  2017-2020 Albert KrewinkelMIT,Albert Krewinkel betaDeriveDataTypeableNone  3SL hslua,Exceptions raised by Lua-related operations.hslua Raise a Lua $ containing the given error message.hslua Catch a Lua .hslua Catch Lua  , alter the message and rethrow.hsluaReturn either the result of a Lua computation or, if an exception was thrown, the error.hsluaConvert a Lua error into a Haskell exception. The error message is expected to be at the top of the stack.hslua Alias for 0; will be deprecated in the next mayor release.hsluaHelper function which uses proper error-handling to throw an exception with the given message.hsluaConvert the object at the top of the stack into a string and throw it as a HsLua .This function serves as the default to convert Lua errors to Haskell exceptions.hsluaTakes a failable HsLua function and transforms it into a monadic 5 operation. Throws an exception if an error occured.   2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None hsluaExecute an action only if the given index is a table. Throw an error otherwise.hsluaConverts the acceptable index idx into an equivalent absolute index (that is, one that does not depend on the stack top).hsluaCalls 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  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  3https://www.lua.org/manual/5.3/manual.html#lua_calllua_call.hslua.Ensures that the stack has space for at least n7 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  9https://www.lua.org/manual/5.3/manual.html#lua_checkstacklua_checkstack.hsluaDestroys 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  4https://www.lua.org/manual/5.3/manual.html#lua_close lua_close.hslua!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 RelationalOperator:EQ: compares for equality (==) LT: compares for less than (<) LE: compares for less or equal (<=)This is a wrapper function of  6https://www.lua.org/manual/5.3/manual.html#lua_compare lua_compare.hsluaConcatenates 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  0https://www.lua.org/manual/5.3/manual.html#3.4.63.4.6 of the lua manual).This is a wrapper function of  5https://www.lua.org/manual/5.3/manual.html#lua_concat lua_concat.hsluaCopies 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  3https://www.lua.org/manual/5.3/manual.html#lua_copylua_copy in the lua manual.hsluaCreates 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  :https://www.lua.org/manual/5.3/manual.html#lua_createtablelua_createtable.hsluaReturns 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  internally.hsluaThis is a convenience function to implement error propagation convention described in  #g:1Error handling in hslua. hslua doesn't implement the  lua_error? function from Lua C API because it's never safe to use. (see  #g:1Error handling in hslua for details)hsluaControls the garbage collector.This function performs several tasks, according to the value of the parameter what: : stops the garbage collector. !: restarts the garbage collector. +: performs a full garbage-collection cycle.: returns the current amount of memory (in Kbytes) in use by Lua.: returns the remainder of dividing the current amount of bytes of memory in use by Lua by 1024.: 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.: 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  1https://www.lua.org/manual/5.3/manual.html#lua_gclua_gc.hslua 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  .https://www.lua.org/manual/5.3/manual.html#2.42.4 of lua's manual).2Errors on the Lua side are caught and rethrown as . See also:  7https://www.lua.org/manual/5.3/manual.html#lua_getfield lua_getfield.hslua.Pushes onto the stack the value of the global name.2Errors on the Lua side are caught and rethrown as . Wrapper of  8https://www.lua.org/manual/5.3/manual.html#lua_getglobal lua_getglobal.hsluaIf 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:  ;https://www.lua.org/manual/5.3/manual.html#lua_getmetatablelua_getmetatable.hslua 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  .https://www.lua.org/manual/5.3/manual.html#2.42.4 of lua's manual).2Errors on the Lua side are caught and rethrown as . See also:  7https://www.lua.org/manual/5.3/manual.html#lua_gettable lua_gettable.hsluaReturns 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:  5https://www.lua.org/manual/5.3/manual.html#lua_gettop lua_gettop.hsluaMoves 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:  5https://www.lua.org/manual/5.3/manual.html#lua_insert lua_insert.hsluaReturns True3 if the value at the given index is a boolean, and False otherwise. See also:  8https://www.lua.org/manual/5.3/manual.html#lua_isboolean lua_isboolean.hsluaReturns True6 if the value at the given index is a C function, and False otherwise. See also:  :https://www.lua.org/manual/5.3/manual.html#lua_iscfunctionlua_iscfunction.hsluaReturns True if the value at the given index is a function (either C or Lua), and False otherwise. See also:  9https://www.lua.org/manual/5.3/manual.html#lua_isfunctionlua_isfunction.hsluaReturns 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.hsluaReturns 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>.hsluaReturns True$ if the value at the given index is nil, and False otherwise. See also:  4https://www.lua.org/manual/5.3/manual.html#lua_isnil lua_isnil.hsluaReturns True& if the given index is not valid, and False otherwise. See also:  5https://www.lua.org/manual/5.3/manual.html#lua_isnone lua_isnone.hsluaReturns True if the given index is not valid or if the value at the given index is nil, and False otherwise. See also:  :https://www.lua.org/manual/5.3/manual.html#lua_isnoneornillua_isnoneornil.hsluaReturns True if the value at the given index is a number or a string convertible to a number, and False otherwise. See also:  7https://www.lua.org/manual/5.3/manual.html#lua_isnumber lua_isnumber.hsluaReturns 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:  7https://www.lua.org/manual/5.3/manual.html#lua_isstring lua_isstring.hsluaReturns True1 if the value at the given index is a table, and False otherwise. See also:  6https://www.lua.org/manual/5.3/manual.html#lua_istable lua_istable.hsluaReturns True2 if the value at the given index is a thread, and False otherwise. See also:  7https://www.lua.org/manual/5.3/manual.html#lua_isthread lua_isthread.hsluaReturns True if the value at the given index is a userdata (either full or light), and False otherwise. See also:  9https://www.lua.org/manual/5.3/manual.html#lua_isuserdatalua_isuserdata.hsluaTests whether the object under the first index is smaller than that under the second. Uses  internally.hsluaLoads a Lua chunk (without running it). If there are no errors,  pushes the compiled chunk as a Lua function on top of the stack. Otherwise, it pushes an error message.The return values of  are: : no errors;&: syntax error during pre-compilation;: memory allocation error;: error while running a __gc metamethod. (This error has no relation with the chunk being loaded. It is generated by the garbage collector.)5This 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  function uses a user-supplied reader function to read the chunk (see 6). 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  .https://www.lua.org/manual/5.3/manual.html#4.94.9). Note that the  chunkname9 is used as a C string, so it may not contain null-bytes.hslua;Returns the type of the value in the given valid index, or &) for a non-valid (but acceptable) index.See  3https://www.lua.org/manual/5.3/manual.html#lua_typelua_type.hsluaCreates a new empty table and pushes it onto the stack. It is equivalent to createtable 0 0. See also:  7https://www.lua.org/manual/5.3/manual.html#lua_newtable lua_newtable.hsluaThis 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:  :https://www.lua.org/manual/5.3/manual.html#lua_newuserdatalua_newuserdata.hsluaPops 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).4Errors on the Lua side are caught and rethrown as a . See also:  3https://www.lua.org/manual/5.3/manual.html#lua_nextlua_next.hsluaOpens all standard Lua libraries into the current state and sets each library name as a global value. See also:  8https://www.lua.org/manual/5.3/manual.html#luaL_openlibs luaL_openlibs.hslua Pushes Lua's base library onto the stack.See  ;https://www.lua.org/manual/5.3/manual.html#pdf-luaopen_base luaopen_base.hslua Pushes Lua's debug library onto the stack. See also:  https://www.lua.org/manual/5.3/manual.html#pdf-luaopen_packageluaopen_package.hslua Pushes Lua's string library onto the stack. See also:  =https://www.lua.org/manual/5.3/manual.html#pdf-luaopen_stringluaopen_string.hslua Pushes Lua's table library onto the stack. See also:  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 .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 &, since by then the stack has unwound.See  4https://www.lua.org/manual/5.3/manual.html#lua_pcall lua_pcall.hsluaPops n elements from the stack. See also:  2https://www.lua.org/manual/5.3/manual.html#lua_poplua_pop.hslua;Pushes a boolean value with the given value onto the stack. See also:  :https://www.lua.org/manual/5.3/manual.html#lua_pushbooleanlua_pushboolean.hslua&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  .https://www.lua.org/manual/5.1/manual.html#3.43.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:  ;https://www.lua.org/manual/5.3/manual.html#lua_pushcclosurelua_pushcclosure.hsluaPushes 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 7) See also:  https://www.lua.org/manual/5.3/manual.html#lua_pushglobaltable lua_pushglobaltable>.hslua;Pushes an integer with with the given value onto the stack. See also:  :https://www.lua.org/manual/5.3/manual.html#lua_pushintegerlua_pushinteger.hslua'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:  https://www.lua.org/manual/5.3/manual.html#lua_pushlightuserdatalua_pushlightuserdata.hslua"Pushes a nil value onto the stack.See  6https://www.lua.org/manual/5.3/manual.html#lua_pushnil lua_pushnil.hslua3Pushes a float with the given value onto the stack.See  9https://www.lua.org/manual/5.3/manual.html#lua_pushnumberlua_pushnumber.hsluaPushes 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: < 9https://www.lua.org/manual/5.3/manual.html#lua_pushstring lua_pushstring>.hslua2Pushes the current thread onto the stack. Returns True2 if this thread is the main thread of its state, False otherwise. See also:  9https://www.lua.org/manual/5.3/manual.html#lua_pushthreadlua_pushthread.hslua?Pushes a copy of the element at the given index onto the stack.See  8https://www.lua.org/manual/5.3/manual.html#lua_pushvalue lua_pushvalue.hsluaReturns True if the two values in indices idx1 and idx26 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:  7https://www.lua.org/manual/5.3/manual.html#lua_rawequal lua_rawequal.hslua Similar to 4, but does a raw access (i.e., without metamethods). See also:  5https://www.lua.org/manual/5.3/manual.html#lua_rawget lua_rawget.hslua 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:  6https://www.lua.org/manual/5.3/manual.html#lua_rawgeti lua_rawgeti.hsluaReturns 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:  5https://www.lua.org/manual/5.3/manual.html#lua_rawlen lua_rawlen.hslua Similar to 9, but does a raw assignment (i.e., without metamethods). See also:  5https://www.lua.org/manual/5.3/manual.html#lua_rawset lua_rawset.hsluaDoes 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:  6https://www.lua.org/manual/5.3/manual.html#lua_rawseti lua_rawseti.hsluaSets the C function f as the new value of global name.See  7https://www.lua.org/manual/5.3/manual.html#lua_register lua_register.hsluaRemoves 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  5https://www.lua.org/manual/5.3/manual.html#lua_remove lua_remove.hsluaMoves 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  6https://www.lua.org/manual/5.3/manual.html#lua_replace lua_replace.hsluaDoes 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  .https://www.lua.org/manual/5.3/manual.html#2.42.4# of the Lua 5.3 Reference Manual).4Errors on the Lua side are caught and rethrown as a . See also:  7https://www.lua.org/manual/5.3/manual.html#lua_setfield lua_setfield.hsluaPops a value from the stack and sets it as the new value of global name.4Errors on the Lua side are caught and rethrown as a . See also:  8https://www.lua.org/manual/5.3/manual.html#lua_setglobal lua_setglobal.hsluaPops 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>.hsluaDoes 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  .https://www.lua.org/manual/5.3/manual.html#2.42.4# of the Lua 5.3 Reference Manual).4Errors on the Lua side are caught and rethrown as a . See also:  7https://www.lua.org/manual/5.3/manual.html#lua_settable lua_settable.hsluaAccepts 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:  5https://www.lua.org/manual/5.3/manual.html#lua_settop lua_settop.hslua&Returns the status of this Lua thread.The status can be  for a normal thread, an error value if the thread finished the execution of a  lua_resume with an error, or  if the thread is suspended.3You can only call functions in threads with status &. You can resume threads with status  (to start a new coroutine) or  (to resume a coroutine). See also:  5https://www.lua.org/manual/5.3/manual.html#lua_status lua_status.hsluaConverts 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  to test the value's type.) See also:  8https://www.lua.org/manual/5.3/manual.html#lua_toboolean lua_toboolean.hsluaConverts a value at the given index to a C function. That value must be a C function; otherwise, returns Nothing. See also:  :https://www.lua.org/manual/5.3/manual.html#lua_tocfunctionlua_tocfunction.hsluaConverts the Lua value at the given acceptable index to the signed integral type 4. The Lua value must be an integer, a number or a string convertible to an integer (see  0https://www.lua.org/manual/5.3/manual.html#3.4.33.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:  8https://www.lua.org/manual/5.3/manual.html#lua_tointeger lua_tointeger.hsluaConverts 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 .See  7https://www.lua.org/manual/5.3/manual.html#lua_tonumber lua_tonumber.hsluaConverts 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:  8https://www.lua.org/manual/5.3/manual.html#lua_topointer lua_topointer.hslua/Converts the Lua value at the given index to a . The Lua value must be a string or a number; otherwise, the function returns !. If the value is a number, then  also changes the actual value in the stack to a string. (This change confuses  when . is applied to keys during a table traversal.)See  8https://www.lua.org/manual/5.3/manual.html#lua_tolstring lua_tolstring.hsluaConverts 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:  7https://www.lua.org/manual/5.3/manual.html#lua_tothread lua_tothread.hsluaIf 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:  9https://www.lua.org/manual/5.3/manual.html#lua_touserdatalua_touserdata.hslua2Returns the name of the type encoded by the value tp,, which must be one the values returned by . See also:  7https://www.lua.org/manual/5.3/manual.html#lua_typename lua_typename.hslua-Returns the pseudo-index that represents the i*-th upvalue of the running function (see  .https://www.lua.org/manual/5.3/manual.html#4.44.4# of the Lua 5.3 reference manual). See also:  ;https://www.lua.org/manual/5.3/manual.html#lua_upvalueindexlua_upvalueindex.hsluaindex1hsluaindex2 2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None ۺhslua Loads and runs the given string.Returns  on success, or an error if either loading of the string or calling of the thunk failed.hsluaLoads 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.hslua 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.hslua9Pushes 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.hslua8Push referenced value from the table at the given index.hsluaEnsures 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.hslua"Loads a ByteString as a Lua chunk.*This function returns the same results as . name is the chunk name, used for debug information and error messages. Note that name9 is used as a C string, so it may not contain null-bytes.See  :https://www.lua.org/manual/5.3/manual.html#luaL_loadbufferluaL_loadbuffer.hslua0Loads a file as a Lua chunk. This function uses lua_load (see ) 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 .*This function returns the same results as ", but it has an extra error code  for file-related errors (e.g., it cannot open or read the file).As :, this function only loads the chunk; it does not run it.1Note that the file is opened by Haskell, not Lua.See  8https://www.lua.org/manual/5.3/manual.html#luaL_loadfile luaL_loadfile.hslua2Loads 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 ).Also as :, this function only loads the chunk; it does not run it.See  :https://www.lua.org/manual/5.3/manual.html#luaL_loadstringluaL_loadstring.hslua3If 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:  betanon-portable (depends on GHC)None   !"#$%&'()*+,-./2345789>?@A74523 89%&'()*+,-./"#$>? !@A   2020 Albert KrewinkelMIT,Albert Krewinkel betaPortableNone hslua(Function to push a value to Lua's stack.hslua Pushes a  as a Lua boolean.hslua Pushes a " value as an UTF-8 encoded string.hslua Pushes a  as a raw string.hsluaPushes a lazy  as a raw string.hslua Pushes a  as an UTF-8 encoded Lua string.hslua Pushes an Integer to the Lua stack. Values representable as Lua integers are pushed as such; bigger integers are represented using their string representation.hsluaPush a floating point number to the Lua stack. Uses a string representation for all types which do not match the float properties of the 2 type.hslua'Push list as numerically indexed table.hsluaPush  as default key-value Lua table.hsluaPush a  as idiomatic Lua set, i.e., as a table with the set elements as keys and true as values.    2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel beta&FlexibleInstances, ScopedTypeVariablesNone >zhslua,A value that can be pushed to the Lua stack.hsluaPushes a value onto Lua stack, casting it into meaningfully nearest Lua type.hslua'Push list as numerically indexed table. 2020 Albert KrewinkelMIT,Albert Krewinkel betaPortableNone hslua.Function to retrieve a value from Lua's stack.hsluaList of errors which occurred while retrieving a value from the stack.hslua*Create a peek error from an error message.hslua*Add a message to the peek traceback stack.hsluaForce creation of a result, throwing an exception if that's not possible.hslua!Convert an old peek funtion to a .hslua Retrieves a  as a Lua boolean.hslua Retrieves a  as a raw string.hsluaRetrieves a lazy  as a raw string.hslua Retrieves a " from an UTF-8 encoded Lua string.hslua?Retrieves a String-like value from an UTF-8 encoded Lua string. This should not be used to peek 4 values or other values for which construction via $ can result in loss of information.hslua Retrieves a " value as an UTF-8 encoded string.hslua Retrieves an  value from the Lua stack.hslua Retrieve a  (e.g.,  or ) from the stack.hslua"Reads a numerically indexed table t into a list, where the  of the list is equal to #t/. The operation will fail if a numerical field n with  1 D n < #t is missing.hslua#Retrieves a key-value Lua table as .hslua"Read a table into a list of pairs.hslua Retrieves a  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.hslua!Makes a result optional. Returns  if the Lua value is nil6; otherwise applies the peeker and returns its result.hsluapeeker 2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None  >?shslua,A value that can be read from the Lua stack.hsluaCheck if at index n there is a convertible Lua value and if so return it. Throws a  otherwise.hsluaReport the expected and actual type of the value under the given index if conversion failed.hsluaRead a table into a listhslua"Read a table into a list of pairs. 2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None hslua0Push data by wrapping it into a userdata object.hsluaPush data by wrapping it into a userdata object, using the object at the top of the stack after performing the given operation as metatable.hsluaPush the metatable used to define the behavior of the given value in Lua. The table will be created if it doesn't exist yet.hslua)Retrieve data which has been pushed with .hslua)Retrieve data which has been pushed with ), where *name* must is the value of the __name field of the metatable.hslua:Retrieve Haskell data which was pushed to Lua as userdata.hsluaReturn the default name for userdata to be used when wrapping an object as the given type as userdata. The argument is never evaluated.hsluaoperation to push the metatablehsluaobject to push to Lua.hslua7name of the registered metatable which should be used.hsluaset additional properties; this operation will be called with the newly created metadata table at the top of the stack.hsluaexpected metatable name 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None t 2020 Albert KrewinkelMIT,Albert Krewinkel alphaPortableNone 5hslua+Documentation for the result of a function.hslua&Documentation for function parameters.hslua$Documentation for a Haskell functionhsluaHaskell equivallent to CFunction, i.e., function callable from Lua.hsluaFunction parameter.hsluaList of function results in the order in which they are returned in Lua.hslua'Result of a call to a Haskell function.hslua8Create a HaskellFunction precursor from a pure function.hsluaPartially apply a parameter.hsluaLike #, but returns only a single result.hsluaInline version of .hsluaInline version of .hsluaInline version of .hsluaCreates a parameter.hsluaCreates an optional parameter.hsluaCreates a function result.hslua!method to retrieve value from Luahsluaexpected Lua typehsluaparameter namehsluaparameter descriptionhslua%method to retrieve the value from Luahsluaexpected Lua typehsluaparameter namehsluaparameter descriptionhslua(method to push the Haskell result to LuahsluaLua type of resulthsluaresult description((888 2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None  hsluaNewtype wrapper intended to be used for optional Lua values. Nesting this type is strongly discouraged as missing values on inner levels are indistinguishable from missing values on an outer level; wrong values would be the likely result.hsluaRun Lua computation using the default HsLua state as starting point. Exceptions are masked, thus avoiding some issues when using multiple threads. All exceptions are passed through; error handling is the responsibility of the caller.hsluaRun Lua computation using the default HsLua state as starting point. Conversion from Lua errors to Haskell exceptions can be controlled through .hsluaRun the given Lua computation; exceptions raised in haskell code are caught, but other exceptions (user exceptions raised in haskell, unchecked type errors, etc.) are passed through.hsluaRun Lua computation with the given Lua state and the default error-to-exception converter. Exception handling is left to the caller.hsluaLike  getglobal2, but knows about packages and nested tables. E.g. getglobal' "math.sin"will return the function sin in package math.hsluaLike  setglobal2, but knows about packages and nested tables. E.g. 1pushstring "0.9.4" setglobal' "mypackage.version"=All tables and fields, except for the last field, must exist.hslua=Raise a Lua error, using the given value as the error object.hslua8Get a value by retrieving a String from Lua, then using - to convert the String into a Haskell value.hsluaTry to convert the value at the given stack index to a Haskell value. Returns Left" with an error message on failure.betaFlexibleInstances, ForeignFunctionInterface, ScopedTypeVariablesNone  >? hslua raiseError (e :: FooException)))hsluaCreate new foreign Lua function. Function created can be called by the Lua engine. Remeber to free the pointer with  freecfunction.hslua#Free function pointer created with  newcfunction.hsluaCall a Lua function. Use as: 1v <- callfunc "proc" "abc" (1::Int) (5.0::Double)hslua;Imports a Haskell function and registers it at global name.hsluaPushes Haskell function as a callable userdata. All values created will be garbage collected. Use as: +pushHaskellFunction myfun setglobal "myfun"6Error conditions should be indicated by raising a Lua  or by returning the result of .hsluaConverts a pre C function to a Lua function and pushes it to the stack.Pre C functions collect parameters from the stack and return a ; that represents number of return values left on the stack. 2019-2020 Albert KrewinkelMIT,Albert Krewinkel alphaRequires GHC 8 or later.None y hsluaSelf-documenting module fieldhslua Named and documented Lua module.hsluaLoad a module, defined by a Haskell action, under the given name. Similar to  luaL_required(: After checking "loaded" table, calls pushMod= to push a module to the stack, and registers the result in package.loaded table.The pushMod function must push exactly one element to the top of the stack. This is not checked, but failure to do so will lead to problems. Lua's package module must have been loaded by the time this function is invoked.)Leaves a copy of the module on the stack.hsluaRegisters a preloading function. Takes an module name and the Lua operation which produces the package.hsluaAdd a string-indexed field to the table at the top of the stack.hsluaAttach a function to the table at the top of the stack, using the given name.hslua(Create a new module (i.e., a Lua table).hslua Registers a 2; leaves a copy of the module table on the stack.hslua Preload self-documenting module.hslua)Renders module documentation as Markdown." 2007@2012 Gracjan Polak, 2012@2016 mer Sinan Aacan, 2017-2020 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None   ! "#$%/.-,+*)(&'2345789>?@A%#$%&&'(()**+,-./01234556789:;<=>?@ABCCDEFGHIJKLMNOPPQQRSTTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                          #########$hslua-1.3.0.1-E0DUOF9wqszLOuDXHQ8B5LForeign.Lua.Core.TypesForeign.Lua.Raw.TypesForeign.Lua.Raw.FunctionsForeign.Lua.Raw.ConstantsForeign.Lua.Raw.CallForeign.Lua.Raw.AuxiliaryForeign.Lua.Raw.ErrorForeign.Lua.Raw.UserdataForeign.Lua.Utf8Foreign.Lua.Core.ErrorForeign.Lua.CoreForeign.Lua.PushForeign.Lua.Types.PushableForeign.Lua.PeekForeign.Lua.Types.PeekableForeign.Lua.UserdataForeign.Lua.CallForeign.Lua.UtilForeign.Lua.FunctionCallingForeign.Lua.ModuleLuaNumberForeign.Lua.Core.FunctionsloadgettopForeign.Lua.Core.RawBindingsForeign.Lua.Core.ConstantsForeign.Lua.Core.AuxiliaryrefnilnorefForeign.Lua.TypesControl.Monad.Catch MonadCatch Foreign.LuabaseControl.Monad.IO.ClassliftIO NumResultsfromNumResultsNumArgs fromNumArgs StackIndexfromStackIndex GCCONTROLGCSTOP GCRESTART GCCOLLECTGCCOUNTGCCOUNTBGCSTEP GCSETPAUSE GCSETSTEPMUL StatusCodeStatusOKYieldErrRun ErrSyntaxErrMemErrErrErrGcmmErrFileRelationalOperatorEQLTLETypeCode fromTypeCodeTypeTypeNoneTypeNil TypeBooleanTypeLightUserdata TypeNumber TypeString TypeTable TypeFunction TypeUserdata TypeThreadLuaBoolIntegerReader CFunctionStatetruefalse fromLuaBool toLuaBoolfromTypetoTypefromRelationalOperatortoStatus $fEnumType$fEqNumResults$fNumNumResults$fOrdNumResults$fShowNumResults $fEqNumArgs $fNumNumArgs $fOrdNumArgs $fShowNumArgs$fEnumStackIndex$fEqStackIndex$fNumStackIndex$fOrdStackIndex$fShowStackIndex$fEnumGCCONTROL $fEqGCCONTROL$fOrdGCCONTROL$fShowGCCONTROL$fEqStatusCode$fStorableStatusCode $fEqStatus $fShowStatus$fEqRelationalOperator$fOrdRelationalOperator$fShowRelationalOperator $fEqTypeCode $fOrdTypeCode$fShowTypeCode $fBoundedType$fEqType $fOrdType $fShowType $fEqLuaBool$fStorableLuaBool $fShowLuaBool $fEqNumber$fFloatingNumber$fFractionalNumber $fNumNumber $fOrdNumber $fRealNumber$fRealFloatNumber$fRealFracNumber $fShowNumber$fBoundedInteger $fEnumInteger $fEqInteger$fIntegralInteger $fNumInteger $fOrdInteger $fRealInteger $fShowInteger $fEqState$fGenericStatelua_open_package_ptrlua_open_debug_ptrlua_open_math_ptrlua_open_string_ptrlua_open_os_ptrlua_open_io_ptrlua_open_table_ptrlua_open_base_ptr luaL_openlibslua_pushglobaltable hslua_concat hslua_next hslua_errorlua_gc lua_statuslua_load lua_pcallhslua_setgloballua_setmetatable lua_rawseti lua_rawsethslua_settablehslua_getgloballua_getmetatablelua_newuserdatalua_createtable lua_rawgeti lua_rawgethslua_gettablelua_pushthreadlua_pushlightuserdatalua_pushbooleanlua_pushcclosurelua_pushlstringlua_pushintegerlua_pushnumber lua_pushnil lua_rawlenlua_touserdata lua_tothread lua_topointer lua_tolstring lua_tonumberxlua_tointegerxlua_tocfunction lua_toboolean lua_rawequal hslua_compare lua_typenamelua_typelua_isuserdatalua_iscfunction lua_isstring lua_isinteger lua_isnumberlua_checkstack lua_replace lua_insert lua_removelua_copylua_pop lua_pushvalue lua_settop lua_gettop lua_absindex lua_close registryindexmultret HsFunctionhslua_newhsfunctionhslua_pushhsfunction ReferenceRefNilluaL_testudata luaL_unrefluaL_tracebackhsluaL_tolstringluaL_refhsluaL_newstateluaL_newmetatableluaL_loadbufferluaL_getmetatableluaL_getmetafieldloadedTableRegistryFieldpreloadTableRegistryField fromReference toReference $fEqReference$fShowReference errorMessageunLuaLuaEnvironmentluaEnvErrorConversion luaEnvStateErrorConversionerrorToExceptionaddContextToException alternativeexceptionToErrorliftLualiftLua1stateerrorConversionrunWithConverter unsafeRunWithunsafeErrorConversion nthFromTopnth nthFromBottomtopstackTop stackBottom$fApplicativeLua $fFunctorLua $fMonadLua$fMonadCatchLua $fMonadIOLua$fMonadMaskLua$fMonadReaderLuaEnvironmentLua$fMonadThrowLuahslua_newudmetatablehslua_newhsuserdatahslua_fromuserdatatoStringtoText fromStringfromText ExceptionexceptionMessagethrowExceptioncatchExceptionwithExceptionMessagetrythrowErrorAsExceptionthrowTopMessage throwMessagethrowTopMessageWithState liftLuaThrow$fAlternativeLua$fExceptionException$fShowException $fEqExceptionabsindexcall checkstackclosecompareconcatcopy createtableequalerrorgcgetfield getglobal getmetatablegettableinsert isboolean iscfunction isfunction isintegerislightuserdataisnilisnone isnoneornilisnumberisstringistableisthread isuserdatalessthanltypenewtable newuserdatanextopenlibsopenbase opendebugopenioopenmathopenos openpackage openstring opentablepcallpop pushboolean pushcclosure pushcfunctionpushglobaltable pushintegerpushlightuserdatapushnil pushnumber pushstring pushthread pushvaluerawequalrawgetrawgetirawlenrawsetrawsetiregisterremovereplacesetfield setglobal setmetatablesettablesettopstatus toboolean tocfunction tointegertonumber topointertostringtothread touserdatatypename upvalueindexdostringdofile getmetafield getmetatable'getref getsubtable loadbufferloadfile loadstring newmetatablenewstateref tostring' tracebackunrefPusherpushBoolpushTextpushByteStringpushLazyByteString pushString pushIntegral pushRealFloatpushListpushMappushSetPushablepush$fPushable(,,,,,,,)$fPushable(,,,,,,)$fPushable(,,,,,)$fPushable(,,,,)$fPushable(,,,)$fPushable(,,) $fPushable(,) $fPushableSet $fPushableMap $fPushable[] $fPushable[]0$fPushableDouble$fPushableFloat $fPushableInt$fPushableInteger$fPushableByteString$fPushableText $fPushablePtr$fPushableFunPtr$fPushableBool$fPushableByteString0$fPushableNumber$fPushableInteger0 $fPushable()Peeker PeekError fromPeekErrorformatPeekErrorerrorMsgpushMsgforcetoPeekerpeekBoolpeekByteStringpeekLazyByteString peekString peekStringypeekText peekIntegral peekRealFloatpeekListpeekMappeekKeyValuePairspeekSetoptional $fEqPeekError$fShowPeekErrorPeekablepeekreportValueOnFailure$fPeekable(,,,,,,,)$fPeekable(,,,,,,)$fPeekable(,,,,,)$fPeekable(,,,,)$fPeekable(,,,)$fPeekable(,,) $fPeekable(,) $fPeekableSet $fPeekableMap $fPeekable[] $fPeekable[]0$fPeekableDouble$fPeekableFloat $fPeekableInt$fPeekableInteger$fPeekableByteString$fPeekableText$fPeekableState $fPeekablePtr$fPeekableFunPtr$fPeekableBool$fPeekableByteString0$fPeekableNumber$fPeekableInteger0 $fPeekable()pushAnypushAnyWithMetatableensureUserdataMetatabletoAny toAnyWithNamepeekAny metatableNameFunctionResultDocfunctionResultTypefunctionResultDescription ParameterDoc parameterName parameterTypeparameterDescriptionparameterIsOptional FunctionDocfunctionDescription parameterDocsfunctionResultDocsHaskellFunction callFunction functionDoc ParameterparameterPeeker parameterDocFunctionResultsFunctionResultfnResultPusher fnResultDoctoHsFnPrecursortoHsFnPrecursorWithStartIndexapplyParameter returnResult<#>=#>#?renderpushHaskellFunction parameteroptionalParameterfunctionResult$fFunctorHsFnPrecursor$fEqFunctionDoc$fOrdFunctionDoc$fShowFunctionDoc$fEqFunctionResultDoc$fOrdFunctionResultDoc$fShowFunctionResultDoc$fEqParameterDoc$fOrdParameterDoc$fShowParameterDocOptional fromOptionalrunrun' runEitherrunWith getglobal' setglobal' raiseErrorpeekRead peekEitherpopValue$fPushableOptional$fPeekableOptional LuaCallFunc callFunc'ToHaskellFunctiontoHsFun PreCFunctiontoHaskellFunction newCFunction freeCFunctioncallFuncregisterHaskellFunctionpushPreCFunction$fToHaskellFunction->$fToHaskellFunctionLua$fToHaskellFunctionLua0$fLuaCallFunc->$fLuaCallFuncLuaField fieldNamefieldDescriptionfieldPushValueModule moduleNamemoduleDescription moduleFieldsmoduleFunctions requirehs preloadhsaddfield addfunctioncreateregisterModule preloadModule pushModuleForeign.C.TypesCIntghc-prim GHC.TypesFalseTrueDoubleGHC.IntInt64Boolbytestring-0.10.10.0Data.ByteString.Internal ByteStringGHC.BaseString text-1.2.3.2Data.Text.InternalText ensureTable GHC.MaybeNothingData.ByteString.Lazy.Internalcontainers-0.6.2.1Data.Map.InternalMapData.Set.InternalSet Data.StringGHC.RealIntegral GHC.Float RealFloatFloat Data.FoldablelengthupdateFunctionDescription Text.Read readMaybe