Future Module

Wraps a function into a future.

The global Future Library provides functions to work more easily with futures.

Adds the given futures to the tasks list.

Creates a new Future that will finish once any of the passed futures has finished. The other futures will be ignored. The future will return all futures and the table containing the results of the one future that finished in order.

Wraps the given thread/coroutine in a Lua-Future

Creates a new Future that will only finish once all futures passed as parameters have finished. The return values of all futures will be packed into tables and returned in order.

Runs the default task scheduler indefinitely until no pending futures are left.

Runs the default task scheduler once.

Returns true if there are still pending futures.

Creates a future that returns after the given amount of seconds.

A list of futures that are considered "Tasks". Tasks could be seen as background threads. Effectively getting "joined" together. Examples for tasks are callback invocations of timers and event listeners.

Blocks the current thread/future until the given amount of time passed

A future that is used as task to handle Timeouts.

Represents some action to be executed at some point. Provides an interface to drive execution forward, check for completion and return retrieval. Futures are mostly used to retrieve data, usually you just want to use await function to yield the current thread until the values become available.

If the associated actions get executed is defined by the variation of the future, by the creator of the future. Some Futures may only require to exist, some can be destroyed but the action still will be executed and others require you to await/poll for them.

Polling a future using the poll function allows you to drive its execution forward if necessary, but most importantly, allows you to check if it finished execution You can always poll a future.

To retrieve values that may be returned by the Future, use the get function which causes an error if the future is not ready.

Actively Polling a future is in most cases quite inefficient. Use the await function to yield the current thread until the future is ready. It will then also return the return values of the future. If the future caused an error, the await function will propagate the error further.

Some functions are aware when the get closed, allowing you to have more control over the cancellation of a future. Every Future gets cancelled on garbage collection, but only some actually care about getting cancelled.

A Future essentially wraps a thread/coroutine. When a future yields, the future can be considered pending, when it returns, the future is Finished, when a future fails, the future failed. A future can be actively polled by the runtime or may wait to be woken up by some other future or external system. For this, the values a future yields are used to control its runtime. - <nothing> indicates the future should be actively polled. This practically means it gets added as task. - future indicates the future is waiting for the given future. When the future gets polled using await or as task, this will make this future be woken up by the given future and be removed as task. - number indicates the future is waiting to be woken up by some external system, but if its a task or called in the main thread, allows to indicate the runtime its fine to sleep for the given amount of seconds - <any> indicates the future is waiting to be woken up by some external system

Wait for the future to complete and return its value.

Check if the future’s value is available without performing any additional logic.

Get value from the future if one is available. Causes error if future is not yet resolved.