Copyright | (c) Justin Bonnar 2011 Roman Leshchinskiy 2011-2012 |
---|---|

License | BSD-style |

Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au> |

Portability | non-portable |

Safe Haskell | Safe-Inferred |

Language | Haskell2010 |

Primitive boxed mutable variables. This is a generalization of
Data.IORef, Data.STRef and Data.STRef.Lazy to work in
any `PrimMonad`

.

## Synopsis

- data MutVar s a = MutVar (MutVar# s a)
- newMutVar :: PrimMonad m => a -> m (MutVar (PrimState m) a)
- readMutVar :: PrimMonad m => MutVar (PrimState m) a -> m a
- writeMutVar :: PrimMonad m => MutVar (PrimState m) a -> a -> m ()
- atomicModifyMutVar :: PrimMonad m => MutVar (PrimState m) a -> (a -> (a, b)) -> m b
- atomicModifyMutVar' :: PrimMonad m => MutVar (PrimState m) a -> (a -> (a, b)) -> m b
- modifyMutVar :: PrimMonad m => MutVar (PrimState m) a -> (a -> a) -> m ()
- modifyMutVar' :: PrimMonad m => MutVar (PrimState m) a -> (a -> a) -> m ()

# Documentation

A `MutVar`

behaves like a single-element mutable array associated
with a primitive state token.

newMutVar :: PrimMonad m => a -> m (MutVar (PrimState m) a) Source #

Create a new `MutVar`

with the specified initial value.

writeMutVar :: PrimMonad m => MutVar (PrimState m) a -> a -> m () Source #

Write a new value into a `MutVar`

.

atomicModifyMutVar :: PrimMonad m => MutVar (PrimState m) a -> (a -> (a, b)) -> m b Source #

Atomically mutate the contents of a `MutVar`

.

This function is useful for using `MutVar`

in a safe way in a multithreaded program.
If you only have one `MutVar`

, then using `atomicModifyMutVar`

to access and modify
it will prevent race conditions.

Extending the atomicity to multiple `MutVar`

s is problematic,
so if you need to do anything more complicated,
using `MVar`

instead is a good idea.

`atomicModifyMutVar`

does not apply the function strictly. This means if a program
calls `atomicModifyMutVar`

many times, but seldom uses the value, thunks will pile up
in memory resulting in a space leak.
To avoid this problem, use `atomicModifyMutVar'`

instead.

atomicModifyMutVar' :: PrimMonad m => MutVar (PrimState m) a -> (a -> (a, b)) -> m b Source #

Strict version of `atomicModifyMutVar`

. This forces both the value stored
in the `MutVar`

as well as the value returned.

modifyMutVar :: PrimMonad m => MutVar (PrimState m) a -> (a -> a) -> m () Source #

Mutate the contents of a `MutVar`

.

`modifyMutVar`

does not apply the function strictly. This means if a program
calls `modifyMutVar`

many times, but seldom uses the value, thunks will pile up
in memory resulting in a space leak.
To avoid this problem, use `modifyMutVar'`

instead.

modifyMutVar' :: PrimMonad m => MutVar (PrimState m) a -> (a -> a) -> m () Source #

Strict version of `modifyMutVar`

.