Values

(DYNAMIC-IS-THREADING-EXCEPTION? DYN) ^{_{FUNCTION · src}}

Returns true if the dynamic val is a threading exception or an IoError containing a ThreadingException.

(IS-THREADING-EXCEPTION IO-ERR) ^{_{FUNCTION · src}}

Return True if IO-ERR contains a threading exception.

Values

(RAISE-RESULT IO-RES) ^{_{FUNCTION · src}}

Raise any (Err :e) into :m. Useful if (Err :e) represents any unhandleable, fatal exception to the program.

(RAISE-RESULT-DYNAMIC OP) ^{_{FUNCTION · src}}

(TRY OP) ^{_{FUNCTION · src}}

Bring any unhandled exceptions of type :e up into a Result. Continues to carry any unhandeld exceptions not of type :e.

(TRY-ALL OP) ^{_{FUNCTION · src}}

Bring the result of OP up into an Optional. Returns None if OP raised any exceptions.

(TRY-RESULT OP) ^{_{FUNCTION · src}}

(WRAP-ERROR_ THUNK) ^{_{FUNCTION · src}}

Run thunk, catching any unhandled Lisp/Coalton errors and raising them as exceptions.

Values

(FOREACH-IO COLL A->MB) ^{_{FUNCTION · src}}

Efficiently perform a monadic operation for each element of an iterator. The next element of the iterator is passed into the operation via a cell. If your effect can be run in simple-io/IO, the version in that package will be faster!

(MAP-INTO-IO ITR A->RB) ^{_{FUNCTION · src}}

Efficiently perform a monadic operation for each element of an iterator and return the results. If you're having inference issues, try map-into-io_

(TIMES-IO N IO-OP) ^{_{FUNCTION · src}}

Efficiently perform an IO operation N times. If the effect can be run in simple-io/IO, the version in that package will be faster!

Values

(FOREACH-IO_ COLL A->MB) ^{_{FUNCTION · src}}

Efficiently perform a monadic operation for each element of an iterator. More efficient than foreach-io, if your effect can run in IO. The next element of the iterator is passed into the operation via a cell.

(HANDLE-ALL-IO IO-OP HANDLE-OP) ^{_{FUNCTION · src}}

Run IO-OP, and run HANDLE-OP to handle exceptions of any type thrown by IO-OP.

(HANDLE-IO IO-OP HANDLE-OP) ^{_{FUNCTION · src}}

(MAP-INTO-IO_ ITR A->MB) ^{_{FUNCTION · src}}

Efficiently perform a monadic operation for each element of an iterator and return the results. More efficient than map-into-io, if you can run your effect in a BaseIo.

(RAISE-DYNAMIC-IO DYN) ^{_{FUNCTION · src}}

(RAISE-IO E) ^{_{FUNCTION · src}}

(RAISE-IO_) ^{_{FUNCTION · src}}

(RERAISE-IO OP CATCH-OP) ^{_{FUNCTION · src}}

(RUN-IO! IO-OP) ^{_{FUNCTION · src}}

Top-level run-io! that raises any unhandled exceptions. Also sets the current thread as the global thread for structured concurrency, and exits any child threads on exit.

(TIMES-IO_ N IO-OP) ^{_{FUNCTION · src}}

Efficiently perform an IO operation N times.

(TRY-DYNAMIC-IO IO-OP) ^{_{FUNCTION · src}}

(WITH-RUN-IN-IO_) ^{_{FUNCTION · src}}

`with-run-in-io`, but pegged to the simple-io implementation. Useful when you need to unlift, run, then immediately re-run a function. See, e.g., io-file:with-open-file%.

Values

(BRACKET-LIFECYCLE-MASKED ACQUIRE-OP RELEASE-OP COMPUTATION-OP) ^{_{FUNCTION · src}}

Acquire a resource, run a computation with it, and release it. Guarantees that RELEASE-OP will run if ACQUIRE-OP completes. If COMPUTATION-OP raises an exception, it will be re-raised after the resource cleans up. If ACQUIRE-OP or RELEASE-OP raise an exception, then release is not guaranteed. RELEASE-OP receives only the acquired resource. Concurrent: - Masks the thread during resource acquisition and release. - The computation is not maskedbut and if another thread stops this one during the computation then the resource the resource will still be released.

(BRACKET-LIFECYCLE-MASKED-CASE ACQUIRE-OP RELEASE-OP COMPUTATION-OP) ^{_{FUNCTION · src}}

Acquire a resource, run a computation with it, and release it. Guarantees that RELEASE-OP will run if ACQUIRE-OP completes. If COMPUTATION-OP raises an exception, it will be re-raised after the resource cleans up. If ACQUIRE-OP or RELEASE-OP raise an exception, then release is not guaranteed. RELEASE-OP receives both the acquired resource and an ExitCase indicating whether the computation completed successfully (Completed) or errored (Errored). Concurrent: - Masks the thread during resource acquisition and release. - The computation is not masked, but if another thread stops this one during the computation then the resource the resource will still be released.

(BRACKET-MASKED ACQUIRE-OP RELEASE-OP COMPUTATION-OP) ^{_{FUNCTION · src}}

Acquire a resource, run a computation with it, and release it. Guarantees that RELEASE-OP will run if ACQUIRE-OP completes. If COMPUTATION-OP raises an exception, it will be re-raised after the resource cleans up. If ACQUIRE-OP or RELEASE-OP raise an exception, then release is not guaranteed. RELEASE-OP receives only the acquired resource. Concurrent: - Masks the thread before ACQUIRE-OP starts. - Unmasks the thread after RELEASE-OP finishes.

(BRACKET-MASKED-CASE ACQUIRE-OP RELEASE-OP COMPUTATION-OP) ^{_{FUNCTION · src}}

Acquire a resource, run a computation with it, and release it. Guarantees that RELEASE-OP will run if ACQUIRE-OP completes. If COMPUTATION-OP raises an exception, it will be re-raised after the resource cleans up. If ACQUIRE-OP or RELEASE-OP raise an exception, then release is not guaranteed. RELEASE-OP receives both the acquired resource and an ExitCase indicating whether the computation completed successfully (Completed) or errored (Errored). Concurrent: - Masks the thread before ACQUIRE-OP starts. - Unmasks the thread after RELEASE-OP finishes.

(BRACKET-UNMASKED ACQUIRE-OP RELEASE-OP COMPUTATION-OP) ^{_{FUNCTION · src}}

Acquire a resource, run a computation with it, and release it. Guarantees that RELEASE-OP will run if ACQUIRE-OP completes. If COMPUTATION-OP raises an exception, it will be re-raised after the resource cleans up. If ACQUIRE-OP or RELEASE-OP raise an exception, then release is not guaranteed. RELEASE-OP receives only the acquired resource.

(BRACKET-UNMASKED-CASE ACQUIRE-OP RELEASE-OP COMPUTATION-OP) ^{_{FUNCTION · src}}

Acquire a resource, run a computation with it, and release it. Guarantees that RELEASE-OP will run if ACQUIRE-OP completes. If COMPUTATION-OP raises an exception, it will be re-raised after the resource cleans up. If ACQUIRE-OP or RELEASE-OP raise an exception, then release is not guaranteed. RELEASE-OP receives both the acquired resource and an ExitCase indicating whether the computation completed successfully (Completed) or errored (Errored).

Values

CURRENT-THREAD ^{_{VALUE · src}}

Get the current thread.

(FORK-THREAD OP) ^{_{FUNCTION · src}}

Spawn a new thread, which starts running immediately. Returns the handle to the thread. Can specify an unhandled exception strategy and fork scope. If the thread raises an unhandled exception, the default behavior is to log it to *ERROR-OUTPUT* and swallow it until/if the thread is joined. The default fork scope is structured.

(JOIN-THREAD THREAD) ^{_{FUNCTION · src}}

Block the current thread until the target thread is completed. Does not a retrieve value. Raises an exception if the target thread raised an unhandled exception, wrapping the target thread's raised exception. JOIN-THREAD is the lowest level operation to block on another thread's termination.

(MASK-CURRENT! RT-PRX) ^{_{FUNCTION · src}}

Mask the current thread.

MASK-CURRENT-THREAD ^{_{VALUE · src}}

Mask the current thread so it can't be stopped.

(MASK-THREAD THREAD) ^{_{FUNCTION · src}}

Mask the thread so it can't be stopped.

(PARK-CURRENT-THREAD-IF WITH-GEN SHOULD-PARK?) ^{_{FUNCTION · src}}

Parks the current thread if SHOULD-PARK? returns True. Will park the thread until woken by an unpark from another thread. Upon an unpark, the thread will resume even if SHOULD-PARK? is False! SHOULD-PARK? is only checked to determine if the thread should park, *not* if it should resume. Can specify a timeout. Concurrent: - WARNING: SHOULD-PARK? must not block, or the thread could be left blocked in a masked state. - Can briefly block while trying to park the thread, if contended.

(SLEEP MSEC) ^{_{FUNCTION · src}}

Sleep the current thread for MSECS milliseconds.

(STOP-THREAD THREAD) ^{_{FUNCTION · src}}

Stop a thread. If the thread has already stopped, does nothing.

(UNMASK-CURRENT! RT-PRX) ^{_{FUNCTION · src}}

Unmask the current thread.

UNMASK-CURRENT-THREAD ^{_{VALUE · src}}

Unmask the current thread so it can be stopped. Unmask respects nested masks - if the thread has been masked N times, it can only be stopped after being unmasked N times.

(UNMASK-CURRENT-THREAD-FINALLY OP-FINALLY) ^{_{FUNCTION · src}}

Unmask the current thread, run the provided action, and then honor any pending stop for that thread after the action finishes. Warning: There is a very small chance that the UnmaskFinallyMode passed to the callback could be inconsistent with whether the Concurrent is ultimately stopped. Regardless of the input, the callback should leave any resources in a valid state. An example of a valid callback: closing a log file if the thread is stopped, or closing the log file with a final message if the thread is continuing.

(UNMASK-THREAD THREAD) ^{_{FUNCTION · src}}

Unmask the thread so it can be stopped. Unmask respects nested masks - if the thread has been masked N times, it can only be stopped after being unmasked N times.

(UNMASK-THREAD-FINALLY THREAD OP-FINALLY) ^{_{FUNCTION · src}}

Unmask the thread, run the provided action, and then honor any pending stop for that thread after the action finishes. Warning: There is a very small chance that the UnmaskFinallyMode passed to the callback could be inconsistent with whether the Concurrent is ultimately stopped. Regardless of the input, the callback should leave any resources in a valid state. An example of a valid callback: closing a log file if the thread is stopped, or closing the log file with a final message if the thread is continuing.

(UNPARK-THREAD GEN THREAD) ^{_{FUNCTION · src}}

Unparks the thread if it is still waiting on the generation. Attempting to unpark the thread with a stale generation has no effect. A generation will be stale if the thread has unparked and re-parked since the initial park. Concurrent: - Can briefly block while trying to unpark the thread, if contended.

(WITH-MASK OP) ^{_{FUNCTION · src}}

Mask the current thread while running OP, unmasking afterward.

(WRITE-LINE-SYNC MSG) ^{_{FUNCTION · src}}

Perform a synchrozied write-line to the terminal. Not performant - mainly useful for debugging.

(FORK-THREAD_ OP) ^{_{FUNCTION · src}}

Spawn a new IoThread. Can specify an unhandled exception strategy and fork scope.

(PARK-CURRENT-THREAD-IF_) ^{_{FUNCTION · src}}

Parks the current thread if SHOULD-PARK? returns True. Will park the thread until woken by an unpark from another thread. Upon an unpark, the thread will resume even if SHOULD-PARK? is False! SHOULD-PARK? is only checked to determine if the thread should park, *not* if it should resume. Concurrent: - WARNING: SHOULD-PARK? must not block, or the thread could be left blocked in a masked state. - Can briefly block while trying to park the thread, if contended.

(UNMASK-FINALLY_) ^{_{FUNCTION · src}}

(UNMASK-THREAD-FINALLY_) ^{_{FUNCTION · src}}

Values

(WITH-OPEN-FILE PTH K) ^{_{FUNCTION · src}}

Opens a file stream, performs K on it, then closes the stream. Can run any underlying BaseIo, which can be useful but can also cause inference issues in some cases. Try WITH-OPEN-FILE_ if you have issues.

(WITH-TEMP-DIRECTORY K) ^{_{FUNCTION · src}}

Performs an operation `thunk` inside a temporary directory. Can run any underlying BaseIo, which can be useful but can also cause inference issues in some cases. Try WITH-TEMP-DIRECTORY_ if you have issues.

(WITH-TEMP-FILE K) ^{_{FUNCTION · src}}

Performs an operation `thunk` on a temporary file. File type extensions need to include `.` Can run any underlying BaseIo, which can be useful but can also cause inference issues in some cases. Try WITH-TEMP-FILE_ if you have issues.

(WITH-OPEN-FILE_) ^{_{FUNCTION · src}}

(WITH-TEMP-DIRECTORY_) ^{_{FUNCTION · src}}

(WITH-TEMP-FILE_) ^{_{FUNCTION · src}}

Values

(TO-INT (UNIQUE% I)) ^{_{FUNCTION · src}}

Convert a unique value to an integer. It is guaranteed that: (/= (to-int a) (to-int b)) for any two different Unique instances.

Values

(BYTE-SOCKET-ACCEPT-FORK-WITH SERVER-SOCKET OP) ^{_{FUNCTION · src}}

Accept a byte-stream connection with a new client and run operation OP on a new thread. Guarantees that the socket will close on cleanup. Returns a handle to the forked thread.

(BYTE-SOCKET-ACCEPT-WITH SERVER-SOCKET OP) ^{_{FUNCTION · src}}

Accept a byte-stream connection with a new client and run operation OP. Guarantees that the socket will close on cleanup. Note: If you fork a thread inside this, the operation on this thread will probably finish and close the socket before you intend. For multithreaded uses, use byte-socket-accept-fork-with.

(BYTE-SOCKET-CONNECT-WITH HOSTNAME PORT OP) ^{_{FUNCTION · src}}

Run operation OP with a byte-stream connection to an open server socket at HOSTNAME and PORT. Guarantees that the socket will close on cleanup.

(BYTE-SOCKET-LISTEN-WITH HOSTNAME PORT OP) ^{_{FUNCTION · src}}

Run operation OP with a new byte-stream server socket, listening on HOSTNAME and PORT. Guarantees that the socket will close on cleanup.

(SOCKET-ACCEPT-FORK-WITH SERVER-SOCKET OP) ^{_{FUNCTION · src}}

Accept a connection with a new client and run operation OP on a new thread. Guarantees that the socket will close on cleanup. Returns a handle to the forked thread.

(SOCKET-ACCEPT-WITH SERVER-SOCKET OP) ^{_{FUNCTION · src}}

Accept a connection with a new client and run operation OP. Guarantees that the socket will close on cleanup. Note: If you fork a thread inside this, the operation on this thread will probably finish and close the socket before you intend. For multithreaded uses, use socket-accept-fork-with.

(SOCKET-CONNECT-WITH HOSTNAME PORT OP) ^{_{FUNCTION · src}}

Run operation OP with a connection to an open server socket at HOSTNAME and PORT. Guarantees that the socket will close on cleanup.

(SOCKET-LISTEN-WITH HOSTNAME PORT OP) ^{_{FUNCTION · src}}

Run operation OP with a new server socket, listening on HOSTNAME and PORT. Guarantees that the socket will close on cleanup.

Values

NEW-PARKING-SET ^{_{VALUE · src}}

Create a new ParkingSet.

(PARK-IN-SET-IF SHOULD-PARK? PSET) ^{_{FUNCTION · src}}

Parks the current thread in PSET if SHOULD-PARK? returns True. Will park the thread until woken by an unpark from another thread. Upon an unpark, the thread will resume even if SHOULD-PARK? is False! SHOULD-PARK? is only checked to determine if the thread should park, *not* if it should resume. Can specify a timeout. Concurrent: - WARNING: SHOULD-PARK? must not block, or the thread could be left blocked in a masked state. - Can briefly block while trying to park the thread, if contended.

(PARK-IN-SETS-IF SHOULD-PARK? PSETS) ^{_{FUNCTION · src}}

Parks the current thread in PSETS if SHOULD-PARK? returns True. Will park the thread until woken by an unpark from another thread. Upon an unpark, the thread will resume even if SHOULD-PARK? is False! SHOULD-PARK? is only checked to determine if the thread should park, *not* if it should resume. Can specify a timeout. Concurrent: - WARNING: SHOULD-PARK? must not block, or the thread could be left blocked in a masked state. - Can briefly block while trying to park the thread, if contended.

(UNPARK-SET PSET) ^{_{FUNCTION · src}}

Atomically reset PSET, then attempt to unpark all threads parked on the set. Concurrent: - Can briefly block while trying to reset the set or unpark a parked thread

(PARK-IN-SET-IF_) ^{_{FUNCTION · src}}

Parks the current thread in PSET if SHOULD-PARK? returns True. Will park the thread until woken by an unpark from another thread. Upon an unpark, the thread will resume even if SHOULD-PARK? is False! SHOULD-PARK? is only checked to determine if the thread should park, *not* if it should resume. Can specify a timeout. Concurrent: - WARNING: SHOULD-PARK? must not block, or the thread could be left blocked in a masked state. - Can briefly block while trying to park the thread, if contended.

(PARK-IN-SETS-IF_) ^{_{FUNCTION · src}}

Parks the current thread in PSETS if SHOULD-PARK? returns True. Will park the thread until woken by an unpark from another thread. Upon an unpark, the thread will resume even if SHOULD-PARK? is False! SHOULD-PARK? is only checked to determine if the thread should park, *not* if it should resume. Can specify a timeout. Concurrent: - WARNING: SHOULD-PARK? must not block, or the thread could be left blocked in a masked state. - Can briefly block while trying to park the thread, if contended.

Values

(FORK-FUTURE TASK) ^{_{FUNCTION · src}}

Spawn a new future, which will run and eventually return the result from TASK. The future is guaranteed to only ever run at most once, when the produced :m is run.

(TRY-READ-FUTURE FUTURE) ^{_{FUNCTION · src}}

Try to read the current value from FUTURE, returning NONE if it is not available. Raises any exceptions in the awaiting thread that were raised in the future thread.

(FORK-FUTURE_) ^{_{FUNCTION · src}}

Spawn a new future, which will run and eventually return the result from TASK. The future is guaranteed to only ever run at most once, when the produced :m is run.

Values

(MODIFY ATM F) ^{_{FUNCTION · src}}

Atomically modify `atm` by applying `f` and return the new value. `f` must be a pure function. If `f` throws an error, `atm` will be unchanged and the error will be handleable via `Exceptions`. Concurrent: - WARNING: `f` will be retried each time the calling thread loses the race to update `atm`, so `f` must be pure.

(MODIFY-SWAP ATM F) ^{_{FUNCTION · src}}

Atomically modify `atm` by applying `f` and return the old value. `f` must be a pure function. If `f` throws an error, `atm` will be unchanged and the error will be handleable via `Exceptions`. Concurrent: - WARNING: `f` will be retried each time the calling thread loses the race to update `atm`, so `f` must be pure.

(NEW-AT-VAR VAL) ^{_{FUNCTION · src}}

Create a new AtVar containing `val`.

(POP ATM) ^{_{FUNCTION · src}}

Atomically pop and retrieve the head of an atomic list.

(PUSH ATM ELT) ^{_{FUNCTION · src}}

Atomically push a value onto an atomic list. Returns the new list.

(READ ATM) ^{_{FUNCTION · src}}

Atomically read the value from `atm`.

(WRITE ATM VAL) ^{_{FUNCTION · src}}

Atomically write a new value to `atm`.

Values

(IS-EMPTY-MVAR MVAR) ^{_{FUNCTION · src}}

Return True if the MVar is currently empty.

NEW-EMPTY-CHAN ^{_{VALUE · src}}

Create a new empty channel.

NEW-EMPTY-MVAR ^{_{VALUE · src}}

Create a new empty MVar.

(NEW-MVAR VAL) ^{_{FUNCTION · src}}

Create a new MVar containing VAL.

(POP-CHAN CHAN) ^{_{FUNCTION · src}}

Pop the front value in CHAN. Blocks while CHAN is empty. Can specify a timeout.

(PUSH-CHAN CHAN VAL) ^{_{FUNCTION · src}}

Push VAL onto CHAN.

(PUT-MVAR MVAR VAL) ^{_{FUNCTION · src}}

Fill an empty MVar, blocking until it becomes empty. Can specify a timeout. Concurrent: - Blocks while the MVar is full - Writers (including `put-mvar`) are woken individual on succesful takes in order of acquisition - On succesful put, blocking read-consumers are woken individually in order of acquisition - On succesful put, all blocking read-non-consumers are woken simultaneously. New data is handed directly to woken read-non-consumers so they don't contend on the MVar.

(READ-MVAR MVAR) ^{_{FUNCTION · src}}

Read a value from an MVar, blocking until one is available. Does not consume value. Can specify a timeout. Concurrent: - Blocks while the MVar is empty - Blocking read-non-consumers (including `read-mvar`) are woken simultaneously on succesful put. Data is handed directly to woken readers, which don't contend on mvar.

(SWAP-MVAR MVAR NEW-VAL) ^{_{FUNCTION · src}}

Atomically replace the value in an MVar and return the old value. Can specify an optional timeout. Concurrent: - Blocks while the MVar is empty - Wakes the next blocking read-consumer when `swap-mvar` completes

(TAKE-MVAR MVAR) ^{_{FUNCTION · src}}

Take a value from an MVar, blocking until one is available. Can specify a timeout. Concurrent: - Blocks while the MVar is empty - Read-consumers (including `take-mvar`) are woken individual on succesful puts, in order of acquisition - On succesful take, one blocking writer is woken in order of acquisition

(TAKE-MVAR-MASKED MVAR) ^{_{FUNCTION · src}}

Take a value from an MVar, blocking until one is available. Can specify a timeout. Concurrent: - WARNING: Leaves the thread masked when returns to protect caller's critical regions based on consuming and restoring MVar to a valid state. See MChan for an example. - Blocks while the MVar is empty - Read-consumers (including `take-mvar-masked`) are woken individual on succesfull puts, in order of acquisition - On succesful take, one blocking writer is woken in order of acquisition

(TRY-POP-CHAN CHAN) ^{_{FUNCTION · src}}

Attempt to pop the front value in CHAN. Does not block.

(TRY-PUT-MVAR MVAR VAL) ^{_{FUNCTION · src}}

Attempt to immediately put a value into an MVar. Returns True if succeeded. Concurrent: - Can briefly block while waiting to fill the MVar, if contended - On succesful put, blocking read-consumers are woken individually in order of acquisition - On succesful put, all blocking read-non-consumers are woken simultaneously. New data is handed directly to woken read-non-consumers so they don't contend on the MVar.

(TRY-READ-MVAR MVAR) ^{_{FUNCTION · src}}

Attempt to immediately read a value from an MVar. Returns None if empty.

(TRY-TAKE-MVAR MVAR) ^{_{FUNCTION · src}}

Attempt to immediately take a value from an MVar. Returns None if empty. Concurrent: - Can briefly block while waiting to empty the MVar, if contended - On succesful take, one blocking writer is woken in order of acquisition

(TRY-TAKE-MVAR-MASKED MVAR) ^{_{FUNCTION · src}}

Attempt to immediately take a value from an MVar. Returns None if empty. Concurrent: - WARNING: Leaves the thread masked when returns to protect caller's critical regions based on consuming and restoring MVar to a valid state. See MChan for an example. - Can briefly block while waiting to empty the MVar, if contended - On succesful take, one blocking writer is woken in order of acquisition

(WITH-MVAR MVAR OP) ^{_{FUNCTION · src}}

Run an operation with the value from an MVar, blocking until one is available. Restore the MVar value and return the result of the operation. WARNING: If the computation raises an unhandled exception or is stopped, leaves the MVar empty! Concurrent: - WARNING: Does not mask during the computation. To ensure completion, caller must mask - Blocks while the MVar is empty - Inherits notify semantics from `put-mvar` - Does not leave the MVar locked during the computation. Thus, other threads can put the MVar during the computation and force `with-mvar` to block until empty.

(WITH-MVAR_) ^{_{FUNCTION · src}}

Run an operation with the value from an MVar, blocking until one is available. Restore the MVar value and return the result of the operation. WARNING: If the computation raises an unhandled exception or is stopped, leaves the MVar empty! Concurrent: - WARNING: Does not mask during the computation. To ensure completion, caller must mask - Blocks while the MVar is empty - Inherits notify semantics from `put-mvar` - Does not leave the MVar locked during the computation. Thus, other threads can put the MVar during the computation and force `with-mvar` to block until empty.

Values

(ENCLOSE-GROUP CONCURRENTS) ^{_{FUNCTION · src}}

Enclose already forked Concurrents in a ConcurrentGroup. Warning: After calling, the enclosed Concurrents should only be managed through the group.

(FORK-GROUP FORK-CONCURRENTS) ^{_{FUNCTION · src}}

Run a list of IO operations that each forks a Concurrent. Enclose the forked Concurrents in a ConcurrentGroup. Concurrent: - Does not mask the forking operation, so it is possible to partially fork if stopped. To guarantee forking completion, caller should mask the call to `fork-group`.

Values

(MODIFY-SWAP-TVAR TVAR F) ^{_{FUNCTION · src}}

Modify a mutable variable inside an atomic transaction. Returns the old value.

(MODIFY-TVAR TVAR F) ^{_{FUNCTION · src}}

Modify a mutable variable inside an atomic transaction. Returns the new value.

(NEW-TVAR VAL) ^{_{FUNCTION · src}}

Create a mutable variable that can be used inside an atomic transaction.

(OR-ELSE TX-A TX-B) ^{_{FUNCTION · src}}

Run TX-A. If it signals a retry, run TX-b. If both transactions signal a retry, then the entire transaction retries.

(READ-TVAR TVAR) ^{_{FUNCTION · src}}

Read a mutable variable inside an atomic transaction.

RETRY ^{_{VALUE · src}}

Retry the current operation because the observed state is invalid. Waits for a write transaction to commit somewhere else, and then tries this transaction again. This is useful if the transaction needs to wait for other threads to update the data before it can continue. For example, if the transaction reads from a (TVar Queue) and the queue is empty, it must wait until another thread pushes onto the queue before it can continue. Concurrent: - When the transaction runs, executing retry will abort the transaction and sleep the thread. The thread will sleep until any relevant write transaction commits to the STM, when the retrying thread will wake and retry its transaction. A write transaction only triggers a retry if it writes to a TVar that was read before `retry` was called.

(RETRY-WITH STRATEGY) ^{_{FUNCTION · src}}

Retry the current operation because the observed state is invalid. Waits for a write transaction to commit somewhere else, and then tries this transaction again. This is useful if the transaction needs to wait for other threads to update the data before it can continue. For example, if the transaction reads from a (TVar Queue) and the queue is empty, it must wait until another thread pushes onto the queue before it can continue. Concurrent: - When the transaction runs, executing retry will abort the transaction and sleep the thread. The thread will sleep until any relevant write transaction commits to the STM, when the retrying thread will wake and retry its transaction. A write transaction only triggers a retry if it writes to a TVar that was read before `retry` was called. - Will timeout depending on strategy.

(RUN-TX TX) ^{_{FUNCTION · src}}

Run an atomic transaction. If the transaction raises an exception, the transaction is aborted and the exception is re-raised. WARNING: The STM can abort and re-run the transaction repeatedly, until it completes with a consistent snapshot of the data. Therefore, TX must be pure.

(SWAP-TVAR TVAR NEW-VAL) ^{_{FUNCTION · src}}

Swap the value of a mutable variable inside an atomic transaction. Returns the old value.

(WRITE-TVAR TVAR VAL) ^{_{FUNCTION · src}}

Write to a mutable variable inside an atomic transaction.

Values

NEW-MCHAN-SCHEDULER ^{_{VALUE · src}}

Values

(NEW-WORKER-POOL N-THREADS SCHEDULER) ^{_{FUNCTION · src}}

Create a new worker pool. Automatically forks N-THREADS worker threads.

(REQUEST-SHUTDOWN POOL) ^{_{FUNCTION · src}}

Request a shutdown. The threads in the pool will shutdown when all of the jobs already in the queue are completed. To immediately stop the threads, use `stop`.

(SUBMIT-JOB POOL JOB) ^{_{FUNCTION · src}}

Submit a job to the worker pool. Any jobs submitted after a shutdown request will be ignored. Concurrent: - If the pool's scheduler is backed by a bounded data structure, then this can block while the scheduler is full.

(NEW-WORKER-POOL_) ^{_{FUNCTION · src}}

(SUBMIT-JOB_) ^{_{FUNCTION · src}}

Values

(DEQUEUE BUFFER) ^{_{FUNCTION · src}}

Pop an element from BUFFER. Can specify a timeout. Concurrent: - Can block briefly while acquiring lock on buffer. - If empty, blocks until BUFFER is not empty, possibly timing out based on TIMEOUT.

(ENQUEUE ELT BUFFER) ^{_{FUNCTION · src}}

Add ELT to BUFFER. Can specify a timeout. Concurrent: - Can block acquiring lock on buffer. - If full, blocks until BUFFER is not full, possibly timing out based on TIMEOUT.

(NEW-RING-BUFFER CAPACITY) ^{_{FUNCTION · src}}

Create a new ring buffer with the given capacity.

(TRY-ENQUEUE ELT BUFFER) ^{_{FUNCTION · src}}

Attempt to add ELT to BUFFER. Returns True if equeue succeeded, False otherwise. Concurrent: Can block acquiring lock on buffer.

(NEW-RING-BUFFER-SCHEDULER CAPACITY) ^{_{FUNCTION · src}}

Values

(RUN-TERM-STUB STUB-OP READ-LINE-INPUTS) ^{_{FUNCTION · src}}

(RUN-TERM-STUBM OPM READ-LINE-INPUTS) ^{_{FUNCTION · src}}