h$d3      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       2018-2022 Albert KrewinkelMIT,Albert Krewinkel betaportable Safe-Inferred hslua-coreDecode  to  using UTF-8. Invalid input bytes are replaced with the Unicode replacement character U+FFFD. hslua-coreDecode  to  using UTF-8. Invalid input bytes are replaced with the Unicode replacement character U+FFFD.  hslua-coreEncode  to  using UTF-8.! hslua-coreEncode  to  using UTF-8. ! ! 2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2022 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None18" hslua-coreName of a function, table field, or chunk; the name must be valid UTF-8 and may not contain any nul characters.Implementation note: this is a newtype instead of a simple type Name = ByteString& alias so we can define a UTF-8 based < instance. Non-ASCII users would have a bad time otherwise.% hslua-core*Commands to control the garbage collector.& hslua-corestops the garbage collector.' hslua-corerestarts the garbage collector( hslua-core)performs a full garbage-collection cycle.) hslua-corereturns the current amount of memory (in Kbytes) in use by Lua.* hslua-corereturns the remainder of dividing the current amount of bytes of memory in use by Lua by 1024.+ hslua-core4performs an incremental step of garbage collection., hslua-coresets data as the new value for the pause of the collector (see < .https://www.lua.org/manual/5.3/manual.html#2.5 2.5> of the Lua reference manual) and returns the previous value of the pause.- hslua-coresets data as the new value for the step multiplier of the collector (see < .https://www.lua.org/manual/5.3/manual.html#2.5 2.5> of the Lua reference manual) and returns the previous value of the step multiplier.. hslua-corereturns a boolean that tells whether the collector is running (i.e., not stopped)./ hslua-coreLua comparison operations.0 hslua-core+Correponds to Lua's equality (==) operator.1 hslua-core5Correponds to Lua's strictly-lesser-than (<) operator2 hslua-core1Correponds to Lua's lesser-or-equal (<=) operator3 hslua-coreLua status values.4 hslua-coresuccess5 hslua-coreyielding / suspended coroutine6 hslua-corea runtime rror7 hslua-core"syntax error during precompilation8 hslua-core(memory allocation (out-of-memory) error.9 hslua-core(error while running the message handler.: hslua-coreerror while running a __gc metamethod.; hslua-core!opening or reading a file failed.< hslua-core#Enumeration used as type tag. See  3https://www.lua.org/manual/5.3/manual.html#lua_typelua_type.= hslua-corenon-valid stack index> hslua-coretype of Lua's nil value? hslua-coretype of Lua booleans@ hslua-coretype of light userdataA hslua-coretype of Lua numbers. See   B hslua-coretype of Lua string valuesC hslua-coretype of Lua tablesD hslua-core$type of functions, either normal or  E hslua-coretype of full user dataF hslua-coretype of Lua threadsG hslua-coreHaskell function that can be called from Lua. The HsLua equivallent of a  .H hslua-coreA 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 P.K hslua-core4Environment in which Lua computations are evaluated.M hslua-coreLua interpreter stateN hslua-coreTurn a function of typ Lua.State -> IO a into a monadic Lua operation.O hslua-coreTurn a function of typ Lua.State -> a -> IO b into a monadic Lua operation.P hslua-core*Get the Lua state of this Lua computation.Q hslua-coreRun Lua computation with the given Lua state. Exception handling is left to the caller; resulting exceptions are left unhandled.R hslua-coreRun the given operation, but crash if any Haskell exceptions occur.S hslua-coreConvert a Lua <2 to a type code which can be passed to the C API.T hslua-coreConvert numerical code to Lua <.U hslua-coreConvert C integer constant to 3.V hslua-core2Convert relation operator to its C representation.W hslua-core Convert a  to a Haskell .X hslua-coreConvert a Haskell  to a .Y hslua-core7Converts a GCControl command to its corresponding code.Z hslua-core;Returns the data value associated with a GCControl command.[ hslua-coreOption for multiple returns in  .\ hslua-core'Pseudo stack index of the Lua registry.] hslua-core.Value signaling that no reference was created.^ hslua-core,Value signaling that no reference was found.  "#$%&'()*+,-./1023546789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^HIJKLM NOPQR%&'()*+,-.YZ<=>?@ABCDEFST GWX\[/102V3546789:;U ^]"#$ 2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2022 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)Noney hslua-coreCreates a new userdata wrapping the given Haskell object. The userdata is pushed to the top of the stack.z hslua-coreCreates 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.Using a metatable created by this functions ensures that the pointer to the Haskell value will be freed when the userdata object is garbage collected in Lua.)The name may not contain a nul character.{ hslua-coreRetrieves a Haskell object from userdata at the given index. The userdata must have the given name.| hslua-core?Replaces the Haskell value contained in the userdata value at index&. Checks that the userdata is of type name and returns  on success, or  otherwise.{ hslua-corestack index of userdata hslua-core expected name of userdata object| hslua-coreindex hslua-corename hslua-core new valueyz{|yz{| 2019-2022 Albert KrewinkelMIT,Albert Krewinkel Nonen} hslua-core Wrapper for .WARNING: lua_next is unsafe in Haskell: This function will cause an unrecoverable crash an error if the given key is neither nil4 nor present in the table. Consider using the safe  function in HsLua.Core instead.}} 2017-2022 Albert KrewinkelMIT,Albert Krewinkel None 3(.~ hslua-coreDefault Lua error type. Exceptions raised by Lua-related operations. hslua-coreAny type that you wish to use for error handling in HsLua must be an instance of the LuaError class. hslua-coreConverts the error at the top of the stack into an exception and pops the error off the stack.This function is expected to produce a valid result for any Lua value; neither a Haskell exception nor a Lua error may result when this is called. hslua-corePushes an exception to the top of the Lua stack. The pushed Lua object is used as an error object, and it is recommended that calling  tostring()/ on the object produces an informative message. hslua-core/Creates a new exception with the given message. hslua-coreA Lua operation.This type is suitable for most users. It uses a default exception for error handling. Users who need more control over error handling can use H" with a custom error type instead. hslua-coreReturn either the result of a Lua computation or, if an exception was thrown, the error. hslua-core%Raises an exception in the Lua monad. hslua-coreConverts a Lua error at the top of the stack into a Haskell exception and throws it. hslua-coreRaises an exception that's appropriate when the type of a Lua object at the given index did not match the expected type. The name or description of the expected type is taken as an argument. hslua-core'Change the error type of a computation. hslua-coreTakes a failable HsLua function and transforms it into a monadic H5 operation. Throws an exception if an error occured. hslua-coreRetrieve 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.:This helpful as a "last resort" method when implementing . hslua-coreCreates an error to notify about a Lua type mismatch and pushes it to the stack. hslua-core$name or description of expected type hslua-core!stack index of mismatching object~~ 2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2022 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None  hslua-coreExecute an action only if the given index is a table. Throw an error otherwise. hslua-coreConverts the acceptable index idx into an equivalent absolute index (that is, one that does not depend on the stack top).Wraps . hslua-coreCalls 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 is propagated as exception of type e.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-core.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.Wraps . hslua-coreDestroys 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.Same as . hslua-core!Compares two Lua values. Returns  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 /:EQ: compares for equality (==) LT: compares for less than (<) LE: compares for less or equal (<=)Wraps  . See also  6https://www.lua.org/manual/5.3/manual.html#lua_compare lua_compare. hslua-coreConcatenates 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).Wraps  . See also  5https://www.lua.org/manual/5.3/manual.html#lua_concat lua_concat. hslua-coreCopies the element at index fromidx into the valid index toidx, replacing the value at that position. Values at other positions are not affected.Wraps . hslua-coreCreates 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.Wraps . hslua-coreReturns 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. hslua-coreSignals to Lua that an error has occurred and that the error object is at the top of the stack. hslua-coreControls the garbage collector.This function performs several tasks, according to the given control command. See the documentation for %.Wraps . hslua-core 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).&Errors on the Lua side are propagated. See also  7https://www.lua.org/manual/5.3/manual.html#lua_getfield lua_getfield. hslua-core.Pushes onto the stack the value of the global name.&Errors on the Lua side are propagated.Wraps . hslua-coreIf 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.Wraps . hslua-core 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)./Errors on the Lua side are caught and rethrown.Wraps  . See also:  7https://www.lua.org/manual/5.3/manual.html#lua_gettable lua_gettable. hslua-coreReturns 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).Wraps . hslua-corePushes onto the stack the Lua value associated with the full userdata at the given index.%Returns the type of the pushed value.Wraps . hslua-coreMoves 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.Wraps . hslua-coreReturns 4 if the value at the given index is a boolean, and  otherwise.Wraps . hslua-coreReturns 7 if the value at the given index is a C function, and  otherwise.Wraps . hslua-coreReturns  if the value at the given index is a function (either C or Lua), and  otherwise.Wraps . hslua-coreReturns 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  otherwise.Wraps . hslua-coreReturns True; if the value at the given index is a light userdata, and False otherwise.Wraps . hslua-coreReturns 0 if the value at the given index is *nil*, and  otherwise.Wraps . hslua-coreReturns & if the given index is not valid, and  otherwise.Wraps . hslua-coreReturns  if the given index is not valid or if the value at the given index is *nil*, and  otherwise.Wraps . hslua-coreReturns  if the value at the given index is a number or a string convertible to a number, and  otherwise.Wraps . hslua-coreReturns  if the value at the given index is a string or a number (which is always convertible to a string), and  otherwise.Wraps . hslua-coreReturns 2 if the value at the given index is a table, and  otherwise.Wraps . hslua-coreReturns 3 if the value at the given index is a thread, and  otherwise.Wraps . hslua-coreReturns  if the value at the given index is a userdata (either full or light), and  otherwise.Wraps . hslua-coreTests whether the object under the first index is smaller than that under the second. Uses  internally. hslua-coreLoads 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:4 : no errors;7&: syntax error during pre-compilation;8: 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 ). 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.This is a wrapper of . hslua-core of the Lua 5.3 reference manual). See also:  ;https://www.lua.org/manual/5.3/manual.html#lua_upvalueindexlua_upvalueindex. hslua-coreidx1 hslua-coreidx2 hslua-coreindex1 hslua-coreindex2 hslua-coren  hslua-core idx hslua-core n hslua-corename  2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2022 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None hslua-coreConverts 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 CInt that represents number of return values left on the stack. See  for more info. hslua-corePushes Haskell function as a callable userdata. All values created will be garbage collected. The function should behave similar to a .Error conditions should be indicated by raising a catchable exception or by returning the result of  .Example: mod23 :: Lua NumResults mod23 = do mn <- tointeger (nthBottom 1) case mn of Nothing -> pushstring "expected an integer" *> error Just n -> pushinteger (n `mod` 23) pushHaskellFunction mod23 setglobal "mod23" 2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2022 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None  hslua-coreGrows the stack size to top + sz elements, raising an error if the stack cannot grow to that size. msg is an additional text to go into the error message (or the empty string for no additional text). hslua-core Loads and runs the given string.Returns 4 on success, or an error if either loading of the string or calling of the thunk failed. hslua-coreLoads and runs the given file. Note that the filepath is interpreted by Lua, not Haskell. The resulting chunk is named using the UTF8 encoded filepath. hslua-core 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 >.Wraps . hslua-core9Pushes onto the stack the metatable associated with name tname in the registry (see ) (nil if there is no metatable associated with that name). Returns the type of the pushed value.Wraps . hslua-core8Push referenced value from the table at the given index. hslua-coreEnsures 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-core"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.Wraps . hslua-core0Loads 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.See  8https://www.lua.org/manual/5.3/manual.html#luaL_loadfile luaL_loadfile. hslua-core2Loads 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. hslua-core3If 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.Wraps . hslua-core"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  .https://www.lua.org/manual/5.3/manual.html#4.64.6 of the Lua 5.3 Reference Manual) that prints an error message to the standard error output in case of fatal errors.Wraps  . See also:  8https://www.lua.org/manual/5.3/manual.html#luaL_newstate luaL_newstate. hslua-core7Creates 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 . frees a reference and its associated object..If the object at the top of the stack is nil,  returns the constant ]. The constant ^? is guaranteed to be different from any reference returned by .Wraps . hslua-coreIf modname is not already present in package.loaded. calls function openf with string modname- as an argument and sets the call result in package.loaded[modname]0, as if that function has been called through  6https://www.lua.org/manual/5.3/manual.html#pdf-requirerequire.If glb- is true, also stores the module into global modname.)Leaves a copy of the module on the stack.See  requirehs9 for a version intended to be used with Haskell actions. hslua-core/Converts any Lua value at the given index to a  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.Wraps . hslua-coreCreates and pushes a traceback of the stack L1. If a message is given it is appended at the beginning of the traceback. The level parameter tells at which level to start the traceback.Wraps . hslua-coreReleases reference  from the table at index idx (see ). The entry is removed from the table, so that the referred object can be collected. The reference ! is also freed to be used again.Wraps  . See also:  5https://www.lua.org/manual/5.3/manual.html#luaL_unref luaL_unref. hslua-corePushes onto the stack a string identifying the current position of the control at level lvl in the call stack. Typically this string has the following format: chunkname:currentline:Level0 is the running function, level1 is the function that called the running function, etc.;This function is used to build a prefix for error messages. hslua-coreKey to the registry field that holds the table of loaded modules. hslua-coreKey to the registry field that holds the table of loader functions.  hslua-coresz (requested additional size) hslua-coremsg hslua-coreobj hslua-coree hslua-coretname hslua-coreidx hslua-corefname hslua-coreProgram to load hslua-core chunk name hslua-corefilename hslua-coremodname hslua-coreopenf hslua-coreglb hslua-coreidx hslua-coreref hslua-corelvl 2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2022 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None hslua-coreRun 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. hslua-coreRun 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.QQ  2017-2022 Albert KrewinkelMIT,Albert Krewinkel None[ hslua-coreLike , but sets an appropriate message handler function, thereby adding a stack traceback if an error occurs. hslua-coreLike call*, but adds a traceback if an error occurs. hslua-coreRun the given file as a Lua program, while also adding a traceback to the error message if an error occurs.  2019-2022 Albert KrewinkelMIT,Albert Krewinkel alphaRequires GHC 8 or later.None hslua-coreLoad a module, defined by a Haskell action, under the given name. Similar to  luaL_requiref: If modname is not already present in package.loaded, calls function openf with string modname- as an argument and sets the call result in package.loaded[modname]0, as if that function has been called through  6https://www.lua.org/manual/5.3/manual.html#pdf-requirerequire.)Leaves a copy of the module on the stack. hslua-coreRegisters a preloading function. Takes an module name and the Lua operation which produces the package. hslua-coremodname hslua-coreopenf 2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2022 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None  "#$%&'()*+,-./1023546789:;<=>?@ABCDEFGHIJKLMPQR[\]^yz{|~QHIJRPKLM "#$[\ <=>?@ABCDEF/1023546789:;%&'()*+,-. ^]yz{|G~      !!"#$$  %%&''())*++,-./00123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU VWWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~        'hslua-core-2.1.0-93VfFgWuwzKDOBNMnIJscRHsLua.Core.TypesHsLua.Core.Utf8HsLua.Core.UserdataHsLua.Core.UnsafeHsLua.Core.Error HsLua.CoreHsLua.Core.ClosuresHsLua.Core.RunHsLua.Core.TraceHsLua.Core.PackageLuaNumberpcallnextHsLua.Core.Primary Lua.Types CFunctionerrorHsLua.Core.AuxiliarybaseControl.Monad.IO.ClassliftIO lua-2.1.0-50abnCNjzmU63xKvfaiiHttopnth nthBottomnthTop Lua.Auxiliary toReference fromReferenceRefNil ReferenceState PreCFunctionReaderIntegerLuaBoolfromStackIndex StackIndex fromNumArgsNumArgsfromNumResults NumResultstoStringtoText fromStringfromTextNamefromName GCControlGCStop GCRestart GCCollectGCCountGCCountbGCStep GCSetPause GCSetStepMul GCIsRunningRelationalOperatorEQLTLEStatusOKYieldErrRun ErrSyntaxErrMemErrErrErrGcmmErrFileTypeTypeNoneTypeNil TypeBooleanTypeLightUserdata TypeNumber TypeString TypeTable TypeFunction TypeUserdata TypeThreadHaskellFunctionLuaEunLuaLuaEnvironment luaEnvStateliftLualiftLua1staterunWith unsafeRunWithfromTypetoTypetoStatusfromRelationalOperator fromLuaBool toLuaBooltoGCcodetoGCdatamultret registryindexrefnilnoref $fEnumType$fIsStringName$fEqName $fOrdName$fSemigroupName $fShowName $fEqGCControl$fOrdGCControl$fShowGCControl$fEqRelationalOperator$fOrdRelationalOperator$fShowRelationalOperator $fEqStatus $fShowStatus $fBoundedType$fEqType $fOrdType $fShowType$fApplicativeLuaE $fFunctorLuaE $fMonadLuaE$fMonadCatchLuaE $fMonadIOLuaE$fMonadMaskLuaE$fMonadReaderLuaEnvironmentLuaE$fMonadThrowLuaE newhsuserdatanewudmetatable fromuserdata putuserdata ExceptionexceptionMessageLuaError popException pushException luaExceptiontryfailLuathrowErrorAsExceptionthrowTypeMismatchErrorchangeErrorType liftLuaThrowpopErrorMessagepushTypeMismatchError$fMonadFailLuaE$fAlternativeLuaE$fLuaErrorException$fExceptionException$fShowException $fEqExceptionabsindexcall checkstackclosecompareconcatcopy createtableequalgcgetfield getglobal getmetatablegettablegettop getuservalueinsert isboolean iscfunction isfunction isintegerislightuserdataisnilisnone isnoneornilisnumberisstringistableisthread isuserdatalessthanloadltypenewtable newuserdataopenlibsopenbase opendebugopenioopenmathopenos openpackage openstring opentablepop pushboolean pushcclosure pushcfunctionpushglobaltable pushintegerpushlightuserdatapushnil pushnumber pushstring pushthread pushvaluerawequalrawgetrawgetirawlenrawsetrawsetiregisterremovereplacerotatesetfield setglobal setmetatablesettablesettop setuservaluestatus toboolean tocfunction tointegertonumber topointertostringtothread touserdatatypename upvalueindexpushPreCFunctionpushHaskellFunction checkstack'dostringdofile getmetafield getmetatable'getref getsubtable loadbufferloadfile loadstring newmetatablenewstaterefrequiref tostring' tracebackunrefwhere'loadedpreloadrun runEither pcallTrace callTrace dofileTrace dostringTrace requirehs preloadhsbytestring-0.10.10.0Data.ByteString.Internal ByteStringGHC.BaseString text-1.2.3.2Data.Text.InternalText Data.StringIsStringghc-prim GHC.TypesBoolTrueFalse Lua.Primarylua_next ensureTable lua_absindexlua_checkstack lua_closeLua.Ersatz.Functions hslua_compare hslua_concatlua_copylua_createtablelua_gchslua_getgloballua_getmetatablehslua_gettable lua_gettoplua_getuservalue lua_insert lua_isbooleanlua_iscfunctionlua_isfunction lua_isintegerlua_islightuserdata lua_isnil lua_isnonelua_isnoneornil lua_isnumber lua_isstring lua_istable lua_isthreadlua_isuserdatalua_loadlua_typelua_newuserdata hslua_next luaL_openlibsLua.Lib luaopen_base luaopen_io luaopen_math luaopen_osluaopen_packageluaopen_string luaopen_table lua_pcalllua_pushbooleanlua_pushcclosurelua_pushglobaltablelua_pushintegerlua_pushlightuserdata lua_pushnillua_pushnumberlua_pushlstringlua_pushthread lua_pushvalue lua_rawequal lua_rawget lua_rawgeti lua_rawlen lua_rawset lua_rawseti lua_remove lua_replacehslua_setgloballua_setmetatablehslua_settable lua_settop lua_status lua_tobooleanlua_tocfunctionlua_tointegerx GHC.MaybeNothing lua_tonumberx lua_topointer lua_tolstring lua_tothreadlua_touserdata lua_typenameluaL_getmetafieldluaL_getmetatableluaL_loadbufferluaL_newmetatableLua.Ersatz.AuxiliaryhsluaL_newstateluaL_refhsluaL_tolstringluaL_traceback luaL_unref