Codex @codex  0

An individually addressable place in computer memory holding a value. An abstract memory interface can separate reading and updating existing memory locations from allocating a fresh memory location.

Reading preserves the computer memory; writing returns the unit type value; allocating returns both the fresh memory location and the allocator's updated computer memory:

get :: Monad m => Location -> MemT m Value
get a s = resultM (contents s a,s)

put :: Monad m => Location -> Value -> MemT m ()
put a v s = resultM ((),update s a v)

new :: Monad m => MemT m Location
new s = resultM (fresh s)

These use the memory interface in ^[ref]. In particular, fresh already returns its outputs in the order required by the state monad transformer:

Expand the two type synonyms to see what survives an exception:In the first order, a failed computation can still produce (Nothing,s'). The exception handler therefore runs with $s^{\prime }$, including writes made before failure. In the second order, failure produces Nothing, with no returned computer memory. A handler defined by applying the underlying orelse pointwise runs its alternative from the original input computer memory $s$. This gives rollback of this explicit program state for the failed branch.

For example, start with a memory location holding $0$, write $1$, fail, and handle the failure by reading that memory location. The first order returns $1$; the second returns $0$. This rollback concerns the explicit computer memory only: arbitrary effects in the base computational monad are not thereby reversed.A conventional programming language normally retains writes made before an exception is caught. Its mutable computer memory and exception handling therefore correspond more closely to $\mathrm{ExT}(\mathrm{MemT}m)$.