This is the basic MOO monad transformer stack. A computation of type MOO a is a VTx transaction (layered on STM) that returns a value of type a within an environment that supports state, continuations, and local modification.

A Reader environment for state that either doesn't change, or can be locally modified for subcomputations

Lift a VTx transaction into the MOO monad.

Lift an STM transaction into the MOO monad.

The known universe, as far as the MOO server is concerned

Fetch the current setting of a server option obtained from $server_options.

A structure representing a queued or running task

The running state of a task

A function to call in order to wake a suspended task

A State structure for data that may normally change during computation

The stack of verb and/or built-in function frames

An IO computation to be performed after the current task commits its STM transaction

The intermediate or final result of a running task

A continuation to resume the execution of a task where it left off

Task resource limits

Generate a (random) TaskId not currently in use by any existing task.

Create a pending Task for the given computation on behalf of the given player. A new TaskId is reserved for the task and the task is added to the World. (The task will not actually run until passed to runTask.)

Reset the number of ticks and seconds available for the current task based on the latest values obtained from $server_options.

Run a task in a new Haskell thread, returning either the value produced by the task, or Nothing if the task suspends or aborts before producing a value. If the task suspends, it may continue running after this function returns. The task is removed from the task queue after it is finished.

Create and queue a task to run the given computation after the given microsecond delay. E_INVARG may be raised if the delay is out of acceptable range. (The given TaskId should have been reserved by a call to newTaskId.)

Commit the current task's transaction, and return to the task dispatcher with an interrupt request. The task dispatcher may resume execution of the task later if the request is one which supplies an appropriate continuation.

Interrupt the current task to perform the given IO computation, and return the result. Note this implies a commit of the task's STM transaction.

Perform the given IO computation after the current task commits its STM transaction.

Since general IO can't be performed within a transaction, this is a simple alternative when the value returned by the IO isn't needed.

A version of catchUnsafeIOtoMOO that simply propagates any thrown exception into the calling thread, most likely aborting its execution.

Unsafely perform the given IO action within the current STM transaction, using the supplied exception handler in case the IO throws an exception.

Since STM transactions may be aborted at any time, the IO is performed in a separate thread in order to guarantee consistency with any finalizers, brackets, and so forth. The IO must be idempotent as it may be run more than once.

Note that all the hazards of unsafePerformIO apply; in particular, it is incumbent upon the caller to ensure the IO action is executed at least as many times as desired (and not, say, optimized to a single execution).

The data tracked for each verb and/or built-in function call

A local continuation for loop constructs

Create a variable block for a verb by overriding the default.

A MOO exception

Abort execution of the current computation and call the nearest enclosing exception handler.

Create and raise an exception for the given MOO error.

Install a local exception handler for the duration of the passed computation.

Re-raise an exception to the next enclosing handler.

Execute the passed computation, capturing any exception raised in verb frames with debug bit unset and returning the error code as an ordinary value instead of propagating the exception.

Determine whether the given object has its wizard bit set.

Verify that the given floating point number is neither infinite nor NaN, raising E_FLOAT or E_INVARG respectively if so. Also, return the corresponding MOO value.

Verify that the current task permissions have programmer privileges, raising E_PERM if not.

Verify that the current task permissions have wizard privileges, raising E_PERM if not.

Verify that the current task permissions either have wizard privileges or are the same as the given object, raising E_PERM if not.

Verify that the given object is valid, raising E_INVARG if not. Also, return the referenced object.

Verify that the given object is fertile for the current task permissions, raising E_PERM if not.

Verify that the named built-in property is not protected by $server_options.protect_prop, or that the current task permissions have wizard privileges if it is, raising E_PERM otherwise.

Verify that the given object does not have a recursive relationship with the given subject, raising E_RECMOVE if so.

Verify that the programmer has not reached their queued task limit (before creating a new forked, suspended, or reading task).

Translate a MOO binary string into a Haskell ByteString, raising E_INVARG if the MOO string is improperly formatted.

Generate and return a pseudorandom value in the given range, modifying the local generator state.

Split the local random number generator state in two, updating the local state with one of them and returning the other.

Wait for the given number of microseconds to elapse.

Begin the server shutdown process.

Placeholder for features not yet implemented