Values

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

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

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

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

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

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

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

(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.

Values

(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_

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

Efficiently perform a monadic operation for each element of an iterator. If you're having inference issues, try foreach-io_.

Values

(RAISE-DYNAMIC-IO DYN) ^{_{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%.

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

(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.

(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.

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

Efficiently perform a monadic operation for each element of an iterator. More efficient than foreach-io, if you can run your effect in a BaseIo.

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

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

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

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

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

Top-level run-io! that raises any unhandled exceptions.

Values

(BRACKET-IO-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. Masks the thread during the entire operation, including the computation.

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

WARNING: BRACKET-IO-MASKED will *only* cleanup if the raised exception matches :e, or if the computation succeedes. To guarantee cleanup after any exception, use BRACKET-IO-MASKED_ 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. Masks the thread during the entire operation, including the computation.

(BRACKET-IO_ 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. 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 will release before the thread is stopped.

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

WARNING: BRACKET-IO will *only* cleanup if the raised exception matches :e, or if the computation succeedes. To guarantee cleanup after any exception, use BRACKET-IO_ 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. 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 will release before the thread is stopped (if :e = ThreadingException). Example of using BRACKET-IO to clean after stops: (bracket-io (pure Unit) (fn (_resource exit-case) (do-match exit-case ((Errored (InterruptCurrentThread _)) (write stopped True) (s-signal cleanup-done-gate)) (_ (s-signal cleanup-done-gate)))) (fn (_) (do (s-signal start-gate) (s-await wait-forever))))))

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

Mask the current thread while running OP, automatically unmasking afterward.

Values

(MODIFY FS->S) ^{_{FUNCTION · src}}

Modify the state in a StatefulComputation, discarding the old state.

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

Atomically modify by applying F, then return the new value of the atomic variable. F may be called multiple times, and must be a pure function. If F errors, it will be raised in (:m :a) as an UnhandledError exception, and the atomic variable will not be modified.

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

Write a new value to an atomic variable.

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

Read the value from an atomic variable.

(MODIFY HM KEY F) ^{_{FUNCTION · src}}

Modify the value at KEY with F. Returns the modified `HashMap`.

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

Read the value of an atomic cell `atm`.

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

Returns the current value of `atomic'.

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

Access the value held in a Mutex.

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

Read the value of a mutable cell `cel`.

Values

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

Write a new value to an atomic variable.

(WRITE-LINE STREAM S) ^{_{FUNCTION · src}}

Writes a string with an appended newline to a filestream of type Char.

(READ-LINE STREAM) ^{_{FUNCTION · src}}

Reads a line of characters from a FileStream.

Values

(RANDOM-ELT#_ LST) ^{_{FUNCTION · src}}

Get a random element from LST. Errors if LST is empty.

(RANDOM-ELT_ LST) ^{_{FUNCTION · src}}

Get a random element from LST. Returns NONE if LST is empty.

(RANDOM-ELT# RS LST) ^{_{FUNCTION · src}}

Get a random element from LST. Errors if LST is empty.

(RANDOM-ELT RS LST) ^{_{FUNCTION · src}}

Get a random element from LST. Returns NONE if LST is empty.

Values

(AWAIT CV LOCK) ^{_{FUNCTION · src}}

Atomically release `lock' and enqueue the calling thread waiting for `cv'. The thread will resume when another thread has notified it using `notify-cv'; it may also resume if interrupted by some external event or in other implementation-dependent circumstances: the caller must always test on waking that there is threading to be done, instead of assuming that it can go ahead.

(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-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.

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.

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

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

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

Spawn a new thread, which starts running immediately. Returns the handle to the thread. If the thread raises an unhandled exception, throws immediately. The underlying system determines the result of the throw, but it could include terminating the whole program.

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

Unmask the current thread.

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

Get the current thread.

(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.

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

Mask the current thread.

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

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

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

Mask the thread so it can't be stopped.

(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.

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

Spawn a new thread, which starts running immediately. Returns the handle to the thread. If the thread raises an unhandled exception, it will be logged to *ERROR-OUTPUT* and swallowed, until/if the thread is joined. This version can accept any underlying BaseIo, which can be useful, but causes inference issues in some cases.

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

Sleep the current thread for MSECS milliseconds.

(AWAIT SEM) ^{_{FUNCTION · src}}

Decrement the count of `sem' by 1 if the count is larger than zero. If the count is zero, blocks until `sem' can be decremented.

(AWAIT BARRIER) ^{_{FUNCTION · src}}

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

Returns the thread object representing the calling thread.

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

Sleep for `n` seconds, where `n` can be of any type with an instance of `Rational`. Sleep uses type class `Rational`'s `best-approx` instead of `Real`'s `real-approx` because it handles the approximation without arbitrary precision. The only `Real` type excluded by this decision is `CReal`.

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

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

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

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

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

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

Values

(COPY V) ^{_{FUNCTION · src}}

Make a deep copy of the `LispArray` `v`.

(COPY V) ^{_{FUNCTION · src}}

Return a new vector containing the same elements as `v`.

(COPY Q) ^{_{FUNCTION · src}}

Return a new queue containing the same elements as `q`.

(SYSTEM-RELATIVE-PATHNAME SYSTEM-NAME NAME) ^{_{FUNCTION · src}}

Generates a system-relative-pathname for a given filename or path. This is a wrapper for `asdf:system-relative-pathname`. `Name` will likely be an empty string unless a subdirectory or filename is specified.

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

Performs an operation `thunk` inside a temporary directory.

(READ-FILE-TO-VECTOR STREAM) ^{_{FUNCTION · src}}

Reads a file into a vector of type `:a`.

(READ-FILE-TO-STRING PATH) ^{_{FUNCTION · src}}

Reads a file into a string, given a pathname string.

(SET-FILE-POSITION STREAM I) ^{_{FUNCTION · src}}

Sets the file position of a file stream.

(DIRECTORY-EXISTS? PATH) ^{_{FUNCTION · src}}

Returns True if a pathname names a directory that exists.

(READ-FILE-LINES PATH) ^{_{FUNCTION · src}}

Reads a file into lines, given a pathname or string.

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

Performs an operation `thunk` on a temporary file. File type extensions need to include `.`, like ".txt".

(WITH-OPEN-FILE STREAM-OPTIONS THUNK) ^{_{FUNCTION · src}}

Opens a file stream, performs `thunk` on it, then closes the stream.

(WRITE-VECTOR STREAM V) ^{_{FUNCTION · src}}

Writes elements of an vector of type `:a` to a stream of type `:a`.

(WRITE-STRING FS S) ^{_{FUNCTION · src}}

Writes a `string` to a FileStream of type Char.

(FILE-EXISTS? PATH) ^{_{FUNCTION · src}}

Returns True if a pathname names a file that exists.

(READ-VECTOR STREAM CHUNK-SIZE) ^{_{FUNCTION · src}}

Reads a chunk of a file into a vector of type `:a`.

(WRITE-LINE STREAM S) ^{_{FUNCTION · src}}

Writes a string with an appended newline to a filestream of type Char.

(WRITE-CHAR STREAM DATA) ^{_{FUNCTION · src}}

Writes a `Char` to the stream.

(READ-LINE STREAM) ^{_{FUNCTION · src}}

Reads a line of characters from a FileStream.

(READ-CHAR STREAM) ^{_{FUNCTION · src}}

Reads a character from an FileStream.

(EXISTS? PATH) ^{_{FUNCTION · src}}

Returns whether a file or directory exists.

(CLOSE STREAM) ^{_{FUNCTION · src}}

Closes a FileStream.

(ABORT STREAM) ^{_{FUNCTION · src}}

Closes a FileStream and aborts all operations..

(COPY SEQ) ^{_{FUNCTION · src}}

A shallow copy of `seq`

(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 FILE-TYPE 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 OPTS 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_) ^{_{FUNCTION · src}}

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

(WITH-OPEN-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

(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 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.

(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-SWAP FS->S) ^{_{FUNCTION · src}}

Modify the state in a StatefulComputation, returning the old state.

(MODIFY FS->S) ^{_{FUNCTION · src}}

Modify the state in a StatefulComputation, discarding the old state.

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

Atomically modify by applying F, then return the old value of the variable. F may be called multiple times, and must be a pure function. If F errors, it will be raised in (:m :a) as an UnhandledError exception, and the atomic variable will not be modified.

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

Create a new atomic variable with an initial value.

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

Atomically modify by applying F, then return the new value of the atomic variable. F may be called multiple times, and must be a pure function. If F errors, it will be raised in (:m :a) as an UnhandledError exception, and the atomic variable will not be modified.

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

Write a new value to an atomic variable.

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

Read the value from an atomic variable.

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

Atomically push a value onto an atomic list.

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

Atomically pop and retrieve the head of an atomic list.

(MODIFY HM KEY F) ^{_{FUNCTION · src}}

Modify the value at KEY with F. Returns the modified `HashMap`.

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

Read the value of an atomic cell `atm`.

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

Returns the current value of `atomic'.

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

Access the value held in a Mutex.

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

Read the value of a mutable cell `cel`.

(PUSH SEQ A) ^{_{FUNCTION · src}}

Push `a` onto the end of `seq`, returning a new `Seq` instance.

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

If `seq` is empty, return `None`. Otherwise, the last member of `seq` and a new `Seq` instance.

Values

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

Create a new empty MVar.

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

Create a new empty channel.

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

Attempt to take a value from an MVar; returns None if empty.

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

Attempt to read (without removing) the value from an MVar; returns None if empty.

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

Return True if the MVar is currently empty.

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

Attempt to put a value into an MVar; returns False if full and the put fails, True if the put succeeds.

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

Modify with the result of an operation. Blocks until MVar is full. If the operation raises an exception, will restore the MVar value and re-raise. If other threads are calling PUT-MVAR while the operation is running, they can block this thread until another thread takes the MVar.

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

Take a value from an MVar, blocking until one is available.

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

Atomically replace the value in an MVar and return the old value.

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

Read (without removing) the value from an MVar, blocking until one is available.

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

Push VAL onto CHAN.

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

Put a value into an MVar, blocking until it becomes empty.

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

Pop the front value in CHAN. Blocks while CHAN is empty.

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

Create a new MVar containing VAL.

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

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.

Values

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

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