version 4.0.0

Changes from 3.17.2:

• Internal changes
  - Lanes is implemented in C++20: thread, condition_variable, mutex, string_view, variant, lambdas, templates, and more!
  - Almost all platform-specific code is gone (only a small bit for thread priority and affinity remains).
  - Decoda support inactive by default.
  - Deep userdata interface fully revamped to C++20 too.
  - Supports Lua 5.5
  • Lanes API changes
    • Lanes module:
      • shared library is now lanes_core.[so|dll] instead of lanes/core.[so|dll]
      • lanes.register() is also available as lanes_register() in the exported C API.
      • lanes.sleep(): passing nil or no argument now blocks indefinitely (until cancellation is received).
      • function set_debug_threadname() available inside a Lane is renamed lane_threadname(); can now both read and write the name.
      • function cancel_test() raises cancel_error by default in a hard-cancelled lane.
      • new function lanes.finally(). Installs a function that gets called at Lanes shutdown after attempting to terminate all lanes.
        If some lanes still run after the finalizer, Universe::__gc with raise an error or freeze, depending on its return value.
      • new function lanes.collectgarbage(), to force a full GC cycle in the keeper states.
      • new function lanes.thread_priority_range(), to query the valid range of priorities.
      • Configuration settings:
        • Boolean parameters only accept boolean values.
        • allocator provider function is called with a string hint to distinguish internal allocations, lane and keeper states.
        • demote_full_userdata removed. Use __lanesconvert instead (see below).
        • keepers_gc_threshold added. Controls when GC runs inside keepers.
        • nb_keepers changed to nb_user_keepers. limited to 100 keepers on top of the internal keeper used by the timer Linda.
        • strip_functions added. Only useful for Lua 5.3+.
        • verbose_errors removed. Use lane error_trace_level instead.
        • with_timers is false by default.
      • Non-deep full userdata are processed during module registration just like ordinary module C functions, making them valid transferable (up)values (for example: io.stdin).
      • thread API errors cause a Lua error instead of aborting the program.
      • thread priorities can now be set using the native range of values, if desired.
    • Lanes:
      • Can no longer be "killed" by hard-stopping their thread without any resource cleanup (see lane:cancel()).
      • lanes.gen() settings:
        • stricter check of base libraries (can raise an error if it doesn't exist in the Lua flavor it's built against).
        • error_trace_level added. Replaces the global verbose_errors setting.
        • name added. Can be used to set the name early (before the lane body calls lane_threadname()).
      • New generator lanes.coro() to start a lane as a coroutine.
      • New __close metamethod that calls join().
      • lane:join() returns nil, error in case of problem, else returns true followed by the lane body return values.
      • lane:get_debug_threadname() renamed get_threadname().
      • cancel_test() returns "soft"/"hard" instead of true when a cancellation request is active.
    • Lindas:
      • lanes.linda()
        • Arguments can be provided in any order.
        • Accepts a callback to be invoked by __close (see below).
        • Providing "auto" as name when constructing a Linda cause Lanes to provide a name built from the source location of the construction.
        • Specifying a group to lanes.linda() is mandatory when Lanes is configured with user Keepers.
      • linda:deep() result no longer contains the raw C pointer of the Linda object.
      • new function linda:receive_batched() to replace linda:receive(linda.batched). linda.batched special value is removed.
      • linda :receive(), :send(), :get(), :set(), :limit() return nil, error in case of problem. Returned values in case of success change too.
      • linda:limit() can be used to read the value if no new limit is provided.
      • linda:restrict() can restrain the use of send/receive or set/get on any key.
      • New __close metamethod that calls any suitable handler that was provided at Linda creation.
      • linda:dump() outputs .limit as 'unlimited' instead of -1 for unlimited keys.
      • linda:wake() can wake up threads waiting for a Linda without doing any I/O on it.
      • linda.status reads the cancel status of the Linda.
      • new function linda:collectgarbage() to force collection of all stale data in the associated keeper.
      • Deep userdata are an acceptable slot to send data into (for example, another linda).
      • Tables can be used as table keys in transferred data.
    • Full userdata conversion:
      • __lanesconvert added.
      • global configuration convert_fallback and convert_max_attempts added.
      • __lanesignore removed. Use __lanesconvert instead.