Compatibility updates.

Released 2021-11-04.

• Updated lower bounds of hslua packages:

  • hslua >= 2.0.0.2,
  • hslua-marshalling >= 2.0.1, and
  • hslua-objectorientation >= 2.0.1.

  This fixes a number of smaller issues; see the respective
  package changelogs for details.

hslua-2.0.0

Released 2021-10-21.

• Moved module hierarchy from Foreign.Lua to HsLua.

• Error handling has been reworked completely. The type of
  exceptions used and handled by HsLua is now exposed to the type
  system. The type Lua makes use of a default error type. Custom
  error handling can be implemented by using the LuaE type with
  an exception type that is an instance of class LuaError.

• Renamed stack index helpers to nth, nthTop, nthBottom,
  top. The following have been removed: stackTop,
  nthFromTop, nthFromBottom.

• Extracted raw Lua bindings into new package lua. This means
  that all cabal flags have been moved to package lua as well.
  Version lua-1.0.0 contained the Foreign.Lua.Raw hierarchy as
  present in hslua-1.3.0. See that package's changelog for
  info on the additional modifications since then.

• The module Foreign.Lua.Raw.Error was merged into the
  HsLua.Core.Error module.

• The functions getglobal and gettable now return the Lua
  Type of the pushed value.

• Extracted new packages:

  • hslua-core: the package contains all modules from the
    Core sub-hierarchy.
  • hslua-classes: typclasses Peekable and Pushable for
    pushing and pulling, as well as function calling.
  • tasty-hslua: makes testing helpers available for reuse.

• Moved run functions from Util to Core.Run.

• Moved module Utf8 from the base level into Core.

• Refactored code to expose Haskell functions to Lua:

  • Removed functions newCFunction, freeCFunction. Use
    pushHaskellFunction instead, it takes care of garbage
    collection.

  • Renamed typeclass ToHaskellFunction to Exposable,
    function callFunc to invoke. All these have been moved
    to hslua-classes.

  • The type PreCFunction is now defined in package lua;
    HaskellFunction is defined in hslua-core.

  • Changed pushHaskellFunction to only accept HaskellFunction
    arguments, move it to hslua-core.

  • Removed helper functions addfunction and addfield from
    Module. Use documented functions and fields instead.

• Added support for a "since" tag on documented functions; allows
  to mark the library version when a function was introduced in
  its present form.

Released 2020-10-16.

• Upgrade included Lua version to new bug-fix release 5.3.6. See
  the upstream documentation https://www.lua.org/bugs.html#5.3.5
  for the bugs which have been fixed.

• Stop exporting c_loaded_table and c_prelad_table from module
  Foreign.Lua.Raw.Auxiliary. Both values are defined only if the
  flag HARDCODE_REG_KEYS is disabled, leading to compilation
  errors when the flag is enabled.

• Add new function peekStringy to Peek module. It allows to peek
  a value of any IsString type from an UTF-8 encoded string.

• Various improvements to the continuous integration setup,
  including cleanup of the config files, version bumps to the
  ghc/cabal versions used for testing, and running the linter in a
  dedicated GitHub Action.

Released 2020-08-15

• New module Foreign.Lua.Call: the module offers an alternative
  method of exposing Haskell functions to Lua. The focus is on
  maintainability: types and marshaling methods are made explicit;
  the possibility of adding documentation and parameter names
  improves error messages and allows for automatic documentation
  extraction.

  Work on this module is ongoing; the interface is likely to
  change. Suggestions and feedback are welcome.

• New types Module, Field, and new functions registerModule,
  preloadModule, pushModule, and render exported from
  Foreign.Lua.Module: this builds on the new Call module and
  allows the creation of documented modules as well as automatic
  generation of Markdown-formatted module documentation.

• Export new items nth and top from Foreign.Lua.Core and
  Foreign.Lua. They are short-hands for nthFromTop and
  stackTop.

• Performance improvements: Calling of Lua functions and creation
  of Haskell data wrapping userdata has been sped up by about 10%.
  This is mostly due to using of previously missed optimization
  opportunities.

• All foreign imports have been moved to into the new
  Foreign.Lua.Raw module. This module will replace the current
  Foreign.Lua.Core module in the future and will be distributed
  as a separate package (likely starting with the 2.0 release);
  the remaining parts of the current Core module will be
  promoted one level in the module hierarchy.

  The Raw module can be used whenever the full power of HsLua is
  not needed.

• Error-signaling of API wrapper functions has been changed:
  instead of returning special integer values, functions now take
  an additional pointer argument, which is set to the status
  result of the computation.

  The Failable type in Core.Error is no longer needed and has
  been removed.

• CI builds now include GHC 8.8 and GHC 8.10, ensuring that all
  GHC 8.* versions are supported.

Released 2020-06-27

• Revert signature of function pushList to it's proper 1.1.0
  value. This fixes a mistake which caused the 1.1.1 release
  to be in violation of the PVP versioning policy.

• Module Foreign.Lua.Peek: add function pushKeyValuePairs (Alex
  Loomis).

Released 2020-06-02

WARNING: This version does not conform to the PVP versioning
policy, due to a unintended signature change of function
pushList. It is recommended to use 1.1.2 instead of this version.

• New module Foreign.Lua.Push: provides functions which marshal
  and push Haskell values onto Lua's stack.

  Most functions in Foreign.Lua.Types.Pushable are now defined
  using functions from this module.

• New module Foreign.Lua.Peek: provides functions which unmarshal
  and retrieve Haskell values from Lua's stack. Contrary to peek
  from Foreign.Lua.Types.Peekable, the peeker functions in this
  module will never throw errors, but use an Either type to
  signal retrieval failure.

  The error type PeekError should not be considered final and
  will likely be subject to change in later versions.

• Module Foreign.Lua.Utf8: never throw errors when decoding UTF-8
  strings. Invalid UTF-8 input bytes no longer cause exceptions,
  but are replaced with the Unicode replacement character U+FFFD.

• Fixed missing and faulty Haddock documentation.

• Fixed a bug which caused unnecessary use of strings to represent
  floating point numbers under certain configurations.

Released 2020-03-25.

WARNING: The changes in this release are experimental. It is
recommended to skip this release unless the newly introduced
features are required.

• Allow custom error handling: conversion of Lua errors to
  Haskell exceptions and back is made configurable. Users can
  define their own exception/error handling strategies, even
  opening up the option to pass arbitrary exceptions through Lua.

  • New types exported from Foreign.Lua.Types:

    • ErrorConversion: defines the ways in which exceptions
      and errors are handled and converted.
    • LuaEnvironment: environment in which Lua computations
      are evaluated. Contains the Lua interpreter state and
      the error conversion strategy.

  • The environment of the Lua type is changed from a plain
    Lua State to the above mentioned LuaEnvironment.

  • New functions run' is exported from Foreign.Lua.Util
    and Foreign.Lua: it is analogous to run, but allows to
    run computations with a custom error conversion strategy.

  • New function runWithConverter exported from
    Foreign.Lua.Core.Types and Foreign.Lua.Core; like
    run', but takes a custom state.

  • New function unsafeRunWith exported from
    Foreign.Lua.Core.Types and Foreign.Lua.Core; runs a
    computation without proper error handling.

  • New function errorConversion exported from
    Foreign.Lua.Core.Types and Foreign.Lua.Core: extract
    the error conversion strategy from the Lua type.

  • New function throwErrorAsException exported from
    Foreign.Lua.Core.Error and Foreign.Lua.Core: throws a
    Lua error as Haskell exception, using the current error
    conversion strategy.

• Function runWith is moved from module Foreign.Lua.Core to
  Foreign.Lua.Util.

• The module Foreign.Lua.Utf8 is now exported.

Released 2019-08-21.

• Added flag to use hardcoded values for registry keys: The names
  of the registry keys used to store package information are
  available as CPP values from file lauxlib.h since Lua 5.3.4;
  compiling HsLua against older Lua versions was not possible, as
  those values were expected to exist.

  The respective values are now hardcoded into HsLua, and a new
  flag hardcode-reg-key is introduced, which will cause the use
  of these hardcoded values instead of those defined in
  lauxlib.h. Using this flag makes it possible to compile hslua
  against all Lua 5.3.* versions.

• Added missing C files for benchmarking to list of
  extra-source-files.

Released 2019-05-08.

• Prevent filenames being treated as strings in debug messages.
  Lua's loadbuffer takes a source description as an argument,
  which is used for debug messages. The loadfile function now
  adds a special prefix (@) to source, thus marking it as a
  filename.