Event Module

Acquire a lock such that this operating system thread is the only thread with access to this resource. This will block this entire thread until the lock becomes available, and will not yield to other fibers on this system thread.

Acquire a read lock an a read-write lock.

Acquire a write lock on a read-write lock.

Call a function asynchronously.
Returns a fiber that is scheduled to run the function.

Cancel a suspended fiber in the event loop. Differs from cancel in that it returns the canceled fiber immediately.

Get the number of items a channel will store before blocking writers.

Create a new channel. capacity is the number of values to queue before blocking writers, defaults to 0 if not provided. Returns a new channel.

Close a channel. A closed channel will cause all pending reads and writes to return nil. Returns the channel.

Same as ev/read, but will not return early if less than n bytes are available. If an end of stream is reached, will also return early with the collected bytes.

Close a stream. This should be the same as calling (:close stream) for all streams.

Get the number of items currently waiting in a channel.

Set a deadline for a fiber `tocheck`. If `tocheck` is not finished after `sec` seconds, `tocancel` will be canceled as with `ev/cancel`. If `tocancel` and `tocheck` are not given, they default to `(fiber/root)` and `(fiber/current)` respectively. Returns `tocancel`.

Run some code in a new thread. Suspends the current fiber until the thread is complete, and
evaluates to nil.

Check if a channel is full or not.

Run a number of fibers in parallel on the event loop, and join when they complete.
Returns the gathered results in an array.

Write a value to a channel, suspending the current fiber if the channel is full. Returns the channel if the write succeeded, nil otherwise.

Send a message to the current supervisor channel if there is one. The message will be a tuple of all of the arguments combined into a single message, where the first element is tag. By convention, tag should be a keyword indicating the type of message. Returns nil.

Put a fiber on the event loop to be resumed later. If a function is used, it is wrapped with `fiber/new` first. Optionally pass a value to resume with, otherwise resumes with nil. Returns the fiber. An optional `core/channel` can be provided as a supervisor. When various events occur in the newly scheduled fiber, an event will be pushed to the supervisor. If not provided, the new fiber will inherit the current supervisor.

Create a new lock to coordinate threads.

Read up to n bytes into a buffer asynchronously from a stream. `n` can also be the keyword `:all` to read into the buffer until end of stream. Optionally provide a buffer to write into as well as a timeout in seconds after which to cancel the operation and raise an error. Returns the buffer if the read was successful or nil if end-of-stream reached. Will raise an error if there are problems with the IO operation.

Release a lock such that other threads may acquire it.

Release a read lock on a read-write lock

Release a write lock on a read-write lock

Similar to ev/select, but will try clauses in a random order for fairness.

Create a new read-write lock to coordinate threads.

Block until the first of several channel operations occur. Returns a tuple of the form [:give chan], [:take chan x], or [:close chan], where a :give tuple is the result of a write and :take tuple is the result of a read. Each clause must be either a channel (for a channel take operation) or a tuple [channel x] for a channel give operation. Operations are tried in order, such that the first clauses will take precedence over later clauses. Both and give and take operations can return a [:close chan] tuple, which indicates that the specified channel was closed while waiting, or that the channel was already closed.

Suspend the current fiber for sec seconds without blocking the event loop.

Run some code in a new fiber. This is shorthand for `(ev/go (fn [] ;body))`.

Run some code in a new thread. Like `ev/do-thread`, but returns nil immediately.

Read from a channel, suspending the current fiber if no value is available.

Run `main` in a new operating system thread, optionally passing `value` to resume with. The parameter `main` can either be a fiber, or a function that accepts 0 or 1 arguments. Unlike `ev/go`, this function will suspend the current fiber until the thread is complete. If you want to run the thread without waiting for a result, pass the `:n` flag to return nil immediately. Otherwise, returns nil. Available flags:

* `:n` - return immediately
* `:t` - set the task-id of the new thread to value. The task-id is passed in messages to the supervisor channel.
* `:a` - don't copy abstract registry to new thread (performance optimization)
* `:c` - don't copy cfunction registry to new thread (performance optimization)

Create a threaded channel. A threaded channel is a channel that can be shared between threads and used to communicate between any number of operating system threads.

Run a body of code with a deadline, such that if the code does not complete before
the deadline is up, it will be canceled.

Write data to a stream, suspending the current fiber until the write completes. Takes an optional timeout in seconds, after which will return nil. Returns nil, or raises an error if the write failed.