Data.Mutable.Instances

Exports Ref data types for various common data types, and also the tools for automatic derivation of instances. See Data.Mutable for more information.

Documentation

newtype RecRef s f a

Ref for components in a vinyl Rec.

Constructors

RecRef

Fields

• getRecRef :: Ref s (f a)

Instances

Eq (Ref s (f a)) => Eq (RecRef s f a)

Defined in Data.Mutable.Instances

Methods

(==) :: RecRef s f a -> RecRef s f a -> Bool

(/=) :: RecRef s f a -> RecRef s f a -> Bool

Ord (Ref s (f a)) => Ord (RecRef s f a)

Defined in Data.Mutable.Instances

Methods

compare :: RecRef s f a -> RecRef s f a -> Ordering

(<) :: RecRef s f a -> RecRef s f a -> Bool

(<=) :: RecRef s f a -> RecRef s f a -> Bool

(>) :: RecRef s f a -> RecRef s f a -> Bool

(>=) :: RecRef s f a -> RecRef s f a -> Bool

max :: RecRef s f a -> RecRef s f a -> RecRef s f a

min :: RecRef s f a -> RecRef s f a -> RecRef s f a

data HListRef :: Type -> [Type] -> Type where

The mutable reference of the HList type from generic-lens.

Constructors

NilRef :: HListRef s '[]

(:!>) :: Ref s a -> HListRef s as -> HListRef s (a ': as) infixr 5

data UnitRef s

The Ref for () (unit). This breaks the pattern for tuple instances (type Ref s (a, b) = (Ref s a, Ref s b)), but is necessary for type inference (see documentation for Ref).

Since: 0.2.0.0

Constructors

UnitRef

Instances

Monad (UnitRef :: Type -> Type)

Defined in Data.Mutable.Instances

Methods

(>>=) :: UnitRef a -> (a -> UnitRef b) -> UnitRef b

(>>) :: UnitRef a -> UnitRef b -> UnitRef b

return :: a -> UnitRef a

Functor (UnitRef :: Type -> Type)

Defined in Data.Mutable.Instances

Methods

fmap :: (a -> b) -> UnitRef a -> UnitRef b

(<$) :: a -> UnitRef b -> UnitRef a

Applicative (UnitRef :: Type -> Type)

Defined in Data.Mutable.Instances

Methods

pure :: a -> UnitRef a

(<*>) :: UnitRef (a -> b) -> UnitRef a -> UnitRef b

liftA2 :: (a -> b -> c) -> UnitRef a -> UnitRef b -> UnitRef c

(*>) :: UnitRef a -> UnitRef b -> UnitRef b

(<*) :: UnitRef a -> UnitRef b -> UnitRef a

Foldable (UnitRef :: Type -> Type)

Defined in Data.Mutable.Instances

Methods

fold :: Monoid m => UnitRef m -> m

foldMap :: Monoid m => (a -> m) -> UnitRef a -> m

foldMap' :: Monoid m => (a -> m) -> UnitRef a -> m

foldr :: (a -> b -> b) -> b -> UnitRef a -> b

foldr' :: (a -> b -> b) -> b -> UnitRef a -> b

foldl :: (b -> a -> b) -> b -> UnitRef a -> b

foldl' :: (b -> a -> b) -> b -> UnitRef a -> b

foldr1 :: (a -> a -> a) -> UnitRef a -> a

foldl1 :: (a -> a -> a) -> UnitRef a -> a

toList :: UnitRef a -> [a]

null :: UnitRef a -> Bool

length :: UnitRef a -> Int

elem :: Eq a => a -> UnitRef a -> Bool

maximum :: Ord a => UnitRef a -> a

minimum :: Ord a => UnitRef a -> a

sum :: Num a => UnitRef a -> a

product :: Num a => UnitRef a -> a

Traversable (UnitRef :: Type -> Type)

Defined in Data.Mutable.Instances

Methods

traverse :: Applicative f => (a -> f b) -> UnitRef a -> f (UnitRef b)

sequenceA :: Applicative f => UnitRef (f a) -> f (UnitRef a)

mapM :: Monad m => (a -> m b) -> UnitRef a -> m (UnitRef b)

sequence :: Monad m => UnitRef (m a) -> m (UnitRef a)

Eq (UnitRef s)

Defined in Data.Mutable.Instances

Methods

(==) :: UnitRef s -> UnitRef s -> Bool

(/=) :: UnitRef s -> UnitRef s -> Bool

Ord (UnitRef s)

Defined in Data.Mutable.Instances

Methods

compare :: UnitRef s -> UnitRef s -> Ordering

(<) :: UnitRef s -> UnitRef s -> Bool

(<=) :: UnitRef s -> UnitRef s -> Bool

(>) :: UnitRef s -> UnitRef s -> Bool

(>=) :: UnitRef s -> UnitRef s -> Bool

max :: UnitRef s -> UnitRef s -> UnitRef s

min :: UnitRef s -> UnitRef s -> UnitRef s

Read (UnitRef s)

Defined in Data.Mutable.Instances

Methods

readsPrec :: Int -> ReadS (UnitRef s)

readList :: ReadS [UnitRef s]

readPrec :: ReadPrec (UnitRef s)

readListPrec :: ReadPrec [UnitRef s]

Show (UnitRef s)

Defined in Data.Mutable.Instances

Methods

showsPrec :: Int -> UnitRef s -> ShowS

show :: UnitRef s -> String

showList :: [UnitRef s] -> ShowS

data VoidRef s

The Ref for Void.

Since: 0.2.0.0

Instances

Functor (VoidRef :: Type -> Type)

Defined in Data.Mutable.Instances

Methods

fmap :: (a -> b) -> VoidRef a -> VoidRef b

(<$) :: a -> VoidRef b -> VoidRef a

Foldable (VoidRef :: Type -> Type)

Defined in Data.Mutable.Instances

Methods

fold :: Monoid m => VoidRef m -> m

foldMap :: Monoid m => (a -> m) -> VoidRef a -> m

foldMap' :: Monoid m => (a -> m) -> VoidRef a -> m

foldr :: (a -> b -> b) -> b -> VoidRef a -> b

foldr' :: (a -> b -> b) -> b -> VoidRef a -> b

foldl :: (b -> a -> b) -> b -> VoidRef a -> b

foldl' :: (b -> a -> b) -> b -> VoidRef a -> b

foldr1 :: (a -> a -> a) -> VoidRef a -> a

foldl1 :: (a -> a -> a) -> VoidRef a -> a

toList :: VoidRef a -> [a]

null :: VoidRef a -> Bool

length :: VoidRef a -> Int

elem :: Eq a => a -> VoidRef a -> Bool

maximum :: Ord a => VoidRef a -> a

minimum :: Ord a => VoidRef a -> a

sum :: Num a => VoidRef a -> a

product :: Num a => VoidRef a -> a

Traversable (VoidRef :: Type -> Type)

Defined in Data.Mutable.Instances

Methods

traverse :: Applicative f => (a -> f b) -> VoidRef a -> f (VoidRef b)

sequenceA :: Applicative f => VoidRef (f a) -> f (VoidRef a)

mapM :: Monad m => (a -> m b) -> VoidRef a -> m (VoidRef b)

sequence :: Monad m => VoidRef (m a) -> m (VoidRef a)

Eq (VoidRef s)

Defined in Data.Mutable.Instances

Methods

(==) :: VoidRef s -> VoidRef s -> Bool

(/=) :: VoidRef s -> VoidRef s -> Bool

Ord (VoidRef s)

Defined in Data.Mutable.Instances

Methods

compare :: VoidRef s -> VoidRef s -> Ordering

(<) :: VoidRef s -> VoidRef s -> Bool

(<=) :: VoidRef s -> VoidRef s -> Bool

(>) :: VoidRef s -> VoidRef s -> Bool

(>=) :: VoidRef s -> VoidRef s -> Bool

max :: VoidRef s -> VoidRef s -> VoidRef s

min :: VoidRef s -> VoidRef s -> VoidRef s

Read (VoidRef s)

Defined in Data.Mutable.Instances

Methods

readsPrec :: Int -> ReadS (VoidRef s)

readList :: ReadS [VoidRef s]

readPrec :: ReadPrec (VoidRef s)

readListPrec :: ReadPrec [VoidRef s]

Show (VoidRef s)

Defined in Data.Mutable.Instances

Methods

showsPrec :: Int -> VoidRef s -> ShowS

show :: VoidRef s -> String

showList :: [VoidRef s] -> ShowS

Generic

newtype GRef s a

Automatically generate a piecewise mutable reference for any Generic instance.

-- | any Generic instance
data MyType = MyType { mtInt :: Int, mtDouble :: Double }
  deriving (Generic, Show)

instance Mutable s MyType where
    type Ref s MyType = GRef s MyType

ghci> r <- thawRef (MyType 3 4.5)
ghci> freezeRef r
MyType 3 4.5
ghci> freezePart (fieldMut #mtInt) r
3
ghci> copyPart (fieldMut #mtDouble) 1.23
ghci> freezeRef r
MyType 3 1.23

Note that this is basically just a bunch of tupled refs for a product type. For a sum type (with multiple constructors), an extra layer of indirection is added to account for the dynamically changable shape.

See Data.Mutable.Parts and Data.Mutable.Branches for nice ways to inspect and mutate the internals of this type (as demonstrated above).

If the facilities in those modules are not adequate, you can also manually crack open GRef and work with the internals. Getting the type of unGRef @MyType should allow you to navigate what is going on, if you are familiar with GHC.Generics. However, ideally, you would never need to do this.

Constructors

GRef

Fields

• unGRef :: GRef_ s (Rep a) ()

Instances

(Generic a, GMutable s (Rep a)) => DefaultMutable s a (GRef s a)

Defined in Data.Mutable.Internal

Methods

defaultThawRef :: (PrimMonad m, PrimState m ~ s) => a -> m (GRef s a)

defaultFreezeRef :: (PrimMonad m, PrimState m ~ s) => GRef s a -> m a

defaultCopyRef :: (PrimMonad m, PrimState m ~ s) => GRef s a -> a -> m ()

defaultMoveRef :: (PrimMonad m, PrimState m ~ s) => GRef s a -> GRef s a -> m ()

defaultCloneRef :: (PrimMonad m, PrimState m ~ s) => GRef s a -> m (GRef s a)

defaultUnsafeThawRef :: (PrimMonad m, PrimState m ~ s) => a -> m (GRef s a)

defaultUnsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => GRef s a -> m a

Eq (GRef_ s (Rep a) ()) => Eq (GRef s a)

Defined in Data.Mutable.Internal

Methods

(==) :: GRef s a -> GRef s a -> Bool

(/=) :: GRef s a -> GRef s a -> Bool

Ord (GRef_ s (Rep a) ()) => Ord (GRef s a)

Defined in Data.Mutable.Internal

Methods

compare :: GRef s a -> GRef s a -> Ordering

(<) :: GRef s a -> GRef s a -> Bool

(<=) :: GRef s a -> GRef s a -> Bool

(>) :: GRef s a -> GRef s a -> Bool

(>=) :: GRef s a -> GRef s a -> Bool

max :: GRef s a -> GRef s a -> GRef s a

min :: GRef s a -> GRef s a -> GRef s a

gThawRef :: (Generic a, GMutable s (Rep a), PrimMonad m, PrimState m ~ s) => a -> m (GRef s a)

Default thawRef for GRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with GRef as the Ref. However, it can be useful if you are using a GRef s a just as a normal data type, independent of the Ref class. See documentation for GRef for more information.

gFreezeRef :: (Generic a, GMutable s (Rep a), PrimMonad m, PrimState m ~ s) => GRef s a -> m a

Default freezeRef for GRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with GRef as the Ref. However, it can be useful if you are using a GRef s a just as a normal data type, independent of the Ref class. See documentation for GRef for more information.

gCopyRef :: (Generic a, GMutable s (Rep a), PrimMonad m, PrimState m ~ s) => GRef s a -> a -> m ()

Default copyRef for GRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with GRef as the Ref. However, it can be useful if you are using a GRef s a just as a normal data type, independent of the Ref class. See documentation for GRef for more information.

gMoveRef :: (GMutable s (Rep a), PrimMonad m, PrimState m ~ s) => GRef s a -> GRef s a -> m ()

Default moveRef for GRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with GRef as the Ref. However, it can be useful if you are using a GRef s a just as a normal data type, independent of the Ref class. See documentation for GRef for more information.

gCloneRef :: (GMutable s (Rep a), PrimMonad m, PrimState m ~ s) => GRef s a -> m (GRef s a)

Default cloneRef for GRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with GRef as the Ref. However, it can be useful if you are using a GRef s a just as a normal data type, independent of the Ref class. See documentation for GRef for more information.

gUnsafeThawRef :: (Generic a, GMutable s (Rep a), PrimMonad m, PrimState m ~ s) => a -> m (GRef s a)

Default unsafeThawRef for GRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with GRef as the Ref. However, it can be useful if you are using a GRef s a just as a normal data type, independent of the Ref class. See documentation for GRef for more information.

gUnsafeFreezeRef :: (Generic a, GMutable s (Rep a), PrimMonad m, PrimState m ~ s) => GRef s a -> m a

Default unsafeFreezeRef for GRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with GRef as the Ref. However, it can be useful if you are using a GRef s a just as a normal data type, independent of the Ref class. See documentation for GRef for more information.

class GMutable s (f :: Type -> Type)

Class for automatic generation of Ref for Generic instances. See GRef for more information.

Minimal complete definition

gThawRef_, gFreezeRef_, gCopyRef_, gMoveRef_, gCloneRef_, gUnsafeThawRef_, gUnsafeFreezeRef_

Associated Types

type GRef_ s f = (u :: Type -> Type) | u -> f

Instances

GMutable s (V1 :: Type -> Type)

Defined in Data.Mutable.Internal

Associated Types

type GRef_ s V1 = (u :: Type -> Type)

Methods

gThawRef_ :: (PrimMonad m, PrimState m ~ s) => V1 a -> m (GRef_ s V1 a)

gFreezeRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s V1 a -> m (V1 a)

gCopyRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s V1 a -> V1 a -> m ()

gMoveRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s V1 a -> GRef_ s V1 a -> m ()

gCloneRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s V1 a -> m (GRef_ s V1 a)

gUnsafeThawRef_ :: (PrimMonad m, PrimState m ~ s) => V1 a -> m (GRef_ s V1 a)

gUnsafeFreezeRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s V1 a -> m (V1 a)

GMutable s (U1 :: Type -> Type)

Defined in Data.Mutable.Internal

Associated Types

type GRef_ s U1 = (u :: Type -> Type)

Methods

gThawRef_ :: (PrimMonad m, PrimState m ~ s) => U1 a -> m (GRef_ s U1 a)

gFreezeRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s U1 a -> m (U1 a)

gCopyRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s U1 a -> U1 a -> m ()

gMoveRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s U1 a -> GRef_ s U1 a -> m ()

gCloneRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s U1 a -> m (GRef_ s U1 a)

gUnsafeThawRef_ :: (PrimMonad m, PrimState m ~ s) => U1 a -> m (GRef_ s U1 a)

gUnsafeFreezeRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s U1 a -> m (U1 a)

(GMutable s f, GMutable s g) => GMutable s (f :+: g)

Defined in Data.Mutable.Internal

Associated Types

type GRef_ s (f :+: g) = (u :: Type -> Type)

Methods

gThawRef_ :: (PrimMonad m, PrimState m ~ s) => (f :+: g) a -> m (GRef_ s (f :+: g) a)

gFreezeRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (f :+: g) a -> m ((f :+: g) a)

gCopyRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (f :+: g) a -> (f :+: g) a -> m ()

gMoveRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (f :+: g) a -> GRef_ s (f :+: g) a -> m ()

gCloneRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (f :+: g) a -> m (GRef_ s (f :+: g) a)

gUnsafeThawRef_ :: (PrimMonad m, PrimState m ~ s) => (f :+: g) a -> m (GRef_ s (f :+: g) a)

gUnsafeFreezeRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (f :+: g) a -> m ((f :+: g) a)

(GMutable s f, GMutable s g) => GMutable s (f :*: g)

Defined in Data.Mutable.Internal

Associated Types

type GRef_ s (f :*: g) = (u :: Type -> Type)

Methods

gThawRef_ :: (PrimMonad m, PrimState m ~ s) => (f :*: g) a -> m (GRef_ s (f :*: g) a)

gFreezeRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (f :*: g) a -> m ((f :*: g) a)

gCopyRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (f :*: g) a -> (f :*: g) a -> m ()

gMoveRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (f :*: g) a -> GRef_ s (f :*: g) a -> m ()

gCloneRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (f :*: g) a -> m (GRef_ s (f :*: g) a)

gUnsafeThawRef_ :: (PrimMonad m, PrimState m ~ s) => (f :*: g) a -> m (GRef_ s (f :*: g) a)

gUnsafeFreezeRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (f :*: g) a -> m ((f :*: g) a)

Mutable s c => GMutable s (K1 i c :: Type -> Type)

Defined in Data.Mutable.Internal

Associated Types

type GRef_ s (K1 i c) = (u :: Type -> Type)

Methods

gThawRef_ :: (PrimMonad m, PrimState m ~ s) => K1 i c a -> m (GRef_ s (K1 i c) a)

gFreezeRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (K1 i c) a -> m (K1 i c a)

gCopyRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (K1 i c) a -> K1 i c a -> m ()

gMoveRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (K1 i c) a -> GRef_ s (K1 i c) a -> m ()

gCloneRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (K1 i c) a -> m (GRef_ s (K1 i c) a)

gUnsafeThawRef_ :: (PrimMonad m, PrimState m ~ s) => K1 i c a -> m (GRef_ s (K1 i c) a)

gUnsafeFreezeRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (K1 i c) a -> m (K1 i c a)

GMutable s f => GMutable s (M1 i c f)

Defined in Data.Mutable.Internal

Associated Types

type GRef_ s (M1 i c f) = (u :: Type -> Type)

Methods

gThawRef_ :: (PrimMonad m, PrimState m ~ s) => M1 i c f a -> m (GRef_ s (M1 i c f) a)

gFreezeRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (M1 i c f) a -> m (M1 i c f a)

gCopyRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (M1 i c f) a -> M1 i c f a -> m ()

gMoveRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (M1 i c f) a -> GRef_ s (M1 i c f) a -> m ()

gCloneRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (M1 i c f) a -> m (GRef_ s (M1 i c f) a)

gUnsafeThawRef_ :: (PrimMonad m, PrimState m ~ s) => M1 i c f a -> m (GRef_ s (M1 i c f) a)

gUnsafeFreezeRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s (M1 i c f) a -> m (M1 i c f a)

Higher-Kinded Data Pattern

thawHKD :: forall z m s. (Generic (z Identity), Generic (z (RefFor s)), GMutable s (Rep (z Identity)), GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s)), PrimMonad m, PrimState m ~ s) => z Identity -> m (z (RefFor s))

Default thawRef for the higher-kinded data pattern, a la https://reasonablypolymorphic.com/blog/higher-kinded-data/.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with z (RefFor s) as the Ref. However, it can be useful if you are using a z (RefFor s) just as a normal data type, independent of the Ref class. See documentation for Mutable for more information.

freezeHKD :: forall z m s. (Generic (z Identity), Generic (z (RefFor s)), GMutable s (Rep (z Identity)), GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s)), PrimMonad m, PrimState m ~ s) => z (RefFor s) -> m (z Identity)

Default freezeRef for the higher-kinded data pattern, a la https://reasonablypolymorphic.com/blog/higher-kinded-data/.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with z (RefFor s) as the Ref. However, it can be useful if you are using a z (RefFor s) just as a normal data type, independent of the Ref class. See documentation for Mutable for more information.

copyHKD :: forall z m s. (Generic (z Identity), Generic (z (RefFor s)), GMutable s (Rep (z Identity)), GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s)), PrimMonad m, PrimState m ~ s) => z (RefFor s) -> z Identity -> m ()

Default copyRef for the higher-kinded data pattern, a la https://reasonablypolymorphic.com/blog/higher-kinded-data/.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with z (RefFor s) as the Ref. However, it can be useful if you are using a z (RefFor s) just as a normal data type, independent of the Ref class. See documentation for Mutable for more information.

moveHKD :: forall z m s. (Generic (z (RefFor s)), GMutable s (Rep (z Identity)), GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s)), PrimMonad m, PrimState m ~ s) => z (RefFor s) -> z (RefFor s) -> m ()

Default moveRef for the higher-kinded data pattern, a la https://reasonablypolymorphic.com/blog/higher-kinded-data/.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with z (RefFor s) as the Ref. However, it can be useful if you are using a z (RefFor s) just as a normal data type, independent of the Ref class. See documentation for Mutable for more information.

cloneHKD :: forall z m s. (Generic (z (RefFor s)), GMutable s (Rep (z Identity)), GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s)), PrimMonad m, PrimState m ~ s) => z (RefFor s) -> m (z (RefFor s))

Default cloneRef for the higher-kinded data pattern, a la https://reasonablypolymorphic.com/blog/higher-kinded-data/.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with z (RefFor s) as the Ref. However, it can be useful if you are using a z (RefFor s) just as a normal data type, independent of the Ref class. See documentation for Mutable for more information.

unsafeThawHKD :: forall z m s. (Generic (z Identity), Generic (z (RefFor s)), GMutable s (Rep (z Identity)), GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s)), PrimMonad m, PrimState m ~ s) => z Identity -> m (z (RefFor s))

Default unsafeThawRef for the higher-kinded data pattern, a la https://reasonablypolymorphic.com/blog/higher-kinded-data/.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with z (RefFor s) as the Ref. However, it can be useful if you are using a z (RefFor s) just as a normal data type, independent of the Ref class. See documentation for Mutable for more information.

unsafeFreezeHKD :: forall z m s. (Generic (z Identity), Generic (z (RefFor s)), GMutable s (Rep (z Identity)), GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s)), PrimMonad m, PrimState m ~ s) => z (RefFor s) -> m (z Identity)

Default unsafeFreezeRef for the higher-kinded data pattern, a la https://reasonablypolymorphic.com/blog/higher-kinded-data/.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with z (RefFor s) as the Ref. However, it can be useful if you are using a z (RefFor s) just as a normal data type, independent of the Ref class. See documentation for Mutable for more information.

Coercible

newtype CoerceRef s b a

A Ref that works by using the Mutable instance of an equivalent type. This is useful for newtype wrappers, so you can use the underlying data type's Mutable instance.

newtype MyVec = MyVec (Vector Double)

instance Mutable s MyVec where
    type Ref s MyVec = CoerceRef s s (Vector Double)

The Ref s MyVec uses the a MVector Double under the hood.

It's essentially a special case of GRef for newtypes.

Constructors

CoerceRef

Fields

• getCoerceRef :: Ref s a

Instances

(Coercible b a, Mutable s a) => DefaultMutable s b (CoerceRef s b a)

Defined in Data.Mutable.Internal

Methods

defaultThawRef :: (PrimMonad m, PrimState m ~ s) => b -> m (CoerceRef s b a)

defaultFreezeRef :: (PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> m b

defaultCopyRef :: (PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> b -> m ()

defaultMoveRef :: (PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> CoerceRef s b a -> m ()

defaultCloneRef :: (PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> m (CoerceRef s b a)

defaultUnsafeThawRef :: (PrimMonad m, PrimState m ~ s) => b -> m (CoerceRef s b a)

defaultUnsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> m b

IsoHKD (CoerceRef s b :: Type -> Type) (a :: Type)

Use a CoerceRef s b a as if it were a Ref s a

Defined in Data.Mutable.Internal

Associated Types

type HKD (CoerceRef s b) a

Methods

unHKD :: HKD (CoerceRef s b) a -> CoerceRef s b a

toHKD :: CoerceRef s b a -> HKD (CoerceRef s b) a

Eq (Ref s a) => Eq (CoerceRef s b a)

Defined in Data.Mutable.Internal

Methods

(==) :: CoerceRef s b a -> CoerceRef s b a -> Bool

(/=) :: CoerceRef s b a -> CoerceRef s b a -> Bool

Ord (Ref s a) => Ord (CoerceRef s b a)

Defined in Data.Mutable.Internal

Methods

compare :: CoerceRef s b a -> CoerceRef s b a -> Ordering

(<) :: CoerceRef s b a -> CoerceRef s b a -> Bool

(<=) :: CoerceRef s b a -> CoerceRef s b a -> Bool

(>) :: CoerceRef s b a -> CoerceRef s b a -> Bool

(>=) :: CoerceRef s b a -> CoerceRef s b a -> Bool

max :: CoerceRef s b a -> CoerceRef s b a -> CoerceRef s b a

min :: CoerceRef s b a -> CoerceRef s b a -> CoerceRef s b a

type HKD (CoerceRef s b :: Type -> Type) (a :: Type)

Defined in Data.Mutable.Internal

type HKD (CoerceRef s b :: Type -> Type) (a :: Type) = Ref s a

thawCoerce :: (Coercible b a, Mutable s a, PrimMonad m, PrimState m ~ s) => b -> m (CoerceRef s b a)

Default thawRef for CoerceRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with CoerceRef as the Ref. However, it can be useful if you are using a CoerceRef s b a just as a normal data type, independent of the Ref class. See documentation for CoerceRef for more information.

freezeCoerce :: (Coercible b a, Mutable s a, PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> m b

Default freezeRef for CoerceRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with CoerceRef as the Ref. However, it can be useful if you are using a CoerceRef s b a just as a normal data type, independent of the Ref class. See documentation for CoerceRef for more information.

copyCoerce :: (Coercible b a, Mutable s a, PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> b -> m ()

Default copyRef for CoerceRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with CoerceRef as the Ref. However, it can be useful if you are using a CoerceRef s b a just as a normal data type, independent of the Ref class. See documentation for CoerceRef for more information.

moveCoerce :: (Mutable s a, PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> CoerceRef s b a -> m ()

Default moveRef for CoerceRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with CoerceRef as the Ref. However, it can be useful if you are using a CoerceRef s b a just as a normal data type, independent of the Ref class. See documentation for CoerceRef for more information.

cloneCoerce :: (Mutable s a, PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> m (CoerceRef s b a)

Default cloneRef for CoerceRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with CoerceRef as the Ref. However, it can be useful if you are using a CoerceRef s b a just as a normal data type, independent of the Ref class. See documentation for CoerceRef for more information.

unsafeThawCoerce :: (Coercible b a, Mutable s a, PrimMonad m, PrimState m ~ s) => b -> m (CoerceRef s b a)

Default unsafeThawRef for CoerceRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with CoerceRef as the Ref. However, it can be useful if you are using a CoerceRef s b a just as a normal data type, independent of the Ref class. See documentation for CoerceRef for more information.

unsafeFreezeCoerce :: (Coercible b a, Mutable s a, PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> m b

Default unsafeFreezeRef for CoerceRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with CoerceRef as the Ref. However, it can be useful if you are using a CoerceRef s b a just as a normal data type, independent of the Ref class. See documentation for CoerceRef for more information.

Traversable

newtype TraverseRef s f a

A Ref that works for any instance of Traversable, by using the fields of the Traversable instance to purely store mutable references.

Note that this really only makes complete sense if the Traversable is fixed-size, or you never modify the length of the traversable as you use it as a reference.

If you do modify the length, copying and modifying semantics can be a bit funky:

• If copying a shorter item into a longer item ref, the "leftovers" items in the longer item are unchanged.
• If copying a longer item into a shorter item ref, the leftover items are unchanged.

ghci> r <- thawTraverse [1..10]
ghci> copyTraverse r [0,0,0,0]
ghci> freezeTraverse r
[0,0,0,0,5,6,7,8,9,10]
ghci> copyTraverse r [20..50]
ghci> freezeTraverse r
[20,21,22,23,24,25,26,27,28,29]

Constructors

TraverseRef

Fields

• getTraverseRef :: f (Ref s a)

Instances

(Traversable f, Mutable s a) => DefaultMutable s (f a) (TraverseRef s f a)

Defined in Data.Mutable.Internal

Methods

defaultThawRef :: (PrimMonad m, PrimState m ~ s) => f a -> m (TraverseRef s f a)

defaultFreezeRef :: (PrimMonad m, PrimState m ~ s) => TraverseRef s f a -> m (f a)

defaultCopyRef :: (PrimMonad m, PrimState m ~ s) => TraverseRef s f a -> f a -> m ()

defaultMoveRef :: (PrimMonad m, PrimState m ~ s) => TraverseRef s f a -> TraverseRef s f a -> m ()

defaultCloneRef :: (PrimMonad m, PrimState m ~ s) => TraverseRef s f a -> m (TraverseRef s f a)

defaultUnsafeThawRef :: (PrimMonad m, PrimState m ~ s) => f a -> m (TraverseRef s f a)

defaultUnsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => TraverseRef s f a -> m (f a)

IsoHKD (TraverseRef s f :: Type -> Type) (a :: Type)

Use a TraverseRef s f a as if it were a f (Ref s a)

Defined in Data.Mutable.Internal

Associated Types

type HKD (TraverseRef s f) a

Methods

unHKD :: HKD (TraverseRef s f) a -> TraverseRef s f a

toHKD :: TraverseRef s f a -> HKD (TraverseRef s f) a

type HKD (TraverseRef s f :: Type -> Type) (a :: Type)

Defined in Data.Mutable.Internal

type HKD (TraverseRef s f :: Type -> Type) (a :: Type) = f (Ref s a)

thawTraverse :: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s) => f a -> m (TraverseRef s f a)

Default thawRef for TraverseRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with TraverseRef as the Ref. However, it can be useful if you are using a TraverseRef m f a just as a normal data type, independent of the Ref class. See documentation for TraverseRef for more information.

freezeTraverse :: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s) => TraverseRef s f a -> m (f a)

Default freezeRef for TraverseRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with TraverseRef as the Ref. However, it can be useful if you are using a TraverseRef m f a just as a normal data type, independent of the Ref class. See documentation for TraverseRef for more information.

copyTraverse :: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s) => TraverseRef s f a -> f a -> m ()

Default copyRef for TraverseRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with TraverseRef as the Ref. However, it can be useful if you are using a TraverseRef m f a just as a normal data type, independent of the Ref class. See documentation for TraverseRef for more information.

moveTraverse

Arguments

:: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s)

=> TraverseRef s f a

destination

-> TraverseRef s f a

source

-> m ()

Default moveRef for TraverseRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with TraverseRef as the Ref. However, it can be useful if you are using a TraverseRef m f a just as a normal data type, independent of the Ref class. See documentation for TraverseRef for more information.

cloneTraverse :: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s) => TraverseRef s f a -> m (TraverseRef s f a)

Default cloneRef for TraverseRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with TraverseRef as the Ref. However, it can be useful if you are using a TraverseRef m f a just as a normal data type, independent of the Ref class. See documentation for TraverseRef for more information.

unsafeThawTraverse :: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s) => f a -> m (TraverseRef s f a)

Default unsafeThawRef for TraverseRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with TraverseRef as the Ref. However, it can be useful if you are using a TraverseRef m f a just as a normal data type, independent of the Ref class. See documentation for TraverseRef for more information.

unsafeFreezeTraverse :: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s) => TraverseRef s f a -> m (f a)

Default unsafeFreezeRef for TraverseRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with TraverseRef as the Ref. However, it can be useful if you are using a TraverseRef m f a just as a normal data type, independent of the Ref class. See documentation for TraverseRef for more information.

Immutable

newtype ImmutableRef s a

A "Ref" that can be used to give a default Mutable instance that is immutable. Nothing is allocated ever, all attempts to modify it will be ignored, and freezeRef will just get the original thawed value.

Really only exists to be used with Immutable.

Constructors

ImmutableRef

Fields

• getImmutableRef :: a

Instances

DefaultMutable s a (ImmutableRef s a)

Defined in Data.Mutable.Internal

Methods

defaultThawRef :: (PrimMonad m, PrimState m ~ s) => a -> m (ImmutableRef s a)

defaultFreezeRef :: (PrimMonad m, PrimState m ~ s) => ImmutableRef s a -> m a

defaultCopyRef :: (PrimMonad m, PrimState m ~ s) => ImmutableRef s a -> a -> m ()

defaultMoveRef :: (PrimMonad m, PrimState m ~ s) => ImmutableRef s a -> ImmutableRef s a -> m ()

defaultCloneRef :: (PrimMonad m, PrimState m ~ s) => ImmutableRef s a -> m (ImmutableRef s a)

defaultUnsafeThawRef :: (PrimMonad m, PrimState m ~ s) => a -> m (ImmutableRef s a)

defaultUnsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => ImmutableRef s a -> m a

IsoHKD (ImmutableRef s :: Type -> Type) (a :: Type)

Use a ImmutableRef a as if it were an a

Defined in Data.Mutable.Internal

Associated Types

type HKD (ImmutableRef s) a

Methods

unHKD :: HKD (ImmutableRef s) a -> ImmutableRef s a

toHKD :: ImmutableRef s a -> HKD (ImmutableRef s) a

type HKD (ImmutableRef s :: Type -> Type) (a :: Type)

Defined in Data.Mutable.Internal

type HKD (ImmutableRef s :: Type -> Type) (a :: Type) = a

thawImmutable :: Applicative m => a -> m (ImmutableRef s a)

Default thawRef for ImmutableRef.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with ImmutableRef as the Ref. However, it can be useful if you are using a ImmutableRef s b a just as a normal data type, independent of the Ref class. See documentation for ImmutableRef for more information.

freezeImmutable :: Applicative m => ImmutableRef s a -> m a

Default freezeRef for ImmutableRef. This will always return the originally thawed value, ignoring all copies and writes.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with ImmutableRef as the Ref. However, it can be useful if you are using a ImmutableRef s b a just as a normal data type, independent of the Ref class. See documentation for ImmutableRef for more information.

copyImmutable :: Applicative m => ImmutableRef s a -> a -> m ()

Default copyRef for ImmutableRef. This is a no-op and does nothing, since freezing will always return the originally thawed value.

You likely won't ever use this directly, since it is automatically provided if you have a Mutable instance with ImmutableRef as the Ref. However, it can be useful if you are using a ImmutableRef s b a just as a normal data type, independent of the Ref class. See documentation for ImmutableRef for more information.

Instances for Generics combinators themselves

newtype GMutableRef s f a

A Ref for instances of GMutable, which are the GHC.Generics combinators.

Constructors

GMutableRef

Fields

• getGMutableRef :: GRef_ s f a

Instances

Eq (GRef_ s f a) => Eq (GMutableRef s f a)

Defined in Data.Mutable.Internal

Methods

(==) :: GMutableRef s f a -> GMutableRef s f a -> Bool

(/=) :: GMutableRef s f a -> GMutableRef s f a -> Bool

Ord (GRef_ s f a) => Ord (GMutableRef s f a)

Defined in Data.Mutable.Internal

Methods

compare :: GMutableRef s f a -> GMutableRef s f a -> Ordering

(<) :: GMutableRef s f a -> GMutableRef s f a -> Bool

(<=) :: GMutableRef s f a -> GMutableRef s f a -> Bool

(>) :: GMutableRef s f a -> GMutableRef s f a -> Bool

(>=) :: GMutableRef s f a -> GMutableRef s f a -> Bool

max :: GMutableRef s f a -> GMutableRef s f a -> GMutableRef s f a

min :: GMutableRef s f a -> GMutableRef s f a -> GMutableRef s f a

newtype MutSumF s f g a

Wraps :+: in a mutable reference. Used internally to represent generic sum references.

Constructors

MutSumF

Fields

• getMutSumF :: MutVar s ((f :+: g) a)

Utility

type family MapRef s as where ...

Useful type family to Ref m over every item in a type-level list

ghci> :kind! MapRef IO '[Int, V.Vector Double]
'[ MutVar RealWorld Int, MVector RealWorld Double ]

Equations

MapRef s '[] = '[]

MapRef s (a ': as) = Ref s a ': MapRef s as

Orphan instances

Mutable s ()

Associated Types

type Ref s () = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => () -> m (Ref s ())

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s () -> m ()

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s () -> () -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s () -> Ref s () -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s () -> m (Ref s ())

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => () -> m (Ref s ())

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s () -> m ()

Mutable s Void

Associated Types

type Ref s Void = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Void -> m (Ref s Void)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Void -> m Void

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s Void -> Void -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s Void -> Ref s Void -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s Void -> m (Ref s Void)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Void -> m (Ref s Void)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Void -> m Void

Mutable s ByteArray

Associated Types

type Ref s ByteArray = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => ByteArray -> m (Ref s ByteArray)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s ByteArray -> m ByteArray

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s ByteArray -> ByteArray -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s ByteArray -> Ref s ByteArray -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s ByteArray -> m (Ref s ByteArray)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => ByteArray -> m (Ref s ByteArray)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s ByteArray -> m ByteArray

Mutable s CDouble

Associated Types

type Ref s CDouble = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CDouble -> m (Ref s CDouble)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CDouble -> m CDouble

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CDouble -> CDouble -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CDouble -> Ref s CDouble -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CDouble -> m (Ref s CDouble)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CDouble -> m (Ref s CDouble)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CDouble -> m CDouble

Mutable s CFloat

Associated Types

type Ref s CFloat = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CFloat -> m (Ref s CFloat)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CFloat -> m CFloat

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CFloat -> CFloat -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CFloat -> Ref s CFloat -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CFloat -> m (Ref s CFloat)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CFloat -> m (Ref s CFloat)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CFloat -> m CFloat

Mutable s CSUSeconds

Associated Types

type Ref s CSUSeconds = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CSUSeconds -> m (Ref s CSUSeconds)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSUSeconds -> m CSUSeconds

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSUSeconds -> CSUSeconds -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSUSeconds -> Ref s CSUSeconds -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSUSeconds -> m (Ref s CSUSeconds)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CSUSeconds -> m (Ref s CSUSeconds)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSUSeconds -> m CSUSeconds

Mutable s CUSeconds

Associated Types

type Ref s CUSeconds = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CUSeconds -> m (Ref s CUSeconds)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUSeconds -> m CUSeconds

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUSeconds -> CUSeconds -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUSeconds -> Ref s CUSeconds -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUSeconds -> m (Ref s CUSeconds)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CUSeconds -> m (Ref s CUSeconds)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUSeconds -> m CUSeconds

Mutable s CTime

Associated Types

type Ref s CTime = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CTime -> m (Ref s CTime)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CTime -> m CTime

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CTime -> CTime -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CTime -> Ref s CTime -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CTime -> m (Ref s CTime)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CTime -> m (Ref s CTime)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CTime -> m CTime

Mutable s CClock

Associated Types

type Ref s CClock = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CClock -> m (Ref s CClock)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CClock -> m CClock

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CClock -> CClock -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CClock -> Ref s CClock -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CClock -> m (Ref s CClock)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CClock -> m (Ref s CClock)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CClock -> m CClock

Mutable s CUIntMax

Associated Types

type Ref s CUIntMax = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CUIntMax -> m (Ref s CUIntMax)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUIntMax -> m CUIntMax

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUIntMax -> CUIntMax -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUIntMax -> Ref s CUIntMax -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUIntMax -> m (Ref s CUIntMax)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CUIntMax -> m (Ref s CUIntMax)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUIntMax -> m CUIntMax

Mutable s CIntMax

Associated Types

type Ref s CIntMax = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CIntMax -> m (Ref s CIntMax)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CIntMax -> m CIntMax

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CIntMax -> CIntMax -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CIntMax -> Ref s CIntMax -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CIntMax -> m (Ref s CIntMax)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CIntMax -> m (Ref s CIntMax)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CIntMax -> m CIntMax

Mutable s CUIntPtr

Associated Types

type Ref s CUIntPtr = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CUIntPtr -> m (Ref s CUIntPtr)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUIntPtr -> m CUIntPtr

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUIntPtr -> CUIntPtr -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUIntPtr -> Ref s CUIntPtr -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUIntPtr -> m (Ref s CUIntPtr)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CUIntPtr -> m (Ref s CUIntPtr)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUIntPtr -> m CUIntPtr

Mutable s CIntPtr

Associated Types

type Ref s CIntPtr = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CIntPtr -> m (Ref s CIntPtr)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CIntPtr -> m CIntPtr

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CIntPtr -> CIntPtr -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CIntPtr -> Ref s CIntPtr -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CIntPtr -> m (Ref s CIntPtr)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CIntPtr -> m (Ref s CIntPtr)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CIntPtr -> m CIntPtr

Mutable s CBool

Associated Types

type Ref s CBool = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CBool -> m (Ref s CBool)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CBool -> m CBool

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CBool -> CBool -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CBool -> Ref s CBool -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CBool -> m (Ref s CBool)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CBool -> m (Ref s CBool)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CBool -> m CBool

Mutable s CULLong

Associated Types

type Ref s CULLong = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CULLong -> m (Ref s CULLong)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CULLong -> m CULLong

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CULLong -> CULLong -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CULLong -> Ref s CULLong -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CULLong -> m (Ref s CULLong)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CULLong -> m (Ref s CULLong)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CULLong -> m CULLong

Mutable s CLLong

Associated Types

type Ref s CLLong = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CLLong -> m (Ref s CLLong)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CLLong -> m CLLong

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CLLong -> CLLong -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CLLong -> Ref s CLLong -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CLLong -> m (Ref s CLLong)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CLLong -> m (Ref s CLLong)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CLLong -> m CLLong

Mutable s CSigAtomic

Associated Types

type Ref s CSigAtomic = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CSigAtomic -> m (Ref s CSigAtomic)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSigAtomic -> m CSigAtomic

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSigAtomic -> CSigAtomic -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSigAtomic -> Ref s CSigAtomic -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSigAtomic -> m (Ref s CSigAtomic)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CSigAtomic -> m (Ref s CSigAtomic)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSigAtomic -> m CSigAtomic

Mutable s CWchar

Associated Types

type Ref s CWchar = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CWchar -> m (Ref s CWchar)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CWchar -> m CWchar

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CWchar -> CWchar -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CWchar -> Ref s CWchar -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CWchar -> m (Ref s CWchar)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CWchar -> m (Ref s CWchar)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CWchar -> m CWchar

Mutable s CSize

Associated Types

type Ref s CSize = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CSize -> m (Ref s CSize)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSize -> m CSize

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSize -> CSize -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSize -> Ref s CSize -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSize -> m (Ref s CSize)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CSize -> m (Ref s CSize)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSize -> m CSize

Mutable s CPtrdiff

Associated Types

type Ref s CPtrdiff = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CPtrdiff -> m (Ref s CPtrdiff)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CPtrdiff -> m CPtrdiff

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CPtrdiff -> CPtrdiff -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CPtrdiff -> Ref s CPtrdiff -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CPtrdiff -> m (Ref s CPtrdiff)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CPtrdiff -> m (Ref s CPtrdiff)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CPtrdiff -> m CPtrdiff

Mutable s CULong

Associated Types

type Ref s CULong = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CULong -> m (Ref s CULong)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CULong -> m CULong

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CULong -> CULong -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CULong -> Ref s CULong -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CULong -> m (Ref s CULong)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CULong -> m (Ref s CULong)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CULong -> m CULong

Mutable s CLong

Associated Types

type Ref s CLong = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CLong -> m (Ref s CLong)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CLong -> m CLong

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CLong -> CLong -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CLong -> Ref s CLong -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CLong -> m (Ref s CLong)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CLong -> m (Ref s CLong)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CLong -> m CLong

Mutable s CUInt

Associated Types

type Ref s CUInt = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CUInt -> m (Ref s CUInt)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUInt -> m CUInt

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUInt -> CUInt -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUInt -> Ref s CUInt -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUInt -> m (Ref s CUInt)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CUInt -> m (Ref s CUInt)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUInt -> m CUInt

Mutable s CInt

Associated Types

type Ref s CInt = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CInt -> m (Ref s CInt)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CInt -> m CInt

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CInt -> CInt -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CInt -> Ref s CInt -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CInt -> m (Ref s CInt)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CInt -> m (Ref s CInt)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CInt -> m CInt

Mutable s CUShort

Associated Types

type Ref s CUShort = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CUShort -> m (Ref s CUShort)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUShort -> m CUShort

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUShort -> CUShort -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUShort -> Ref s CUShort -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUShort -> m (Ref s CUShort)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CUShort -> m (Ref s CUShort)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUShort -> m CUShort

Mutable s CShort

Associated Types

type Ref s CShort = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CShort -> m (Ref s CShort)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CShort -> m CShort

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CShort -> CShort -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CShort -> Ref s CShort -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CShort -> m (Ref s CShort)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CShort -> m (Ref s CShort)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CShort -> m CShort

Mutable s CUChar

Associated Types

type Ref s CUChar = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CUChar -> m (Ref s CUChar)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUChar -> m CUChar

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUChar -> CUChar -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUChar -> Ref s CUChar -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUChar -> m (Ref s CUChar)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CUChar -> m (Ref s CUChar)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CUChar -> m CUChar

Mutable s CSChar

Associated Types

type Ref s CSChar = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CSChar -> m (Ref s CSChar)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSChar -> m CSChar

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSChar -> CSChar -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSChar -> Ref s CSChar -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSChar -> m (Ref s CSChar)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CSChar -> m (Ref s CSChar)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CSChar -> m CSChar

Mutable s CChar

Associated Types

type Ref s CChar = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => CChar -> m (Ref s CChar)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CChar -> m CChar

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s CChar -> CChar -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s CChar -> Ref s CChar -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s CChar -> m (Ref s CChar)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => CChar -> m (Ref s CChar)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s CChar -> m CChar

Mutable s Word64

Associated Types

type Ref s Word64 = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Word64 -> m (Ref s Word64)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word64 -> m Word64

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word64 -> Word64 -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word64 -> Ref s Word64 -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word64 -> m (Ref s Word64)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Word64 -> m (Ref s Word64)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word64 -> m Word64

Mutable s Word16

Associated Types

type Ref s Word16 = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Word16 -> m (Ref s Word16)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word16 -> m Word16

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word16 -> Word16 -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word16 -> Ref s Word16 -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word16 -> m (Ref s Word16)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Word16 -> m (Ref s Word16)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word16 -> m Word16

Mutable s Word8

Associated Types

type Ref s Word8 = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Word8 -> m (Ref s Word8)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word8 -> m Word8

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word8 -> Word8 -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word8 -> Ref s Word8 -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word8 -> m (Ref s Word8)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Word8 -> m (Ref s Word8)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word8 -> m Word8

Mutable s Word

Associated Types

type Ref s Word = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Word -> m (Ref s Word)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word -> m Word

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word -> Word -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word -> Ref s Word -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word -> m (Ref s Word)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Word -> m (Ref s Word)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Word -> m Word

Mutable s Char

Associated Types

type Ref s Char = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Char -> m (Ref s Char)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Char -> m Char

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s Char -> Char -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s Char -> Ref s Char -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s Char -> m (Ref s Char)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Char -> m (Ref s Char)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Char -> m Char

Mutable s Bool

Associated Types

type Ref s Bool = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Bool -> m (Ref s Bool)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Bool -> m Bool

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s Bool -> Bool -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s Bool -> Ref s Bool -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s Bool -> m (Ref s Bool)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Bool -> m (Ref s Bool)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Bool -> m Bool

Mutable s Double

Associated Types

type Ref s Double = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Double -> m (Ref s Double)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Double -> m Double

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s Double -> Double -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s Double -> Ref s Double -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s Double -> m (Ref s Double)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Double -> m (Ref s Double)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Double -> m Double

Mutable s Float

Associated Types

type Ref s Float = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Float -> m (Ref s Float)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Float -> m Float

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s Float -> Float -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s Float -> Ref s Float -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s Float -> m (Ref s Float)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Float -> m (Ref s Float)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Float -> m Float

Mutable s Natural

Associated Types

type Ref s Natural = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Natural -> m (Ref s Natural)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Natural -> m Natural

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s Natural -> Natural -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s Natural -> Ref s Natural -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s Natural -> m (Ref s Natural)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Natural -> m (Ref s Natural)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Natural -> m Natural

Mutable s Integer

Associated Types

type Ref s Integer = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Integer -> m (Ref s Integer)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Integer -> m Integer

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s Integer -> Integer -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s Integer -> Ref s Integer -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s Integer -> m (Ref s Integer)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Integer -> m (Ref s Integer)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Integer -> m Integer

Mutable s Int

Associated Types

type Ref s Int = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Int -> m (Ref s Int)

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Int -> m Int

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s Int -> Int -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s Int -> Ref s Int -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s Int -> m (Ref s Int)

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Int -> m (Ref s Int)

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s Int -> m Int

Prim a => Mutable s (PrimArray a)

Associated Types

type Ref s (PrimArray a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => PrimArray a -> m (Ref s (PrimArray a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (PrimArray a) -> m (PrimArray a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (PrimArray a) -> PrimArray a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (PrimArray a) -> Ref s (PrimArray a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (PrimArray a) -> m (Ref s (PrimArray a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => PrimArray a -> m (Ref s (PrimArray a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (PrimArray a) -> m (PrimArray a)

Mutable s (SmallArray a)

Associated Types

type Ref s (SmallArray a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => SmallArray a -> m (Ref s (SmallArray a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (SmallArray a) -> m (SmallArray a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (SmallArray a) -> SmallArray a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (SmallArray a) -> Ref s (SmallArray a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (SmallArray a) -> m (Ref s (SmallArray a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => SmallArray a -> m (Ref s (SmallArray a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (SmallArray a) -> m (SmallArray a)

Mutable s (Array a)

Associated Types

type Ref s (Array a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Array a -> m (Ref s (Array a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Array a) -> m (Array a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Array a) -> Array a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Array a) -> Ref s (Array a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Array a) -> m (Ref s (Array a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Array a -> m (Ref s (Array a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Array a) -> m (Array a)

Prim a => Mutable s (Vector a)

Mutable reference is MVector.

Associated Types

type Ref s (Vector a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Vector a -> m (Ref s (Vector a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> m (Vector a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> Vector a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> Ref s (Vector a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> m (Ref s (Vector a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Vector a -> m (Ref s (Vector a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> m (Vector a)

Unbox a => Mutable s (Vector a)

Mutable reference is MVector.

Associated Types

type Ref s (Vector a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Vector a -> m (Ref s (Vector a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> m (Vector a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> Vector a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> Ref s (Vector a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> m (Ref s (Vector a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Vector a -> m (Ref s (Vector a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> m (Vector a)

Storable a => Mutable s (Vector a)

Mutable reference is MVector.

Associated Types

type Ref s (Vector a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Vector a -> m (Ref s (Vector a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> m (Vector a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> Vector a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> Ref s (Vector a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> m (Ref s (Vector a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Vector a -> m (Ref s (Vector a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> m (Vector a)

Mutable s (Vector a)

Mutable reference is MVector.

Associated Types

type Ref s (Vector a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Vector a -> m (Ref s (Vector a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> m (Vector a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> Vector a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> Ref s (Vector a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> m (Ref s (Vector a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Vector a -> m (Ref s (Vector a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Vector a) -> m (Vector a)

Mutable s a => Mutable s (Identity a)

Meant for usage with higher-kinded data pattern (See HKD)

Associated Types

type Ref s (Identity a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Identity a -> m (Ref s (Identity a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Identity a) -> m (Identity a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Identity a) -> Identity a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Identity a) -> Ref s (Identity a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Identity a) -> m (Ref s (Identity a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Identity a -> m (Ref s (Identity a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Identity a) -> m (Identity a)

Mutable s a => Mutable s [a]

Mutable linked list with mutable references in each cell. See MutBranch documentation for an example of using this as a mutable linked list.l

Associated Types

type Ref s [a] = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => [a] -> m (Ref s [a])

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s [a] -> m [a]

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s [a] -> [a] -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s [a] -> Ref s [a] -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s [a] -> m (Ref s [a])

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => [a] -> m (Ref s [a])

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s [a] -> m [a]

Mutable s a => Mutable s (Maybe a)

Associated Types

type Ref s (Maybe a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Maybe a -> m (Ref s (Maybe a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Maybe a) -> m (Maybe a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Maybe a) -> Maybe a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Maybe a) -> Ref s (Maybe a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Maybe a) -> m (Ref s (Maybe a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Maybe a -> m (Ref s (Maybe a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Maybe a) -> m (Maybe a)

Mutable s a => Mutable s (Dual a)

Associated Types

type Ref s (Dual a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Dual a -> m (Ref s (Dual a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Dual a) -> m (Dual a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Dual a) -> Dual a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Dual a) -> Ref s (Dual a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Dual a) -> m (Ref s (Dual a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Dual a -> m (Ref s (Dual a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Dual a) -> m (Dual a)

Mutable s a => Mutable s (Down a)

Associated Types

type Ref s (Down a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Down a -> m (Ref s (Down a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Down a) -> m (Down a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Down a) -> Down a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Down a) -> Ref s (Down a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Down a) -> m (Ref s (Down a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Down a -> m (Ref s (Down a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Down a) -> m (Down a)

Mutable s a => Mutable s (Sum a)

Associated Types

type Ref s (Sum a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Sum a -> m (Ref s (Sum a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Sum a) -> m (Sum a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Sum a) -> Sum a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Sum a) -> Ref s (Sum a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Sum a) -> m (Ref s (Sum a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Sum a -> m (Ref s (Sum a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Sum a) -> m (Sum a)

Mutable s a => Mutable s (Product a)

Associated Types

type Ref s (Product a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Product a -> m (Ref s (Product a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Product a) -> m (Product a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Product a) -> Product a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Product a) -> Ref s (Product a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Product a) -> m (Ref s (Product a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Product a -> m (Ref s (Product a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Product a) -> m (Product a)

Mutable s a => Mutable s (Identity a)

Associated Types

type Ref s (Identity a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Identity a -> m (Ref s (Identity a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Identity a) -> m (Identity a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Identity a) -> Identity a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Identity a) -> Ref s (Identity a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Identity a) -> m (Ref s (Identity a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Identity a -> m (Ref s (Identity a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Identity a) -> m (Identity a)

Mutable s (Complex a)

Associated Types

type Ref s (Complex a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Complex a -> m (Ref s (Complex a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Complex a) -> m (Complex a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Complex a) -> Complex a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Complex a) -> Ref s (Complex a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Complex a) -> m (Ref s (Complex a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Complex a -> m (Ref s (Complex a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Complex a) -> m (Complex a)

Mutable s (Ratio a)

Associated Types

type Ref s (Ratio a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Ratio a -> m (Ref s (Ratio a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Ratio a) -> m (Ratio a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Ratio a) -> Ratio a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Ratio a) -> Ref s (Ratio a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Ratio a) -> m (Ref s (Ratio a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Ratio a -> m (Ref s (Ratio a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Ratio a) -> m (Ratio a)

(Mutable s a, Mutable s (HList as), Ref s (HList as) ~ HListRef s as) => Mutable s (HList (a ': as))

Associated Types

type Ref s (HList (a ': as)) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => HList (a ': as) -> m (Ref s (HList (a ': as)))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (HList (a ': as)) -> m (HList (a ': as))

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (HList (a ': as)) -> HList (a ': as) -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (HList (a ': as)) -> Ref s (HList (a ': as)) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (HList (a ': as)) -> m (Ref s (HList (a ': as)))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => HList (a ': as) -> m (Ref s (HList (a ': as)))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (HList (a ': as)) -> m (HList (a ': as))

Mutable s (HList ('[] :: [Type]))

Associated Types

type Ref s (HList '[]) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => HList '[] -> m (Ref s (HList '[]))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (HList '[]) -> m (HList '[])

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (HList '[]) -> HList '[] -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (HList '[]) -> Ref s (HList '[]) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (HList '[]) -> m (Ref s (HList '[]))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => HList '[] -> m (Ref s (HList '[]))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (HList '[]) -> m (HList '[])

(Mutable s a, Mutable s b) => Mutable s (a, b)

A Ref of a tuple is a tuple of Refs, for easy accessing.

Ref s (Int, Vector Double) = (MutVar s Int, MVector s Double)

Associated Types

type Ref s (a, b) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => (a, b) -> m (Ref s (a, b))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b) -> m (a, b)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b) -> (a, b) -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b) -> Ref s (a, b) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b) -> m (Ref s (a, b))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => (a, b) -> m (Ref s (a, b))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b) -> m (a, b)

(Mutable s a, Mutable s b) => Mutable s (Either a b)

Associated Types

type Ref s (Either a b) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Either a b -> m (Ref s (Either a b))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Either a b) -> m (Either a b)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Either a b) -> Either a b -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Either a b) -> Ref s (Either a b) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Either a b) -> m (Ref s (Either a b))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Either a b -> m (Ref s (Either a b))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Either a b) -> m (Either a b)

Mutable s a => Mutable s (Const a b)

Associated Types

type Ref s (Const a b) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Const a b -> m (Ref s (Const a b))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Const a b) -> m (Const a b)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Const a b) -> Const a b -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Const a b) -> Ref s (Const a b) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Const a b) -> m (Ref s (Const a b))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Const a b -> m (Ref s (Const a b))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Const a b) -> m (Const a b)

Mutable s a => Mutable s (Const a b)

Associated Types

type Ref s (Const a b) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Const a b -> m (Ref s (Const a b))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Const a b) -> m (Const a b)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Const a b) -> Const a b -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Const a b) -> Ref s (Const a b) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Const a b) -> m (Ref s (Const a b))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Const a b -> m (Ref s (Const a b))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Const a b) -> m (Const a b)

(RecApplicative as, NatToInt (RLength as), RPureConstrained (IndexableField as) as, Mutable s (Rec f as), Ref s (Rec f as) ~ Rec (RecRef s f) as) => Mutable s (ARec f as)

Associated Types

type Ref s (ARec f as) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => ARec f as -> m (Ref s (ARec f as))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (ARec f as) -> m (ARec f as)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (ARec f as) -> ARec f as -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (ARec f as) -> Ref s (ARec f as) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (ARec f as) -> m (Ref s (ARec f as))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => ARec f as -> m (Ref s (ARec f as))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (ARec f as) -> m (ARec f as)

(Mutable s (f a2), Mutable s (Rec f as), Ref s (Rec f as) ~ Rec (RecRef s f) as) => Mutable s (Rec f (a2 ': as))

Associated Types

type Ref s (Rec f (a2 ': as)) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Rec f (a2 ': as) -> m (Ref s (Rec f (a2 ': as)))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Rec f (a2 ': as)) -> m (Rec f (a2 ': as))

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Rec f (a2 ': as)) -> Rec f (a2 ': as) -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Rec f (a2 ': as)) -> Ref s (Rec f (a2 ': as)) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Rec f (a2 ': as)) -> m (Ref s (Rec f (a2 ': as)))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Rec f (a2 ': as) -> m (Ref s (Rec f (a2 ': as)))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Rec f (a2 ': as)) -> m (Rec f (a2 ': as))

Mutable s (Rec f ('[] :: [u]))

Associated Types

type Ref s (Rec f '[]) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Rec f '[] -> m (Ref s (Rec f '[]))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Rec f '[]) -> m (Rec f '[])

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Rec f '[]) -> Rec f '[] -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Rec f '[]) -> Ref s (Rec f '[]) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Rec f '[]) -> m (Ref s (Rec f '[]))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Rec f '[] -> m (Ref s (Rec f '[]))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Rec f '[]) -> m (Rec f '[])

(Mutable s a, Mutable s b, Mutable s c) => Mutable s (a, b, c)

Associated Types

type Ref s (a, b, c) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c) -> m (Ref s (a, b, c))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c) -> m (a, b, c)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c) -> (a, b, c) -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c) -> Ref s (a, b, c) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c) -> m (Ref s (a, b, c))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c) -> m (Ref s (a, b, c))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c) -> m (a, b, c)

(Mutable s (f a), Mutable s (g a)) => Mutable s (Sum f g a)

Associated Types

type Ref s (Sum f g a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Sum f g a -> m (Ref s (Sum f g a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Sum f g a) -> m (Sum f g a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Sum f g a) -> Sum f g a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Sum f g a) -> Ref s (Sum f g a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Sum f g a) -> m (Ref s (Sum f g a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Sum f g a -> m (Ref s (Sum f g a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Sum f g a) -> m (Sum f g a)

(Mutable s (f a), Mutable s (g a)) => Mutable s (Product f g a)

Associated Types

type Ref s (Product f g a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Product f g a -> m (Ref s (Product f g a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Product f g a) -> m (Product f g a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Product f g a) -> Product f g a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Product f g a) -> Ref s (Product f g a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Product f g a) -> m (Ref s (Product f g a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Product f g a -> m (Ref s (Product f g a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Product f g a) -> m (Product f g a)

(Mutable s a, Mutable s b, Mutable s c, Mutable s d) => Mutable s (a, b, c, d)

Associated Types

type Ref s (a, b, c, d) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d) -> m (Ref s (a, b, c, d))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d) -> m (a, b, c, d)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d) -> (a, b, c, d) -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d) -> Ref s (a, b, c, d) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d) -> m (Ref s (a, b, c, d))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d) -> m (Ref s (a, b, c, d))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d) -> m (a, b, c, d)

Mutable s (f (g a)) => Mutable s (Compose f g a)

Associated Types

type Ref s (Compose f g a) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => Compose f g a -> m (Ref s (Compose f g a))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Compose f g a) -> m (Compose f g a)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Compose f g a) -> Compose f g a -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Compose f g a) -> Ref s (Compose f g a) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Compose f g a) -> m (Ref s (Compose f g a))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => Compose f g a -> m (Ref s (Compose f g a))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (Compose f g a) -> m (Compose f g a)

(Mutable s a, Mutable s b, Mutable s c, Mutable s d, Mutable s e) => Mutable s (a, b, c, d, e)

Associated Types

type Ref s (a, b, c, d, e) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e) -> m (Ref s (a, b, c, d, e))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e) -> m (a, b, c, d, e)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e) -> (a, b, c, d, e) -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e) -> Ref s (a, b, c, d, e) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e) -> m (Ref s (a, b, c, d, e))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e) -> m (Ref s (a, b, c, d, e))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e) -> m (a, b, c, d, e)

(Mutable s a, Mutable s b, Mutable s c, Mutable s d, Mutable s e, Mutable s f) => Mutable s (a, b, c, d, e, f)

Associated Types

type Ref s (a, b, c, d, e, f) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f) -> m (Ref s (a, b, c, d, e, f))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f) -> m (a, b, c, d, e, f)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f) -> Ref s (a, b, c, d, e, f) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f) -> m (Ref s (a, b, c, d, e, f))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f) -> m (Ref s (a, b, c, d, e, f))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f) -> m (a, b, c, d, e, f)

(Mutable s a, Mutable s b, Mutable s c, Mutable s d, Mutable s e, Mutable s f, Mutable s g) => Mutable s (a, b, c, d, e, f, g)

Associated Types

type Ref s (a, b, c, d, e, f, g) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f, g) -> m (Ref s (a, b, c, d, e, f, g))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g) -> Ref s (a, b, c, d, e, f, g) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g) -> m (Ref s (a, b, c, d, e, f, g))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f, g) -> m (Ref s (a, b, c, d, e, f, g))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g)

(Mutable s a, Mutable s b, Mutable s c, Mutable s d, Mutable s e, Mutable s f, Mutable s g, Mutable s h) => Mutable s (a, b, c, d, e, f, g, h)

Associated Types

type Ref s (a, b, c, d, e, f, g, h) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f, g, h) -> m (Ref s (a, b, c, d, e, f, g, h))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h) -> m (a, b, c, d, e, f, g, h)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h) -> Ref s (a, b, c, d, e, f, g, h) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h) -> m (Ref s (a, b, c, d, e, f, g, h))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f, g, h) -> m (Ref s (a, b, c, d, e, f, g, h))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h) -> m (a, b, c, d, e, f, g, h)

(Mutable s a, Mutable s b, Mutable s c, Mutable s d, Mutable s e, Mutable s f, Mutable s g, Mutable s h, Mutable s i) => Mutable s (a, b, c, d, e, f, g, h, i)

Associated Types

type Ref s (a, b, c, d, e, f, g, h, i) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f, g, h, i) -> m (Ref s (a, b, c, d, e, f, g, h, i))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i) -> m (a, b, c, d, e, f, g, h, i)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i) -> Ref s (a, b, c, d, e, f, g, h, i) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i) -> m (Ref s (a, b, c, d, e, f, g, h, i))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f, g, h, i) -> m (Ref s (a, b, c, d, e, f, g, h, i))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i) -> m (a, b, c, d, e, f, g, h, i)

(Mutable s a, Mutable s b, Mutable s c, Mutable s d, Mutable s e, Mutable s f, Mutable s g, Mutable s h, Mutable s i, Mutable s j) => Mutable s (a, b, c, d, e, f, g, h, i, j)

Associated Types

type Ref s (a, b, c, d, e, f, g, h, i, j) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f, g, h, i, j) -> m (Ref s (a, b, c, d, e, f, g, h, i, j))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j) -> m (a, b, c, d, e, f, g, h, i, j)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j) -> Ref s (a, b, c, d, e, f, g, h, i, j) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j) -> m (Ref s (a, b, c, d, e, f, g, h, i, j))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f, g, h, i, j) -> m (Ref s (a, b, c, d, e, f, g, h, i, j))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j) -> m (a, b, c, d, e, f, g, h, i, j)

(Mutable s a, Mutable s b, Mutable s c, Mutable s d, Mutable s e, Mutable s f, Mutable s g, Mutable s h, Mutable s i, Mutable s j, Mutable s k) => Mutable s (a, b, c, d, e, f, g, h, i, j, k)

Associated Types

type Ref s (a, b, c, d, e, f, g, h, i, j, k) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f, g, h, i, j, k) -> m (Ref s (a, b, c, d, e, f, g, h, i, j, k))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j, k) -> m (a, b, c, d, e, f, g, h, i, j, k)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j, k) -> Ref s (a, b, c, d, e, f, g, h, i, j, k) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j, k) -> m (Ref s (a, b, c, d, e, f, g, h, i, j, k))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f, g, h, i, j, k) -> m (Ref s (a, b, c, d, e, f, g, h, i, j, k))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j, k) -> m (a, b, c, d, e, f, g, h, i, j, k)

(Mutable s a, Mutable s b, Mutable s c, Mutable s d, Mutable s e, Mutable s f, Mutable s g, Mutable s h, Mutable s i, Mutable s j, Mutable s k, Mutable s l) => Mutable s (a, b, c, d, e, f, g, h, i, j, k, l)

Associated Types

type Ref s (a, b, c, d, e, f, g, h, i, j, k, l) = (v :: Type)

Methods

thawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f, g, h, i, j, k, l) -> m (Ref s (a, b, c, d, e, f, g, h, i, j, k, l))

freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j, k, l) -> m (a, b, c, d, e, f, g, h, i, j, k, l)

copyRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> m ()

moveRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j, k, l) -> Ref s (a, b, c, d, e, f, g, h, i, j, k, l) -> m ()

cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j, k, l) -> m (Ref s (a, b, c, d, e, f, g, h, i, j, k, l))

unsafeThawRef :: (PrimMonad m, PrimState m ~ s) => (a, b, c, d, e, f, g, h, i, j, k, l) -> m (Ref s (a, b, c, d, e, f, g, h, i, j, k, l))

unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s (a, b, c, d, e, f, g, h, i, j, k, l) -> m (a, b, c, d, e, f, g, h, i, j, k, l)