{-# LANGUAGE DefaultSignatures      #-}
{-# LANGUAGE EmptyCase              #-}
{-# LANGUAGE FlexibleContexts       #-}
{-# LANGUAGE FlexibleInstances      #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE GADTs                  #-}
{-# LANGUAGE LambdaCase             #-}
{-# LANGUAGE MultiParamTypeClasses  #-}
{-# LANGUAGE RankNTypes             #-}
{-# LANGUAGE ScopedTypeVariables    #-}
{-# LANGUAGE StandaloneDeriving     #-}
{-# LANGUAGE TypeFamilyDependencies #-}
{-# LANGUAGE TypeInType             #-}
{-# LANGUAGE TypeOperators          #-}
{-# LANGUAGE UndecidableInstances   #-}

module Data.Mutable.Internal (
    Mutable(..)
  , RefFor(..)
  , DefaultMutable(..)
  -- * Instances
  -- ** Generic
  , GRef(..)
  , gThawRef, gFreezeRef
  , gCopyRef, gMoveRef, gCloneRef
  , gUnsafeThawRef, gUnsafeFreezeRef
  , GMutable (GRef_)
  -- ** Higher-Kinded Data Pattern
  , thawHKD, freezeHKD
  , copyHKD, moveHKD, cloneHKD
  , unsafeThawHKD, unsafeFreezeHKD
  -- ** Coercible
  , CoerceRef(..)
  , thawCoerce, freezeCoerce
  , copyCoerce, moveCoerce, cloneCoerce
  , unsafeThawCoerce, unsafeFreezeCoerce
  -- ** Traversable
  , TraverseRef(..)
  , thawTraverse, freezeTraverse
  , copyTraverse, moveTraverse, cloneTraverse
  , unsafeThawTraverse, unsafeFreezeTraverse
  -- ** Immutable
  , ImmutableRef(..), thawImmutable, freezeImmutable, copyImmutable
  -- ** Instances for Generics combinators themselves
  , GMutableRef(..)
  , MutSumF(..)
  ) where

import           Control.Monad.Primitive
import           Control.Monad.Trans.Class
import           Control.Monad.Trans.State
import           Data.Bifunctor
import           Data.Coerce
import           Data.Foldable
import           Data.Kind
import           Data.List
import           Data.Primitive.MutVar
import           Data.Vinyl.Functor
import           GHC.Generics
import qualified Data.Vinyl.XRec           as X

-- | An instance of @'Mutable' m a@ means that @a@ can be stored
-- a mutable reference in monad @m@.
--
-- The associated type @'Ref' m a@ links any @a@ to the type of its
-- canonical mutable version.
--
-- The /benefit/ of this typeclass, instead of just using
-- 'Data.IORef.IORef' or 'MutVar' or specific mutable versions like
-- 'V.Vector' and 'MV.MVector', is two-fold:
--
-- *   Piecewise-mutable values, so you can write to only one part and not
--     others.  This also allows for cheaper "writes", even if you replace
--     the whole value: you don't need to ever synthesize an entire new
--     value, you can keep each component in a separate variable until you
--     'freezeRef' it out.  This can be especially useful for composite
--     data types containing large structures like 'V.Vector'.
-- *   Generic abstractions (similar to 'Show'), so you can automatically
--     derive instances while preserving piecewise-ness.  For example, the
--     instance
--
--     @
--     instance (Mutable m a, Mutable m b) => Mutable m (a, b)
--     @
--
--     If @a@ and @b@ are piecwise-mutable, then the instance here will
--     appropriately utilize that fact.
--
-- To modify the specific parts of mutable values, it can be useful to use
-- the functions in "Data.Mutable.Parts".
--
-- There are facilities to automatically piecewise mutable versions for
-- user-defined instances of 'Generic'.
--
-- For example, if we have a type like:
--
-- @
-- data TwoVectors = TV
--     { tvInt    :: 'V.Vector' Int
--     , tvDouble :: Vector Double
--     }
--   deriving Generic
--
-- instance Mutable m TwoVectors where
--     type Ref m TwoVectors = 'GRef' m TwoVectors
-- @
--
-- Then now we get:
--
-- @
-- 'thawRef'   :: TwoVectors -> m ('GRef' m TwoVectors)
-- 'freezeRef' :: 'GRef' m TwoVectors -> m TwoVectors
-- @
--
-- And @'GRef' m TwoVectors@ is now a piecewise-mutable reference storing each
-- part in a way that can be modified separately (for example, with tools
-- from "Data.Mutable.Parts").  It does this by internally allocating two
-- 'MV.MVector's.  If the two vectors are large, this can be much more
-- efficient to modify (if you are modifying /several times/) than by just
-- doing alterations on @TwoVector@s.  It is also much better for large
-- vectors if you plan on modifying only a single item in the vector.
--
-- If you are using the "higher-kinded" data pattern, a la
-- <https://reasonablypolymorphic.com/blog/higher-kinded-data/>, then we
-- can also do:
--
-- @
-- data TwoVectors f = TV
--      { tvInt    :: 'X.HKD' f ('V.Vector' Int)
--      , tvDouble :: HKD f (Vector Double)
--      }
--   deriving Generic
--
-- instance Mutable (TwoVectors 'Identity') where
--     type Ref (TwoVectors 'Identity') = TwoVectors ('RefFor' m)
-- @
--
-- And now your mutable ref is literally going to be a product of the
-- components
--
-- @
-- ghci> tvr@(TV is ds) <- thawRef (TV xs ys)
-- ghci> :t tvr
-- TV ('RefFor' IO)
-- ghci> :t is
-- 'MV.MVector' RealWorld Int
-- ghci> :t ds
-- 'MV.MVector' RealWorld Double
-- @
--
-- So 'thawRef' will actually just get you the same record type but with
-- the mutable versions of each field.  If you modify the mutable fields,
-- and then later 'freezeRef' the whole thing, the resulting frozen value
-- will incorporate all of the changes to the individual fields.
--
-- In addition, there are a few more "automatically derived" instances you
-- can get by picking 'Ref':
--
-- @
-- -- Make a mutable version for any newtype wrapper, using the 'Mutable'
-- -- of the underlying type
-- newtype MyType = MT (Vector Double)
--
-- type Ref m MyType = CoerceRef m MyType (Vector Double)
--
-- -- Make a mutable version of any container, where the items are all
-- -- mutable references.
-- data MyContainer a = MC a a a a
--   deriving (Functor, Foldable, Traversable)
--
-- type Ref m (MyContainer a) = TraverseRef m MyContainer a
-- @
--
-- See <https://mutable.jle.im/02-mutable-and-ref.html> for more
-- information on this typeclass and how to define instances
-- automatically, and also
--
-- *  <https://mutable.jle.im/05-mutable-parts.html> for more information
--    on dealing with record types
-- *  <https://mutable.jle.im/06-mutable-branches> for more information
--    on dealing with sum types
class Monad m => Mutable m a where
    -- | Links the type @a@ to the type of its canonical "mutable version".
    --
    -- For example, for 'V.Vector', the mutable version is 'MV.MVector', so
    -- we have
    --
    -- @
    -- type Ref m ('V.Vector' a) = 'MV.MVector' ('PrimState' m) a
    -- @
    --
    -- This means that using 'thawRef' on a 'V.Vector' will give you an
    -- 'MV.MVector', using 'freezeRef' on a 'MV.Vector' will give you
    -- a 'V.Vector', etc.
    --
    -- @
    -- 'thawRef'
    --     :: ('PrimMonad' m, s ~ 'PrimState' m)
    --     => 'V.Vector' a
    --     -> m ('MV.Vector' s a)
    --
    -- 'freezeRef'
    --     :: ('PrimMonad' m, s ~ 'PrimState' m)
    --     => 'MV.Vector' s a
    --     -> m ('V.Vector' a)
    --
    -- 'copyRef'
    --     :: ('PrimMonad' m, s ~ 'PrimState' m)
    --     => 'MV.Vector' s a
    --     -> 'V.Vector' a
    --     -> m ()
    -- @
    --
    -- This associated type must be unique for @a@, so no two types @a@ can
    -- have the same @'Ref' m a@.  This makes type inference a lot more
    -- useful: if you use 'freezeRef' on an 'MV.MVector', for instance, the
    -- return type will be inferred to be 'V.Vector'.
    --
    -- The /default/ instance is just a plain old 'MutVar' containing the
    -- type.  This is a valid instance, but it treats the entire type
    -- "wholesale" --- it is basically using it as a non-mutable type.  You
    -- won't get any of the performance benefits of piecewise mutation from
    -- it, but it is useful as a base case for non-composite types like
    -- 'Int'.
    --
    -- There are some built-in alternative options for user-defined ADTs
    -- with 'Generic' instances:
    --
    -- @
    -- -- Works for all 'Generic' instances, preserves piecewise mutation
    -- -- for products
    -- type Ref m a = 'GRef' m a
    -- @
    --
    -- If you just set up a blank instance, the implementations of
    -- 'thawRef', 'freezeRef', and 'copyRef' will be inferred using
    -- 'DefaultMutable'.
    --
    -- @
    -- data MyType
    --
    -- -- The default setup is OK
    -- instance Mutable m MyType
    --
    -- -- This is equivalent to the above
    -- instance Mutable m MyType
    --     type Ref m MyType = 'MutVar' ('PrimState' m) MyType
    --
    -- -- any 'Generic' instance
    -- data MyType = MyType { mtInt :: Int, mtDouble :: Double }
    --   deriving Generic
    --
    -- instance Mutable m MyType where
    --     type Ref m MyType = 'GRef' m MyType
    -- @
    --
    -- See <https://mutable.jle.im/02-mutable-and-ref.html> for more
    -- information on this type family and how to define instances
    -- automatically.
    type Ref m a = (v :: Type) | v -> a
    type Ref m a = MutVar (PrimState m) a

    -- | "Thaw" a pure/persistent value into its mutable version, which can
    -- be manipulated using 'Data.Mutable.modifyRef' or other methods
    -- specific for that type (like 'MV.read').
    --
    -- Returns the 'Ref' instance, so, for example, for 'V.Vector':
    --
    -- @
    -- 'thawRef'
    --     :: ('PrimMonad' m, s ~ 'PrimState' m)
    --     => 'V.Vector' a
    --     -> m ('MV.Vector' s a)
    -- @
    --
    -- For non-composite (like 'Int'), this is often called the "new var"
    -- function, like 'Data.IORef.newIORef' / 'Data.STRef.newSTRef'
    -- / 'newMutVar' etc.
    thawRef   :: a -> m (Ref m a)

    -- | "Freeze" a mutable value into its pure/persistent version.
    --
    -- Takes a 'Ref' instance, but type inference will be able to infer the
    -- pure value's type because 'Ref' is injective.
    --
    -- For example, for 'V.Vector':
    --
    -- @
    -- 'freezeRef'
    --     :: ('PrimMonad' m, s ~ 'PrimState' m)
    --     => 'MV.Vector' s a
    --     -> m ('V.Vector' a)
    -- @
    --
    -- For non-composite (like 'Int'), this is often called the "read var"
    -- function, like 'Data.IORef.readIORef' / 'Data.STRef.readSTRef'
    -- / 'readMutVar' etc.
    freezeRef :: Ref m a -> m a

    -- | Overwrite a mutable value by provivding a pure/persistent value.
    -- 'copyRef'
    --
    -- Returns the 'Ref' and the value, so, for example, for 'V.Vector':
    --
    -- @
    -- 'copyRef'
    --     :: ('PrimMonad' m, s ~ 'PrimState' m)
    --     => 'MV.Vector' s a
    --     -> 'V.Vector' a
    --     -> m ()
    -- @
    --
    -- Note that if @a@ is a composite type (with an appropriate composite
    -- reference), this will be done "piecewise": it'll write to each
    -- mutable component separately.
    --
    -- For non-composite (like 'Int'), this is often called the "write var"
    -- function, like 'Data.IORef.writeIORef' / 'Data.STRef.writeSTRef'
    -- / 'writeMutVar' etc.
    copyRef
        :: Ref m a      -- ^ destination to overwrite
        -> a            -- ^ value
        -> m ()

    -- | Deep Copy-move a mutable reference on top of another, overwriting the
    -- second one.
    --
    -- For non-composite types, this is the same as a 'thawRef' and
    -- a 'copyRef'.  For composite types this can be more effficient
    -- because the copying is done piecewise, so the intermediate pure value
    -- is never created.
    moveRef
        :: Ref m a      -- ^ destination
        -> Ref m a      -- ^ source
        -> m ()

    -- | Create a deep copy of a mutable reference, allocated to a separate
    -- independent reference.
    --
    -- For non-composite types, this is the same as a 'thawRef' and
    -- a 'freezeRef'.  For composite types this can be more effficient
    -- because the cloning is done piecewise, so the intermediate pure value
    -- is never created.
    cloneRef :: Ref m a -> m (Ref m a)

    -- this is nice but you can't write an instance for 'TraverseRef' on
    -- this, so maybe not.
    -- -- | Initialize a mutable reference with fields being undefined or
    -- -- with undefined values.  This is only useful if you can modify parts
    -- -- of the mutable value (with things like "Data.Mutable.Parts").  If
    -- -- you attempt to 'freezeRef' (or 'modifyRef' etc.) this before setting
    -- -- all of the fields to reasonable values, this is likely to blow up.
    -- initRef :: m (Ref m a)

    -- | A non-copying version of 'thawRef' that can be more efficient for
    -- types where the mutable representation is the same as the immutable
    -- one (like 'V.Vector').
    --
    -- This is safe as long as you never again use the original pure
    -- value, since it can potentially directly mutate it.
    unsafeThawRef   :: a -> m (Ref m a)

    -- | A non-copying version of 'freezeRef' that can be more efficient for
    -- types where the mutable representation is the same as the immutable
    -- one (like 'V.Vector').
    --
    -- This is safe as long as you never again modify the mutable
    -- reference, since it can potentially directly mutate the frozen value
    -- magically.
    unsafeFreezeRef :: Ref m a -> m a

    default thawRef :: DefaultMutable m a (Ref m a) => a -> m (Ref m a)
    thawRef   = a -> m (Ref m a)
forall (m :: * -> *) a r. DefaultMutable m a r => a -> m r
defaultThawRef
    default freezeRef :: DefaultMutable m a (Ref m a) => Ref m a -> m a
    freezeRef = Ref m a -> m a
forall (m :: * -> *) a r. DefaultMutable m a r => r -> m a
defaultFreezeRef
    default copyRef :: DefaultMutable m a (Ref m a) => Ref m a -> a -> m ()
    copyRef   = Ref m a -> a -> m ()
forall (m :: * -> *) a r. DefaultMutable m a r => r -> a -> m ()
defaultCopyRef
    default moveRef :: DefaultMutable m a (Ref m a) => Ref m a -> Ref m a -> m ()
    moveRef   = Ref m a -> Ref m a -> m ()
forall (m :: * -> *) a r. DefaultMutable m a r => r -> r -> m ()
defaultMoveRef
    default cloneRef :: DefaultMutable m a (Ref m a) => Ref m a -> m (Ref m a)
    cloneRef  = Ref m a -> m (Ref m a)
forall (m :: * -> *) a r. DefaultMutable m a r => r -> m r
defaultCloneRef
    default unsafeThawRef :: DefaultMutable m a (Ref m a) => a -> m (Ref m a)
    unsafeThawRef   = a -> m (Ref m a)
forall (m :: * -> *) a r. DefaultMutable m a r => a -> m r
defaultUnsafeThawRef
    default unsafeFreezeRef :: DefaultMutable m a (Ref m a) => Ref m a -> m a
    unsafeFreezeRef = Ref m a -> m a
forall (m :: * -> *) a r. DefaultMutable m a r => r -> m a
defaultUnsafeFreezeRef

-- | The default implementations of 'thawRef', 'freezeRef', and 'copyRef'
-- dispatched for different choices of 'Ref'.
--
-- Basically, by specifying 'Ref', you get the rest of the instance for
-- free.
--
-- We have the default case:
--
-- @
-- -- default, if you don't specify 'Ref'
-- instance Mutable m MyType
--
-- -- the above is the same as:
-- instance Mutable m MyType
--     type Ref m MyType = MutVar (PrimState m) MyType
-- @
--
-- The case for any instance of 'Generic':
--
-- @
-- instance Mutable m MyType
--     type Ref m MyType = GRef m MyType
-- @
--
-- The case for the "higher-kinded data" pattern a la
-- <https://reasonablypolymorphic.com/blog/higher-kinded-data/>:
--
-- @
-- instance Mutable m (MyTypeF Identity)
--     type Ref m (MyTypeF Identity) = MyTypeF (RefFor m)
-- @
--
-- The case for any newtype wrapper:
--
-- @
-- newtype MyType = MT (Vector Double)
--
-- instance Mutable m MyType where
--     type Ref m MyType = CoerceRef m MyType (Vector Double)
-- @
--
-- And the case for any 'Traversable instance, where the items will all be
-- mutable references:
--
-- @
-- data MyContainer a = MC a a a a
--   deriving (Functor, Foldable, Traversable)
--
-- instance Mutable m a => Mutable m (MyContainer a) where
--     type Ref m (MyContainer a) = TraverseRef m MyContainer a
-- @
--
class DefaultMutable m a r | r -> a where
    defaultThawRef         :: a -> m r
    defaultFreezeRef       :: r -> m a
    defaultCopyRef         :: r -> a -> m ()
    defaultMoveRef         :: r -> r -> m ()
    defaultCloneRef        :: r -> m r
    defaultUnsafeThawRef   :: a -> m r
    defaultUnsafeFreezeRef :: r -> m a

instance (PrimMonad m, s ~ PrimState m) => DefaultMutable m a (MutVar s a) where
    defaultThawRef :: a -> m (MutVar s a)
defaultThawRef         = a -> m (MutVar s a)
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar
    defaultFreezeRef :: MutVar s a -> m a
defaultFreezeRef       = MutVar s a -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar
    defaultCopyRef :: MutVar s a -> a -> m ()
defaultCopyRef         = MutVar s a -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar
    defaultMoveRef :: MutVar s a -> MutVar s a -> m ()
defaultMoveRef v :: MutVar s a
v u :: MutVar s a
u     = MutVar (PrimState m) a -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar MutVar s a
MutVar (PrimState m) a
v (a -> m ()) -> m a -> m ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< MutVar (PrimState m) a -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar MutVar s a
MutVar (PrimState m) a
u
    defaultCloneRef :: MutVar s a -> m (MutVar s a)
defaultCloneRef v :: MutVar s a
v      = a -> m (MutVar s a)
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar (a -> m (MutVar s a)) -> m a -> m (MutVar s a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< MutVar (PrimState m) a -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar MutVar s a
MutVar (PrimState m) a
v
    defaultUnsafeThawRef :: a -> m (MutVar s a)
defaultUnsafeThawRef   = a -> m (MutVar s a)
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar
    defaultUnsafeFreezeRef :: MutVar s a -> m a
defaultUnsafeFreezeRef = MutVar s a -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar

instance (Generic a, GMutable m (Rep a)) => DefaultMutable m a (GRef m a) where
    defaultThawRef :: a -> m (GRef m a)
defaultThawRef         = a -> m (GRef m a)
forall a (m :: * -> *).
(Generic a, GMutable m (Rep a)) =>
a -> m (GRef m a)
gThawRef
    defaultFreezeRef :: GRef m a -> m a
defaultFreezeRef       = GRef m a -> m a
forall a (m :: * -> *).
(Generic a, GMutable m (Rep a)) =>
GRef m a -> m a
gFreezeRef
    defaultCopyRef :: GRef m a -> a -> m ()
defaultCopyRef         = GRef m a -> a -> m ()
forall a (m :: * -> *).
(Generic a, GMutable m (Rep a)) =>
GRef m a -> a -> m ()
gCopyRef
    defaultMoveRef :: GRef m a -> GRef m a -> m ()
defaultMoveRef         = GRef m a -> GRef m a -> m ()
forall (m :: * -> *) a.
GMutable m (Rep a) =>
GRef m a -> GRef m a -> m ()
gMoveRef
    defaultCloneRef :: GRef m a -> m (GRef m a)
defaultCloneRef        = GRef m a -> m (GRef m a)
forall (m :: * -> *) a.
GMutable m (Rep a) =>
GRef m a -> m (GRef m a)
gCloneRef
    defaultUnsafeThawRef :: a -> m (GRef m a)
defaultUnsafeThawRef   = a -> m (GRef m a)
forall a (m :: * -> *).
(Generic a, GMutable m (Rep a)) =>
a -> m (GRef m a)
gUnsafeThawRef
    defaultUnsafeFreezeRef :: GRef m a -> m a
defaultUnsafeFreezeRef = GRef m a -> m a
forall a (m :: * -> *).
(Generic a, GMutable m (Rep a)) =>
GRef m a -> m a
gUnsafeFreezeRef

instance (Generic (z Identity), Generic (z (RefFor m)), GMutable m (Rep (z Identity)), GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m)))
        => DefaultMutable m (z Identity) (z (RefFor m)) where
    defaultThawRef :: z Identity -> m (z (RefFor m))
defaultThawRef         = z Identity -> m (z (RefFor m))
forall (z :: (* -> *) -> *) (m :: * -> *).
(Generic (z Identity), Generic (z (RefFor m)),
 GMutable m (Rep (z Identity)),
 GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))) =>
z Identity -> m (z (RefFor m))
thawHKD
    defaultFreezeRef :: z (RefFor m) -> m (z Identity)
defaultFreezeRef       = z (RefFor m) -> m (z Identity)
forall (z :: (* -> *) -> *) (m :: * -> *).
(Generic (z Identity), Generic (z (RefFor m)),
 GMutable m (Rep (z Identity)),
 GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))) =>
z (RefFor m) -> m (z Identity)
freezeHKD
    defaultCopyRef :: z (RefFor m) -> z Identity -> m ()
defaultCopyRef         = z (RefFor m) -> z Identity -> m ()
forall (z :: (* -> *) -> *) (m :: * -> *).
(Generic (z Identity), Generic (z (RefFor m)),
 GMutable m (Rep (z Identity)),
 GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))) =>
z (RefFor m) -> z Identity -> m ()
copyHKD
    defaultMoveRef :: z (RefFor m) -> z (RefFor m) -> m ()
defaultMoveRef         = z (RefFor m) -> z (RefFor m) -> m ()
forall (z :: (* -> *) -> *) (m :: * -> *).
(Generic (z (RefFor m)), GMutable m (Rep (z Identity)),
 GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))) =>
z (RefFor m) -> z (RefFor m) -> m ()
moveHKD
    defaultCloneRef :: z (RefFor m) -> m (z (RefFor m))
defaultCloneRef        = z (RefFor m) -> m (z (RefFor m))
forall (z :: (* -> *) -> *) (m :: * -> *).
(Generic (z (RefFor m)), GMutable m (Rep (z Identity)),
 GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))) =>
z (RefFor m) -> m (z (RefFor m))
cloneHKD
    defaultUnsafeThawRef :: z Identity -> m (z (RefFor m))
defaultUnsafeThawRef   = z Identity -> m (z (RefFor m))
forall (z :: (* -> *) -> *) (m :: * -> *).
(Generic (z Identity), Generic (z (RefFor m)),
 GMutable m (Rep (z Identity)),
 GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))) =>
z Identity -> m (z (RefFor m))
unsafeThawHKD
    defaultUnsafeFreezeRef :: z (RefFor m) -> m (z Identity)
defaultUnsafeFreezeRef = z (RefFor m) -> m (z Identity)
forall (z :: (* -> *) -> *) (m :: * -> *).
(Generic (z Identity), Generic (z (RefFor m)),
 GMutable m (Rep (z Identity)),
 GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))) =>
z (RefFor m) -> m (z Identity)
unsafeFreezeHKD

instance (Traversable f, Mutable m a) => DefaultMutable m (f a) (TraverseRef m f a) where
    defaultThawRef :: f a -> m (TraverseRef m f a)
defaultThawRef         = f a -> m (TraverseRef m f a)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Mutable m a) =>
f a -> m (TraverseRef m f a)
thawTraverse
    defaultFreezeRef :: TraverseRef m f a -> m (f a)
defaultFreezeRef       = TraverseRef m f a -> m (f a)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Mutable m a) =>
TraverseRef m f a -> m (f a)
freezeTraverse
    defaultCopyRef :: TraverseRef m f a -> f a -> m ()
defaultCopyRef         = TraverseRef m f a -> f a -> m ()
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Mutable m a) =>
TraverseRef m f a -> f a -> m ()
copyTraverse
    defaultMoveRef :: TraverseRef m f a -> TraverseRef m f a -> m ()
defaultMoveRef         = TraverseRef m f a -> TraverseRef m f a -> m ()
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Mutable m a) =>
TraverseRef m f a -> TraverseRef m f a -> m ()
moveTraverse
    defaultCloneRef :: TraverseRef m f a -> m (TraverseRef m f a)
defaultCloneRef        = TraverseRef m f a -> m (TraverseRef m f a)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Mutable m a) =>
TraverseRef m f a -> m (TraverseRef m f a)
cloneTraverse
    defaultUnsafeThawRef :: f a -> m (TraverseRef m f a)
defaultUnsafeThawRef   = f a -> m (TraverseRef m f a)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Mutable m a) =>
f a -> m (TraverseRef m f a)
unsafeThawTraverse
    defaultUnsafeFreezeRef :: TraverseRef m f a -> m (f a)
defaultUnsafeFreezeRef = TraverseRef m f a -> m (f a)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Mutable m a) =>
TraverseRef m f a -> m (f a)
unsafeFreezeTraverse

instance (Coercible s a, Mutable m a) => DefaultMutable m s (CoerceRef m s a) where
    defaultThawRef :: s -> m (CoerceRef m s a)
defaultThawRef         = s -> m (CoerceRef m s a)
forall s a (m :: * -> *).
(Coercible s a, Mutable m a) =>
s -> m (CoerceRef m s a)
thawCoerce
    defaultFreezeRef :: CoerceRef m s a -> m s
defaultFreezeRef       = CoerceRef m s a -> m s
forall s a (m :: * -> *).
(Coercible s a, Mutable m a) =>
CoerceRef m s a -> m s
freezeCoerce
    defaultCopyRef :: CoerceRef m s a -> s -> m ()
defaultCopyRef         = CoerceRef m s a -> s -> m ()
forall s a (m :: * -> *).
(Coercible s a, Mutable m a) =>
CoerceRef m s a -> s -> m ()
copyCoerce
    defaultMoveRef :: CoerceRef m s a -> CoerceRef m s a -> m ()
defaultMoveRef         = CoerceRef m s a -> CoerceRef m s a -> m ()
forall k (m :: * -> *) a (s :: k).
Mutable m a =>
CoerceRef m s a -> CoerceRef m s a -> m ()
moveCoerce
    defaultCloneRef :: CoerceRef m s a -> m (CoerceRef m s a)
defaultCloneRef        = CoerceRef m s a -> m (CoerceRef m s a)
forall k (m :: * -> *) a (s :: k).
Mutable m a =>
CoerceRef m s a -> m (CoerceRef m s a)
cloneCoerce
    defaultUnsafeThawRef :: s -> m (CoerceRef m s a)
defaultUnsafeThawRef   = s -> m (CoerceRef m s a)
forall s a (m :: * -> *).
(Coercible s a, Mutable m a) =>
s -> m (CoerceRef m s a)
unsafeThawCoerce
    defaultUnsafeFreezeRef :: CoerceRef m s a -> m s
defaultUnsafeFreezeRef = CoerceRef m s a -> m s
forall s a (m :: * -> *).
(Coercible s a, Mutable m a) =>
CoerceRef m s a -> m s
unsafeFreezeCoerce

instance Applicative m => DefaultMutable m a (ImmutableRef a) where
    defaultThawRef :: a -> m (ImmutableRef a)
defaultThawRef         = a -> m (ImmutableRef a)
forall (m :: * -> *) a. Applicative m => a -> m (ImmutableRef a)
thawImmutable
    defaultFreezeRef :: ImmutableRef a -> m a
defaultFreezeRef       = ImmutableRef a -> m a
forall (m :: * -> *) a. Applicative m => ImmutableRef a -> m a
freezeImmutable
    defaultCopyRef :: ImmutableRef a -> a -> m ()
defaultCopyRef         = ImmutableRef a -> a -> m ()
forall (m :: * -> *) a.
Applicative m =>
ImmutableRef a -> a -> m ()
copyImmutable
    defaultMoveRef :: ImmutableRef a -> ImmutableRef a -> m ()
defaultMoveRef         = ImmutableRef a -> ImmutableRef a -> m ()
forall (m :: * -> *) a.
Applicative m =>
ImmutableRef a -> ImmutableRef a -> m ()
moveImmutable
    defaultCloneRef :: ImmutableRef a -> m (ImmutableRef a)
defaultCloneRef        = ImmutableRef a -> m (ImmutableRef a)
forall (m :: * -> *) a.
Applicative m =>
ImmutableRef a -> m (ImmutableRef a)
cloneImmutable
    defaultUnsafeThawRef :: a -> m (ImmutableRef a)
defaultUnsafeThawRef   = a -> m (ImmutableRef a)
forall (m :: * -> *) a. Applicative m => a -> m (ImmutableRef a)
thawImmutable
    defaultUnsafeFreezeRef :: ImmutableRef a -> m a
defaultUnsafeFreezeRef = ImmutableRef a -> m a
forall (m :: * -> *) a. Applicative m => ImmutableRef a -> m a
freezeImmutable

-- | A handy newtype wrapper that allows you to partially apply 'Ref'.
-- @'RefFor' m a@ is the same as @'Ref' m a@, but can be partially applied.
--
-- If used with 'X.HKD', you can treat this syntactically identically as
-- a @'Ref' m a@.
newtype RefFor m a = RefFor { RefFor m a -> Ref m a
getRefFor :: Ref m a }

deriving instance Eq (Ref m a) => Eq (RefFor m a)
deriving instance Ord (Ref m a) => Ord (RefFor m a)

-- | Use a @'RefFor' m a@ as if it were a @'Ref' m a@.
instance X.IsoHKD (RefFor m) a where
    type HKD (RefFor m) a = Ref m a
    unHKD :: HKD (RefFor m) a -> RefFor m a
unHKD = HKD (RefFor m) a -> RefFor m a
forall (m :: * -> *) a. Ref m a -> RefFor m a
RefFor
    toHKD :: RefFor m a -> HKD (RefFor m) a
toHKD = RefFor m a -> HKD (RefFor m) a
forall (m :: * -> *) a. RefFor m a -> Ref m a
getRefFor

-- | 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]
-- @
--
newtype TraverseRef m f a = TraverseRef { TraverseRef m f a -> f (Ref m a)
getTraverseRef :: f (Ref m a) }

-- | Use a @'TraverseRef' m f a@ as if it were a @f ('Ref' m a)@
instance X.IsoHKD (TraverseRef m f) a where
    type HKD (TraverseRef m f) a = f (Ref m a)
    unHKD :: HKD (TraverseRef m f) a -> TraverseRef m f a
unHKD = HKD (TraverseRef m f) a -> TraverseRef m f a
forall (m :: * -> *) (f :: * -> *) a.
f (Ref m a) -> TraverseRef m f a
TraverseRef
    toHKD :: TraverseRef m f a -> HKD (TraverseRef m f) a
toHKD = TraverseRef m f a -> HKD (TraverseRef m f) a
forall (m :: * -> *) (f :: * -> *) a.
TraverseRef m f a -> f (Ref m a)
getTraverseRef

-- | 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.
thawTraverse :: (Traversable f, Mutable m a) => f a -> m (TraverseRef m f a)
thawTraverse :: f a -> m (TraverseRef m f a)
thawTraverse = (f (Ref m a) -> TraverseRef m f a)
-> m (f (Ref m a)) -> m (TraverseRef m f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f (Ref m a) -> TraverseRef m f a
forall (m :: * -> *) (f :: * -> *) a.
f (Ref m a) -> TraverseRef m f a
TraverseRef (m (f (Ref m a)) -> m (TraverseRef m f a))
-> (f a -> m (f (Ref m a))) -> f a -> m (TraverseRef m f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> m (Ref m a)) -> f a -> m (f (Ref m a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse a -> m (Ref m a)
forall (m :: * -> *) a. Mutable m a => a -> m (Ref m a)
thawRef

-- | 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.
freezeTraverse :: (Traversable f, Mutable m a) => TraverseRef m f a -> m (f a)
freezeTraverse :: TraverseRef m f a -> m (f a)
freezeTraverse = (Ref m a -> m a) -> f (Ref m a) -> m (f a)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Ref m a -> m a
forall (m :: * -> *) a. Mutable m a => Ref m a -> m a
freezeRef (f (Ref m a) -> m (f a))
-> (TraverseRef m f a -> f (Ref m a))
-> TraverseRef m f a
-> m (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TraverseRef m f a -> f (Ref m a)
forall (m :: * -> *) (f :: * -> *) a.
TraverseRef m f a -> f (Ref m a)
getTraverseRef

-- | 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.
copyTraverse :: (Traversable f, Mutable m a) => TraverseRef m f a -> f a -> m ()
copyTraverse :: TraverseRef m f a -> f a -> m ()
copyTraverse (TraverseRef rs :: f (Ref m a)
rs) xs :: f a
xs = StateT [a] m () -> [a] -> m ()
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT ((Ref m a -> StateT [a] m ()) -> f (Ref m a) -> StateT [a] m ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ Ref m a -> StateT [a] m ()
forall (m :: * -> *) a. Mutable m a => Ref m a -> StateT [a] m ()
go f (Ref m a)
rs) (f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList f a
xs)
  where
    go :: Ref m a -> StateT [a] m ()
go r :: Ref m a
r = do
      Maybe a
x <- ([a] -> (Maybe a, [a])) -> StateT [a] m (Maybe a)
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
state (([a] -> (Maybe a, [a])) -> StateT [a] m (Maybe a))
-> ([a] -> (Maybe a, [a])) -> StateT [a] m (Maybe a)
forall a b. (a -> b) -> a -> b
$ (Maybe a, [a])
-> ((a, [a]) -> (Maybe a, [a])) -> Maybe (a, [a]) -> (Maybe a, [a])
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe a
forall a. Maybe a
Nothing, []) ((a -> Maybe a) -> (a, [a]) -> (Maybe a, [a])
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> Maybe a
forall a. a -> Maybe a
Just) (Maybe (a, [a]) -> (Maybe a, [a]))
-> ([a] -> Maybe (a, [a])) -> [a] -> (Maybe a, [a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Maybe (a, [a])
forall a. [a] -> Maybe (a, [a])
uncons
      m () -> StateT [a] m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> StateT [a] m ()) -> m () -> StateT [a] m ()
forall a b. (a -> b) -> a -> b
$ (a -> m ()) -> Maybe a -> m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (Ref m a -> a -> m ()
forall (m :: * -> *) a. Mutable m a => Ref m a -> a -> m ()
copyRef Ref m a
r) Maybe a
x

-- | 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.
moveTraverse
    :: (Traversable f, Mutable m a)
    => TraverseRef m f a        -- ^ destination
    -> TraverseRef m f a        -- ^ source
    -> m ()
moveTraverse :: TraverseRef m f a -> TraverseRef m f a -> m ()
moveTraverse (TraverseRef rs :: f (Ref m a)
rs) (TraverseRef vs :: f (Ref m a)
vs) = StateT [Ref m a] m () -> [Ref m a] -> m ()
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT ((Ref m a -> StateT [Ref m a] m ())
-> f (Ref m a) -> StateT [Ref m a] m ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ Ref m a -> StateT [Ref m a] m ()
forall (m :: * -> *) a.
Mutable m a =>
Ref m a -> StateT [Ref m a] m ()
go f (Ref m a)
rs) (f (Ref m a) -> [Ref m a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList f (Ref m a)
vs)
  where
    go :: Ref m a -> StateT [Ref m a] m ()
go r :: Ref m a
r = do
      Maybe (Ref m a)
x <- ([Ref m a] -> (Maybe (Ref m a), [Ref m a]))
-> StateT [Ref m a] m (Maybe (Ref m a))
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
state (([Ref m a] -> (Maybe (Ref m a), [Ref m a]))
 -> StateT [Ref m a] m (Maybe (Ref m a)))
-> ([Ref m a] -> (Maybe (Ref m a), [Ref m a]))
-> StateT [Ref m a] m (Maybe (Ref m a))
forall a b. (a -> b) -> a -> b
$ (Maybe (Ref m a), [Ref m a])
-> ((Ref m a, [Ref m a]) -> (Maybe (Ref m a), [Ref m a]))
-> Maybe (Ref m a, [Ref m a])
-> (Maybe (Ref m a), [Ref m a])
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe (Ref m a)
forall a. Maybe a
Nothing, []) ((Ref m a -> Maybe (Ref m a))
-> (Ref m a, [Ref m a]) -> (Maybe (Ref m a), [Ref m a])
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Ref m a -> Maybe (Ref m a)
forall a. a -> Maybe a
Just) (Maybe (Ref m a, [Ref m a]) -> (Maybe (Ref m a), [Ref m a]))
-> ([Ref m a] -> Maybe (Ref m a, [Ref m a]))
-> [Ref m a]
-> (Maybe (Ref m a), [Ref m a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Ref m a] -> Maybe (Ref m a, [Ref m a])
forall a. [a] -> Maybe (a, [a])
uncons
      m () -> StateT [Ref m a] m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> StateT [Ref m a] m ()) -> m () -> StateT [Ref m a] m ()
forall a b. (a -> b) -> a -> b
$ (Ref m a -> m ()) -> Maybe (Ref m a) -> m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (Ref m a -> Ref m a -> m ()
forall (m :: * -> *) a. Mutable m a => Ref m a -> Ref m a -> m ()
moveRef Ref m a
r) Maybe (Ref m a)
x

-- | 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.
cloneTraverse :: (Traversable f, Mutable m a) => TraverseRef m f a -> m (TraverseRef m f a)
cloneTraverse :: TraverseRef m f a -> m (TraverseRef m f a)
cloneTraverse = (f (Ref m a) -> TraverseRef m f a)
-> m (f (Ref m a)) -> m (TraverseRef m f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f (Ref m a) -> TraverseRef m f a
forall (m :: * -> *) (f :: * -> *) a.
f (Ref m a) -> TraverseRef m f a
TraverseRef (m (f (Ref m a)) -> m (TraverseRef m f a))
-> (TraverseRef m f a -> m (f (Ref m a)))
-> TraverseRef m f a
-> m (TraverseRef m f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Ref m a -> m (Ref m a)) -> f (Ref m a) -> m (f (Ref m a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Ref m a -> m (Ref m a)
forall (m :: * -> *) a. Mutable m a => Ref m a -> m (Ref m a)
cloneRef (f (Ref m a) -> m (f (Ref m a)))
-> (TraverseRef m f a -> f (Ref m a))
-> TraverseRef m f a
-> m (f (Ref m a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TraverseRef m f a -> f (Ref m a)
forall (m :: * -> *) (f :: * -> *) a.
TraverseRef m f a -> f (Ref m a)
getTraverseRef

-- | 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.
unsafeThawTraverse :: (Traversable f, Mutable m a) => f a -> m (TraverseRef m f a)
unsafeThawTraverse :: f a -> m (TraverseRef m f a)
unsafeThawTraverse = (f (Ref m a) -> TraverseRef m f a)
-> m (f (Ref m a)) -> m (TraverseRef m f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f (Ref m a) -> TraverseRef m f a
forall (m :: * -> *) (f :: * -> *) a.
f (Ref m a) -> TraverseRef m f a
TraverseRef (m (f (Ref m a)) -> m (TraverseRef m f a))
-> (f a -> m (f (Ref m a))) -> f a -> m (TraverseRef m f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> m (Ref m a)) -> f a -> m (f (Ref m a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse a -> m (Ref m a)
forall (m :: * -> *) a. Mutable m a => a -> m (Ref m a)
unsafeThawRef

-- | 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.
unsafeFreezeTraverse :: (Traversable f, Mutable m a) => TraverseRef m f a -> m (f a)
unsafeFreezeTraverse :: TraverseRef m f a -> m (f a)
unsafeFreezeTraverse = (Ref m a -> m a) -> f (Ref m a) -> m (f a)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Ref m a -> m a
forall (m :: * -> *) a. Mutable m a => Ref m a -> m a
unsafeFreezeRef (f (Ref m a) -> m (f a))
-> (TraverseRef m f a -> f (Ref m a))
-> TraverseRef m f a
-> m (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TraverseRef m f a -> f (Ref m a)
forall (m :: * -> *) (f :: * -> *) a.
TraverseRef m f a -> f (Ref m a)
getTraverseRef

-- | 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 ('V.Vector' Double)
--
-- instance 'Mutable' m MyVec where
--     type 'Ref' m MyVec = 'CoerceRef' m s ('V.Vector' Double)
-- @
--
-- The @Ref m MyVec@ uses the a @'MV.MVector' Double@ under the hood.
--
-- It's essentially a special case of 'GRef' for newtypes.
newtype CoerceRef m s a = CoerceRef { CoerceRef m s a -> Ref m a
getCoerceRef :: Ref m a }

deriving instance Eq (Ref m a) => Eq (CoerceRef m s a)
deriving instance Ord (Ref m a) => Ord (CoerceRef m s a)

-- | Use a @'CoerceRef' m s a@ as if it were a @'Ref' m a@
instance X.IsoHKD (CoerceRef m s) a where
    type HKD (CoerceRef m s) a = Ref m a
    unHKD :: HKD (CoerceRef m s) a -> CoerceRef m s a
unHKD = HKD (CoerceRef m s) a -> CoerceRef m s a
forall k (m :: * -> *) (s :: k) a. Ref m a -> CoerceRef m s a
CoerceRef
    toHKD :: CoerceRef m s a -> HKD (CoerceRef m s) a
toHKD = CoerceRef m s a -> HKD (CoerceRef m s) a
forall (m :: * -> *) k (s :: k) a. CoerceRef m s a -> Ref m a
getCoerceRef

-- | 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' m s a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'CoerceRef' for more information.
thawCoerce :: (Coercible s a, Mutable m a) => s -> m (CoerceRef m s a)
thawCoerce :: s -> m (CoerceRef m s a)
thawCoerce = (Ref m a -> CoerceRef m s a) -> m (Ref m a) -> m (CoerceRef m s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ref m a -> CoerceRef m s a
forall k (m :: * -> *) (s :: k) a. Ref m a -> CoerceRef m s a
CoerceRef (m (Ref m a) -> m (CoerceRef m s a))
-> (s -> m (Ref m a)) -> s -> m (CoerceRef m s a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m (Ref m a)
forall (m :: * -> *) a. Mutable m a => a -> m (Ref m a)
thawRef (a -> m (Ref m a)) -> (s -> a) -> s -> m (Ref m a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> a
forall a b. Coercible a b => a -> b
coerce

-- | 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' m s a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'CoerceRef' for more information.
freezeCoerce :: (Coercible s a, Mutable m a) => CoerceRef m s a -> m s
freezeCoerce :: CoerceRef m s a -> m s
freezeCoerce = (a -> s) -> m a -> m s
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> s
forall a b. Coercible a b => a -> b
coerce (m a -> m s) -> (CoerceRef m s a -> m a) -> CoerceRef m s a -> m s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ref m a -> m a
forall (m :: * -> *) a. Mutable m a => Ref m a -> m a
freezeRef (Ref m a -> m a)
-> (CoerceRef m s a -> Ref m a) -> CoerceRef m s a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CoerceRef m s a -> Ref m a
forall (m :: * -> *) k (s :: k) a. CoerceRef m s a -> Ref m a
getCoerceRef

-- | 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' m s a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'CoerceRef' for more information.
copyCoerce :: (Coercible s a, Mutable m a) => CoerceRef m s a -> s -> m ()
copyCoerce :: CoerceRef m s a -> s -> m ()
copyCoerce (CoerceRef r :: Ref m a
r) = Ref m a -> a -> m ()
forall (m :: * -> *) a. Mutable m a => Ref m a -> a -> m ()
copyRef Ref m a
r (a -> m ()) -> (s -> a) -> s -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> a
forall a b. Coercible a b => a -> b
coerce

-- | 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' m s a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'CoerceRef' for more information.
moveCoerce :: Mutable m a => CoerceRef m s a -> CoerceRef m s a -> m ()
moveCoerce :: CoerceRef m s a -> CoerceRef m s a -> m ()
moveCoerce (CoerceRef r :: Ref m a
r) (CoerceRef s :: Ref m a
s) = Ref m a -> Ref m a -> m ()
forall (m :: * -> *) a. Mutable m a => Ref m a -> Ref m a -> m ()
moveRef Ref m a
r Ref m a
s

-- | 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' m s a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'CoerceRef' for more information.
cloneCoerce :: Mutable m a => CoerceRef m s a -> m (CoerceRef m s a)
cloneCoerce :: CoerceRef m s a -> m (CoerceRef m s a)
cloneCoerce = (Ref m a -> CoerceRef m s a) -> m (Ref m a) -> m (CoerceRef m s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ref m a -> CoerceRef m s a
forall k (m :: * -> *) (s :: k) a. Ref m a -> CoerceRef m s a
CoerceRef (m (Ref m a) -> m (CoerceRef m s a))
-> (CoerceRef m s a -> m (Ref m a))
-> CoerceRef m s a
-> m (CoerceRef m s a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ref m a -> m (Ref m a)
forall (m :: * -> *) a. Mutable m a => Ref m a -> m (Ref m a)
cloneRef (Ref m a -> m (Ref m a))
-> (CoerceRef m s a -> Ref m a) -> CoerceRef m s a -> m (Ref m a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CoerceRef m s a -> Ref m a
forall (m :: * -> *) k (s :: k) a. CoerceRef m s a -> Ref m a
getCoerceRef

-- | 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' m s a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'CoerceRef' for more information.
unsafeThawCoerce :: (Coercible s a, Mutable m a) => s -> m (CoerceRef m s a)
unsafeThawCoerce :: s -> m (CoerceRef m s a)
unsafeThawCoerce = (Ref m a -> CoerceRef m s a) -> m (Ref m a) -> m (CoerceRef m s a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ref m a -> CoerceRef m s a
forall k (m :: * -> *) (s :: k) a. Ref m a -> CoerceRef m s a
CoerceRef (m (Ref m a) -> m (CoerceRef m s a))
-> (s -> m (Ref m a)) -> s -> m (CoerceRef m s a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m (Ref m a)
forall (m :: * -> *) a. Mutable m a => a -> m (Ref m a)
unsafeThawRef (a -> m (Ref m a)) -> (s -> a) -> s -> m (Ref m a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> a
forall a b. Coercible a b => a -> b
coerce

-- | 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' m s a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'CoerceRef' for more information.
unsafeFreezeCoerce :: (Coercible s a, Mutable m a) => CoerceRef m s a -> m s
unsafeFreezeCoerce :: CoerceRef m s a -> m s
unsafeFreezeCoerce = (a -> s) -> m a -> m s
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> s
forall a b. Coercible a b => a -> b
coerce (m a -> m s) -> (CoerceRef m s a -> m a) -> CoerceRef m s a -> m s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ref m a -> m a
forall (m :: * -> *) a. Mutable m a => Ref m a -> m a
unsafeFreezeRef (Ref m a -> m a)
-> (CoerceRef m s a -> Ref m a) -> CoerceRef m s a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CoerceRef m s a -> Ref m a
forall (m :: * -> *) k (s :: k) a. CoerceRef m s a -> Ref m a
getCoerceRef

-- | 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 'Data.Mutable.Class.Immutable'.
newtype ImmutableRef a = ImmutableRef { ImmutableRef a -> a
getImmutableRef :: a }

-- | Use a @'ImmutableRef' a@ as if it were an @a@
instance X.IsoHKD ImmutableRef a where
    type HKD ImmutableRef a = a
    unHKD :: HKD ImmutableRef a -> ImmutableRef a
unHKD = HKD ImmutableRef a -> ImmutableRef a
forall a. a -> ImmutableRef a
ImmutableRef
    toHKD :: ImmutableRef a -> HKD ImmutableRef a
toHKD = ImmutableRef a -> HKD ImmutableRef a
forall a. ImmutableRef a -> a
getImmutableRef

-- | 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' m s a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'ImmutableRef' for more information.
thawImmutable :: Applicative m => a -> m (ImmutableRef a)
thawImmutable :: a -> m (ImmutableRef a)
thawImmutable = ImmutableRef a -> m (ImmutableRef a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ImmutableRef a -> m (ImmutableRef a))
-> (a -> ImmutableRef a) -> a -> m (ImmutableRef a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ImmutableRef a
forall a. a -> ImmutableRef a
ImmutableRef

-- | 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' m s a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'ImmutableRef' for more information.
freezeImmutable :: Applicative m => ImmutableRef a -> m a
freezeImmutable :: ImmutableRef a -> m a
freezeImmutable = a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> m a) -> (ImmutableRef a -> a) -> ImmutableRef a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ImmutableRef a -> a
forall a. ImmutableRef a -> a
getImmutableRef

-- | 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' m s a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'ImmutableRef' for more information.
copyImmutable :: Applicative m => ImmutableRef a -> a -> m ()
copyImmutable :: ImmutableRef a -> a -> m ()
copyImmutable _ _ = () -> m ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

-- | Default 'moveRef' 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' m s a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'ImmutableRef' for more information.
moveImmutable :: Applicative m => ImmutableRef a -> ImmutableRef a -> m ()
moveImmutable :: ImmutableRef a -> ImmutableRef a -> m ()
moveImmutable _ _ = () -> m ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

-- | Default 'cloneRef' for 'ImmutableRef'.  'freezeRef' on this value will
-- 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' m s a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'ImmutableRef' for more information.
cloneImmutable :: Applicative m => ImmutableRef a -> m (ImmutableRef a)
cloneImmutable :: ImmutableRef a -> m (ImmutableRef a)
cloneImmutable = ImmutableRef a -> m (ImmutableRef a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure



-- | Class for automatic generation of 'Ref' for 'Generic' instances.  See
-- 'GRef' for more information.
class Monad m => GMutable m f where
    type GRef_ m f = (u :: k -> Type) | u -> f

    gThawRef_         :: f a -> m (GRef_ m f a)
    gFreezeRef_       :: GRef_ m f a -> m (f a)
    gCopyRef_         :: GRef_ m f a -> f a -> m ()
    gMoveRef_         :: GRef_ m f a -> GRef_ m f a -> m ()
    gCloneRef_        :: GRef_ m f a -> m (GRef_ m f a)
    gUnsafeThawRef_   :: f a -> m (GRef_ m f a)
    gUnsafeFreezeRef_ :: GRef_ m f a -> m (f a)

instance Mutable m c => GMutable m (K1 i c) where
    type GRef_ m (K1 i c) = K1 i (Ref m c)

    gThawRef_ :: K1 i c a -> m (GRef_ m (K1 i c) a)
gThawRef_               = (Ref m c -> K1 i (Ref m c) a)
-> m (Ref m c) -> m (K1 i (Ref m c) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ref m c -> K1 i (Ref m c) a
forall k i c (p :: k). c -> K1 i c p
K1 (m (Ref m c) -> m (K1 i (Ref m c) a))
-> (K1 i c a -> m (Ref m c)) -> K1 i c a -> m (K1 i (Ref m c) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. c -> m (Ref m c)
forall (m :: * -> *) a. Mutable m a => a -> m (Ref m a)
thawRef (c -> m (Ref m c)) -> (K1 i c a -> c) -> K1 i c a -> m (Ref m c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. K1 i c a -> c
forall i c k (p :: k). K1 i c p -> c
unK1
    gFreezeRef_ :: GRef_ m (K1 i c) a -> m (K1 i c a)
gFreezeRef_             = (c -> K1 i c a) -> m c -> m (K1 i c a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap c -> K1 i c a
forall k i c (p :: k). c -> K1 i c p
K1 (m c -> m (K1 i c a))
-> (K1 i (Ref m c) a -> m c) -> K1 i (Ref m c) a -> m (K1 i c a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ref m c -> m c
forall (m :: * -> *) a. Mutable m a => Ref m a -> m a
freezeRef (Ref m c -> m c)
-> (K1 i (Ref m c) a -> Ref m c) -> K1 i (Ref m c) a -> m c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. K1 i (Ref m c) a -> Ref m c
forall i c k (p :: k). K1 i c p -> c
unK1
    gCopyRef_ :: GRef_ m (K1 i c) a -> K1 i c a -> m ()
gCopyRef_ (K1 v) (K1 x :: c
x) = Ref m c -> c -> m ()
forall (m :: * -> *) a. Mutable m a => Ref m a -> a -> m ()
copyRef Ref m c
v c
x
    gMoveRef_ :: GRef_ m (K1 i c) a -> GRef_ m (K1 i c) a -> m ()
gMoveRef_ (K1 v) (K1 u) = Ref m c -> Ref m c -> m ()
forall (m :: * -> *) a. Mutable m a => Ref m a -> Ref m a -> m ()
moveRef Ref m c
v Ref m c
u
    gCloneRef_ :: GRef_ m (K1 i c) a -> m (GRef_ m (K1 i c) a)
gCloneRef_              = (Ref m c -> K1 i (Ref m c) a)
-> m (Ref m c) -> m (K1 i (Ref m c) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ref m c -> K1 i (Ref m c) a
forall k i c (p :: k). c -> K1 i c p
K1 (m (Ref m c) -> m (K1 i (Ref m c) a))
-> (K1 i (Ref m c) a -> m (Ref m c))
-> K1 i (Ref m c) a
-> m (K1 i (Ref m c) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ref m c -> m (Ref m c)
forall (m :: * -> *) a. Mutable m a => Ref m a -> m (Ref m a)
cloneRef (Ref m c -> m (Ref m c))
-> (K1 i (Ref m c) a -> Ref m c) -> K1 i (Ref m c) a -> m (Ref m c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. K1 i (Ref m c) a -> Ref m c
forall i c k (p :: k). K1 i c p -> c
unK1
    gUnsafeThawRef_ :: K1 i c a -> m (GRef_ m (K1 i c) a)
gUnsafeThawRef_         = (Ref m c -> K1 i (Ref m c) a)
-> m (Ref m c) -> m (K1 i (Ref m c) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ref m c -> K1 i (Ref m c) a
forall k i c (p :: k). c -> K1 i c p
K1 (m (Ref m c) -> m (K1 i (Ref m c) a))
-> (K1 i c a -> m (Ref m c)) -> K1 i c a -> m (K1 i (Ref m c) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. c -> m (Ref m c)
forall (m :: * -> *) a. Mutable m a => a -> m (Ref m a)
unsafeThawRef (c -> m (Ref m c)) -> (K1 i c a -> c) -> K1 i c a -> m (Ref m c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. K1 i c a -> c
forall i c k (p :: k). K1 i c p -> c
unK1
    gUnsafeFreezeRef_ :: GRef_ m (K1 i c) a -> m (K1 i c a)
gUnsafeFreezeRef_       = (c -> K1 i c a) -> m c -> m (K1 i c a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap c -> K1 i c a
forall k i c (p :: k). c -> K1 i c p
K1 (m c -> m (K1 i c a))
-> (K1 i (Ref m c) a -> m c) -> K1 i (Ref m c) a -> m (K1 i c a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ref m c -> m c
forall (m :: * -> *) a. Mutable m a => Ref m a -> m a
unsafeFreezeRef (Ref m c -> m c)
-> (K1 i (Ref m c) a -> Ref m c) -> K1 i (Ref m c) a -> m c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. K1 i (Ref m c) a -> Ref m c
forall i c k (p :: k). K1 i c p -> c
unK1

instance Monad m => GMutable m U1 where
    type GRef_ m U1 = U1

    gThawRef_ :: U1 a -> m (GRef_ m U1 a)
gThawRef_   _       = U1 a -> m (U1 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure U1 a
forall k (p :: k). U1 p
U1
    gFreezeRef_ :: GRef_ m U1 a -> m (U1 a)
gFreezeRef_ _       = U1 a -> m (U1 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure U1 a
forall k (p :: k). U1 p
U1
    gCopyRef_ :: GRef_ m U1 a -> U1 a -> m ()
gCopyRef_ _ _       = () -> m ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    gMoveRef_ :: GRef_ m U1 a -> GRef_ m U1 a -> m ()
gMoveRef_ _ _       = () -> m ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    gCloneRef_ :: GRef_ m U1 a -> m (GRef_ m U1 a)
gCloneRef_  _       = U1 a -> m (U1 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure U1 a
forall k (p :: k). U1 p
U1
    gUnsafeThawRef_ :: U1 a -> m (GRef_ m U1 a)
gUnsafeThawRef_   _ = U1 a -> m (U1 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure U1 a
forall k (p :: k). U1 p
U1
    gUnsafeFreezeRef_ :: GRef_ m U1 a -> m (U1 a)
gUnsafeFreezeRef_ _ = U1 a -> m (U1 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure U1 a
forall k (p :: k). U1 p
U1

instance Monad m => GMutable m V1 where
    type GRef_ m V1 = V1

    gThawRef_ :: V1 a -> m (GRef_ m V1 a)
gThawRef_         = \case {}
    gFreezeRef_ :: GRef_ m V1 a -> m (V1 a)
gFreezeRef_       = \case {}
    gCopyRef_ :: GRef_ m V1 a -> V1 a -> m ()
gCopyRef_         = \case {}
    gMoveRef_ :: GRef_ m V1 a -> GRef_ m V1 a -> m ()
gMoveRef_         = \case {}
    gCloneRef_ :: GRef_ m V1 a -> m (GRef_ m V1 a)
gCloneRef_        = \case {}
    gUnsafeThawRef_ :: V1 a -> m (GRef_ m V1 a)
gUnsafeThawRef_   = \case {}
    gUnsafeFreezeRef_ :: GRef_ m V1 a -> m (V1 a)
gUnsafeFreezeRef_ = \case {}

instance (GMutable m f, GMutable m g) => GMutable m (f :*: g) where
    type GRef_ m (f :*: g) = GRef_ m f :*: GRef_ m g

    gThawRef_ :: (:*:) f g a -> m (GRef_ m (f :*: g) a)
gThawRef_ (x :: f a
x :*: y :: g a
y)             = GRef_ m f a -> GRef_ m g a -> (:*:) (GRef_ m f) (GRef_ m g) a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) (GRef_ m f a -> GRef_ m g a -> (:*:) (GRef_ m f) (GRef_ m g) a)
-> m (GRef_ m f a)
-> m (GRef_ m g a -> (:*:) (GRef_ m f) (GRef_ m g) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gThawRef_ f a
x m (GRef_ m g a -> (:*:) (GRef_ m f) (GRef_ m g) a)
-> m (GRef_ m g a) -> m ((:*:) (GRef_ m f) (GRef_ m g) a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> g a -> m (GRef_ m g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gThawRef_ g a
y
    gFreezeRef_ :: GRef_ m (f :*: g) a -> m ((:*:) f g a)
gFreezeRef_ (v :*: u)           = f a -> g a -> (:*:) f g a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) (f a -> g a -> (:*:) f g a) -> m (f a) -> m (g a -> (:*:) f g a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GRef_ m f a -> m (f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gFreezeRef_ GRef_ m f a
v m (g a -> (:*:) f g a) -> m (g a) -> m ((:*:) f g a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GRef_ m g a -> m (g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gFreezeRef_ GRef_ m g a
u
    gCopyRef_ :: GRef_ m (f :*: g) a -> (:*:) f g a -> m ()
gCopyRef_ (v :*: u) (x :: f a
x :*: y :: g a
y)   = GRef_ m f a -> f a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> f a -> m ()
gCopyRef_ GRef_ m f a
v f a
x m () -> m () -> m ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> GRef_ m g a -> g a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> f a -> m ()
gCopyRef_ GRef_ m g a
u g a
y
    gMoveRef_ :: GRef_ m (f :*: g) a -> GRef_ m (f :*: g) a -> m ()
gMoveRef_ (v :*: u) (v' :*: u') = GRef_ m f a -> GRef_ m f a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> GRef_ m f a -> m ()
gMoveRef_ GRef_ m f a
v GRef_ m f a
v' m () -> m () -> m ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> GRef_ m g a -> GRef_ m g a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> GRef_ m f a -> m ()
gMoveRef_ GRef_ m g a
u GRef_ m g a
u'
    gCloneRef_ :: GRef_ m (f :*: g) a -> m (GRef_ m (f :*: g) a)
gCloneRef_ (v :*: u)            = GRef_ m f a -> GRef_ m g a -> (:*:) (GRef_ m f) (GRef_ m g) a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) (GRef_ m f a -> GRef_ m g a -> (:*:) (GRef_ m f) (GRef_ m g) a)
-> m (GRef_ m f a)
-> m (GRef_ m g a -> (:*:) (GRef_ m f) (GRef_ m g) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GRef_ m f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (GRef_ m f a)
gCloneRef_ GRef_ m f a
v m (GRef_ m g a -> (:*:) (GRef_ m f) (GRef_ m g) a)
-> m (GRef_ m g a) -> m ((:*:) (GRef_ m f) (GRef_ m g) a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GRef_ m g a -> m (GRef_ m g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (GRef_ m f a)
gCloneRef_ GRef_ m g a
u
    gUnsafeThawRef_ :: (:*:) f g a -> m (GRef_ m (f :*: g) a)
gUnsafeThawRef_ (x :: f a
x :*: y :: g a
y)       = GRef_ m f a -> GRef_ m g a -> (:*:) (GRef_ m f) (GRef_ m g) a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) (GRef_ m f a -> GRef_ m g a -> (:*:) (GRef_ m f) (GRef_ m g) a)
-> m (GRef_ m f a)
-> m (GRef_ m g a -> (:*:) (GRef_ m f) (GRef_ m g) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gUnsafeThawRef_ f a
x m (GRef_ m g a -> (:*:) (GRef_ m f) (GRef_ m g) a)
-> m (GRef_ m g a) -> m ((:*:) (GRef_ m f) (GRef_ m g) a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> g a -> m (GRef_ m g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gUnsafeThawRef_ g a
y
    gUnsafeFreezeRef_ :: GRef_ m (f :*: g) a -> m ((:*:) f g a)
gUnsafeFreezeRef_ (v :*: u)     = f a -> g a -> (:*:) f g a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) (f a -> g a -> (:*:) f g a) -> m (f a) -> m (g a -> (:*:) f g a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GRef_ m f a -> m (f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gUnsafeFreezeRef_ GRef_ m f a
v m (g a -> (:*:) f g a) -> m (g a) -> m ((:*:) f g a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GRef_ m g a -> m (g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gUnsafeFreezeRef_ GRef_ m g a
u

instance GMutable m f => GMutable m (M1 i c f) where
    type GRef_ m (M1 i c f) = M1 i c (GRef_ m f)

    gThawRef_ :: M1 i c f a -> m (GRef_ m (M1 i c f) a)
gThawRef_               = (GRef_ m f a -> M1 i c (GRef_ m f) a)
-> m (GRef_ m f a) -> m (M1 i c (GRef_ m f) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GRef_ m f a -> M1 i c (GRef_ m f) a
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (m (GRef_ m f a) -> m (M1 i c (GRef_ m f) a))
-> (M1 i c f a -> m (GRef_ m f a))
-> M1 i c f a
-> m (M1 i c (GRef_ m f) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gThawRef_ (f a -> m (GRef_ m f a))
-> (M1 i c f a -> f a) -> M1 i c f a -> m (GRef_ m f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. M1 i c f a -> f a
forall i (c :: Meta) k (f :: k -> *) (p :: k). M1 i c f p -> f p
unM1
    gFreezeRef_ :: GRef_ m (M1 i c f) a -> m (M1 i c f a)
gFreezeRef_             = (f a -> M1 i c f a) -> m (f a) -> m (M1 i c f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f a -> M1 i c f a
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (m (f a) -> m (M1 i c f a))
-> (M1 i c (GRef_ m f) a -> m (f a))
-> M1 i c (GRef_ m f) a
-> m (M1 i c f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m f a -> m (f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gFreezeRef_ (GRef_ m f a -> m (f a))
-> (M1 i c (GRef_ m f) a -> GRef_ m f a)
-> M1 i c (GRef_ m f) a
-> m (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. M1 i c (GRef_ m f) a -> GRef_ m f a
forall i (c :: Meta) k (f :: k -> *) (p :: k). M1 i c f p -> f p
unM1
    gCopyRef_ :: GRef_ m (M1 i c f) a -> M1 i c f a -> m ()
gCopyRef_ (M1 v) (M1 x :: f a
x) = GRef_ m f a -> f a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> f a -> m ()
gCopyRef_ GRef_ m f a
v f a
x
    gMoveRef_ :: GRef_ m (M1 i c f) a -> GRef_ m (M1 i c f) a -> m ()
gMoveRef_ (M1 v) (M1 u) = GRef_ m f a -> GRef_ m f a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> GRef_ m f a -> m ()
gMoveRef_ GRef_ m f a
v GRef_ m f a
u
    gCloneRef_ :: GRef_ m (M1 i c f) a -> m (GRef_ m (M1 i c f) a)
gCloneRef_ (M1 v)       = GRef_ m f a -> M1 i c (GRef_ m f) a
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (GRef_ m f a -> M1 i c (GRef_ m f) a)
-> m (GRef_ m f a) -> m (M1 i c (GRef_ m f) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GRef_ m f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (GRef_ m f a)
gCloneRef_ GRef_ m f a
v
    gUnsafeThawRef_ :: M1 i c f a -> m (GRef_ m (M1 i c f) a)
gUnsafeThawRef_         = (GRef_ m f a -> M1 i c (GRef_ m f) a)
-> m (GRef_ m f a) -> m (M1 i c (GRef_ m f) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GRef_ m f a -> M1 i c (GRef_ m f) a
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (m (GRef_ m f a) -> m (M1 i c (GRef_ m f) a))
-> (M1 i c f a -> m (GRef_ m f a))
-> M1 i c f a
-> m (M1 i c (GRef_ m f) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gUnsafeThawRef_ (f a -> m (GRef_ m f a))
-> (M1 i c f a -> f a) -> M1 i c f a -> m (GRef_ m f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. M1 i c f a -> f a
forall i (c :: Meta) k (f :: k -> *) (p :: k). M1 i c f p -> f p
unM1
    gUnsafeFreezeRef_ :: GRef_ m (M1 i c f) a -> m (M1 i c f a)
gUnsafeFreezeRef_       = (f a -> M1 i c f a) -> m (f a) -> m (M1 i c f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f a -> M1 i c f a
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (m (f a) -> m (M1 i c f a))
-> (M1 i c (GRef_ m f) a -> m (f a))
-> M1 i c (GRef_ m f) a
-> m (M1 i c f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m f a -> m (f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gUnsafeFreezeRef_ (GRef_ m f a -> m (f a))
-> (M1 i c (GRef_ m f) a -> GRef_ m f a)
-> M1 i c (GRef_ m f) a
-> m (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. M1 i c (GRef_ m f) a -> GRef_ m f a
forall i (c :: Meta) k (f :: k -> *) (p :: k). M1 i c f p -> f p
unM1

-- | Wraps ':+:' in a mutable reference.  Used internally to represent
-- generic sum references.
newtype MutSumF m f g a = MutSumF { MutSumF m f g a -> MutVar (PrimState m) ((:+:) f g a)
getMutSumF :: MutVar (PrimState m) ((f :+: g) a) }

instance (GMutable m f, GMutable m g, PrimMonad m) => GMutable m (f :+: g) where
    type GRef_ m (f :+: g) = MutSumF m (GRef_ m f) (GRef_ m g)
    -- MutVar (PrimState m) :.: (GRef_ m f :+: GRef_ m g)

    gThawRef_ :: (:+:) f g a -> m (GRef_ m (f :+: g) a)
gThawRef_ = \case
      L1 x :: f a
x -> (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
 -> MutSumF m (GRef_ m f) (GRef_ m g) a)
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
-> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> MutSumF m (GRef_ m f) (GRef_ m g) a
forall k (m :: * -> *) (f :: k -> *) (g :: k -> *) (a :: k).
MutVar (PrimState m) ((:+:) f g a) -> MutSumF m f g a
MutSumF (m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
 -> m (MutSumF m (GRef_ m f) (GRef_ m g) a))
-> (GRef_ m f a
    -> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)))
-> GRef_ m f a
-> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:+:) (GRef_ m f) (GRef_ m g) a
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar ((:+:) (GRef_ m f) (GRef_ m g) a
 -> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)))
-> (GRef_ m f a -> (:+:) (GRef_ m f) (GRef_ m g) a)
-> GRef_ m f a
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m f a -> (:+:) (GRef_ m f) (GRef_ m g) a
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (GRef_ m f a -> m (MutSumF m (GRef_ m f) (GRef_ m g) a))
-> m (GRef_ m f a) -> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gThawRef_ f a
x
      R1 x :: g a
x -> (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
 -> MutSumF m (GRef_ m f) (GRef_ m g) a)
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
-> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> MutSumF m (GRef_ m f) (GRef_ m g) a
forall k (m :: * -> *) (f :: k -> *) (g :: k -> *) (a :: k).
MutVar (PrimState m) ((:+:) f g a) -> MutSumF m f g a
MutSumF (m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
 -> m (MutSumF m (GRef_ m f) (GRef_ m g) a))
-> (GRef_ m g a
    -> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)))
-> GRef_ m g a
-> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:+:) (GRef_ m f) (GRef_ m g) a
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar ((:+:) (GRef_ m f) (GRef_ m g) a
 -> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)))
-> (GRef_ m g a -> (:+:) (GRef_ m f) (GRef_ m g) a)
-> GRef_ m g a
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m g a -> (:+:) (GRef_ m f) (GRef_ m g) a
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (GRef_ m g a -> m (MutSumF m (GRef_ m f) (GRef_ m g) a))
-> m (GRef_ m g a) -> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< g a -> m (GRef_ m g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gThawRef_ g a
x
    gFreezeRef_ :: GRef_ m (f :+: g) a -> m ((:+:) f g a)
gFreezeRef_ (MutSumF r) = MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> m ((:+:) (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
r m ((:+:) (GRef_ m f) (GRef_ m g) a)
-> ((:+:) (GRef_ m f) (GRef_ m g) a -> m ((:+:) f g a))
-> m ((:+:) f g a)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      L1 v :: GRef_ m f a
v -> f a -> (:+:) f g a
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (f a -> (:+:) f g a) -> m (f a) -> m ((:+:) f g a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GRef_ m f a -> m (f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gFreezeRef_ GRef_ m f a
v
      R1 u :: GRef_ m g a
u -> g a -> (:+:) f g a
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (g a -> (:+:) f g a) -> m (g a) -> m ((:+:) f g a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GRef_ m g a -> m (g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gFreezeRef_ GRef_ m g a
u
    gCopyRef_ :: GRef_ m (f :+: g) a -> (:+:) f g a -> m ()
gCopyRef_ (MutSumF r) xy :: (:+:) f g a
xy = MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> m ((:+:) (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
r m ((:+:) (GRef_ m f) (GRef_ m g) a)
-> ((:+:) (GRef_ m f) (GRef_ m g) a -> m ()) -> m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      L1 v :: GRef_ m f a
v -> case (:+:) f g a
xy of
        L1 x :: f a
x -> GRef_ m f a -> f a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> f a -> m ()
gCopyRef_ GRef_ m f a
v f a
x
        R1 y :: g a
y -> MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> (:+:) (GRef_ m f) (GRef_ m g) a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
r ((:+:) (GRef_ m f) (GRef_ m g) a -> m ())
-> (GRef_ m g a -> (:+:) (GRef_ m f) (GRef_ m g) a)
-> GRef_ m g a
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m g a -> (:+:) (GRef_ m f) (GRef_ m g) a
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (GRef_ m g a -> m ()) -> m (GRef_ m g a) -> m ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< g a -> m (GRef_ m g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gThawRef_ g a
y
      R1 u :: GRef_ m g a
u -> case (:+:) f g a
xy of
        L1 x :: f a
x -> MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> (:+:) (GRef_ m f) (GRef_ m g) a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
r ((:+:) (GRef_ m f) (GRef_ m g) a -> m ())
-> (GRef_ m f a -> (:+:) (GRef_ m f) (GRef_ m g) a)
-> GRef_ m f a
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m f a -> (:+:) (GRef_ m f) (GRef_ m g) a
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (GRef_ m f a -> m ()) -> m (GRef_ m f a) -> m ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gThawRef_ f a
x
        R1 y :: g a
y -> GRef_ m g a -> g a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> f a -> m ()
gCopyRef_ GRef_ m g a
u g a
y
    gMoveRef_ :: GRef_ m (f :+: g) a -> GRef_ m (f :+: g) a -> m ()
gMoveRef_ (MutSumF u) (MutSumF v) = MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> m ((:+:) (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
v m ((:+:) (GRef_ m f) (GRef_ m g) a)
-> ((:+:) (GRef_ m f) (GRef_ m g) a -> m ()) -> m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      L1 vl :: GRef_ m f a
vl -> MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> m ((:+:) (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
u m ((:+:) (GRef_ m f) (GRef_ m g) a)
-> ((:+:) (GRef_ m f) (GRef_ m g) a -> m ()) -> m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
        L1 ul :: GRef_ m f a
ul -> GRef_ m f a -> GRef_ m f a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> GRef_ m f a -> m ()
gMoveRef_ GRef_ m f a
ul GRef_ m f a
vl
        R1 _  -> MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> (:+:) (GRef_ m f) (GRef_ m g) a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
u ((:+:) (GRef_ m f) (GRef_ m g) a -> m ())
-> (GRef_ m f a -> (:+:) (GRef_ m f) (GRef_ m g) a)
-> GRef_ m f a
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m f a -> (:+:) (GRef_ m f) (GRef_ m g) a
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (GRef_ m f a -> m ()) -> m (GRef_ m f a) -> m ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GRef_ m f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (GRef_ m f a)
gCloneRef_ GRef_ m f a
vl
      R1 vr :: GRef_ m g a
vr -> MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> m ((:+:) (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
u m ((:+:) (GRef_ m f) (GRef_ m g) a)
-> ((:+:) (GRef_ m f) (GRef_ m g) a -> m ()) -> m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
        L1 _  -> MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> (:+:) (GRef_ m f) (GRef_ m g) a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
u ((:+:) (GRef_ m f) (GRef_ m g) a -> m ())
-> (GRef_ m g a -> (:+:) (GRef_ m f) (GRef_ m g) a)
-> GRef_ m g a
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m g a -> (:+:) (GRef_ m f) (GRef_ m g) a
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (GRef_ m g a -> m ()) -> m (GRef_ m g a) -> m ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GRef_ m g a -> m (GRef_ m g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (GRef_ m f a)
gCloneRef_ GRef_ m g a
vr
        R1 ur :: GRef_ m g a
ur -> GRef_ m g a -> GRef_ m g a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> GRef_ m f a -> m ()
gMoveRef_ GRef_ m g a
ur GRef_ m g a
vr
    gCloneRef_ :: GRef_ m (f :+: g) a -> m (GRef_ m (f :+: g) a)
gCloneRef_ (MutSumF v) = MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> m ((:+:) (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
v m ((:+:) (GRef_ m f) (GRef_ m g) a)
-> ((:+:) (GRef_ m f) (GRef_ m g) a
    -> m (MutSumF m (GRef_ m f) (GRef_ m g) a))
-> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      L1 u :: GRef_ m f a
u -> (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
 -> MutSumF m (GRef_ m f) (GRef_ m g) a)
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
-> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> MutSumF m (GRef_ m f) (GRef_ m g) a
forall k (m :: * -> *) (f :: k -> *) (g :: k -> *) (a :: k).
MutVar (PrimState m) ((:+:) f g a) -> MutSumF m f g a
MutSumF (m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
 -> m (MutSumF m (GRef_ m f) (GRef_ m g) a))
-> (GRef_ m f a
    -> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)))
-> GRef_ m f a
-> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:+:) (GRef_ m f) (GRef_ m g) a
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar ((:+:) (GRef_ m f) (GRef_ m g) a
 -> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)))
-> (GRef_ m f a -> (:+:) (GRef_ m f) (GRef_ m g) a)
-> GRef_ m f a
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m f a -> (:+:) (GRef_ m f) (GRef_ m g) a
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (GRef_ m f a -> m (MutSumF m (GRef_ m f) (GRef_ m g) a))
-> m (GRef_ m f a) -> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GRef_ m f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (GRef_ m f a)
gCloneRef_ GRef_ m f a
u
      R1 u :: GRef_ m g a
u -> (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
 -> MutSumF m (GRef_ m f) (GRef_ m g) a)
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
-> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> MutSumF m (GRef_ m f) (GRef_ m g) a
forall k (m :: * -> *) (f :: k -> *) (g :: k -> *) (a :: k).
MutVar (PrimState m) ((:+:) f g a) -> MutSumF m f g a
MutSumF (m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
 -> m (MutSumF m (GRef_ m f) (GRef_ m g) a))
-> (GRef_ m g a
    -> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)))
-> GRef_ m g a
-> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:+:) (GRef_ m f) (GRef_ m g) a
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar ((:+:) (GRef_ m f) (GRef_ m g) a
 -> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)))
-> (GRef_ m g a -> (:+:) (GRef_ m f) (GRef_ m g) a)
-> GRef_ m g a
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m g a -> (:+:) (GRef_ m f) (GRef_ m g) a
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (GRef_ m g a -> m (MutSumF m (GRef_ m f) (GRef_ m g) a))
-> m (GRef_ m g a) -> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GRef_ m g a -> m (GRef_ m g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (GRef_ m f a)
gCloneRef_ GRef_ m g a
u
    gUnsafeThawRef_ :: (:+:) f g a -> m (GRef_ m (f :+: g) a)
gUnsafeThawRef_ = \case
      L1 x :: f a
x -> (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
 -> MutSumF m (GRef_ m f) (GRef_ m g) a)
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
-> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> MutSumF m (GRef_ m f) (GRef_ m g) a
forall k (m :: * -> *) (f :: k -> *) (g :: k -> *) (a :: k).
MutVar (PrimState m) ((:+:) f g a) -> MutSumF m f g a
MutSumF (m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
 -> m (MutSumF m (GRef_ m f) (GRef_ m g) a))
-> (GRef_ m f a
    -> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)))
-> GRef_ m f a
-> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:+:) (GRef_ m f) (GRef_ m g) a
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar ((:+:) (GRef_ m f) (GRef_ m g) a
 -> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)))
-> (GRef_ m f a -> (:+:) (GRef_ m f) (GRef_ m g) a)
-> GRef_ m f a
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m f a -> (:+:) (GRef_ m f) (GRef_ m g) a
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (GRef_ m f a -> m (MutSumF m (GRef_ m f) (GRef_ m g) a))
-> m (GRef_ m f a) -> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gUnsafeThawRef_ f a
x
      R1 x :: g a
x -> (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
 -> MutSumF m (GRef_ m f) (GRef_ m g) a)
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
-> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> MutSumF m (GRef_ m f) (GRef_ m g) a
forall k (m :: * -> *) (f :: k -> *) (g :: k -> *) (a :: k).
MutVar (PrimState m) ((:+:) f g a) -> MutSumF m f g a
MutSumF (m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
 -> m (MutSumF m (GRef_ m f) (GRef_ m g) a))
-> (GRef_ m g a
    -> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)))
-> GRef_ m g a
-> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:+:) (GRef_ m f) (GRef_ m g) a
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar ((:+:) (GRef_ m f) (GRef_ m g) a
 -> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)))
-> (GRef_ m g a -> (:+:) (GRef_ m f) (GRef_ m g) a)
-> GRef_ m g a
-> m (MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m g a -> (:+:) (GRef_ m f) (GRef_ m g) a
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (GRef_ m g a -> m (MutSumF m (GRef_ m f) (GRef_ m g) a))
-> m (GRef_ m g a) -> m (MutSumF m (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< g a -> m (GRef_ m g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gUnsafeThawRef_ g a
x
    gUnsafeFreezeRef_ :: GRef_ m (f :+: g) a -> m ((:+:) f g a)
gUnsafeFreezeRef_ (MutSumF r) = MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
-> m ((:+:) (GRef_ m f) (GRef_ m g) a)
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar MutVar (PrimState m) ((:+:) (GRef_ m f) (GRef_ m g) a)
r m ((:+:) (GRef_ m f) (GRef_ m g) a)
-> ((:+:) (GRef_ m f) (GRef_ m g) a -> m ((:+:) f g a))
-> m ((:+:) f g a)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      L1 v :: GRef_ m f a
v -> f a -> (:+:) f g a
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (f a -> (:+:) f g a) -> m (f a) -> m ((:+:) f g a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GRef_ m f a -> m (f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gUnsafeFreezeRef_ GRef_ m f a
v
      R1 u :: GRef_ m g a
u -> g a -> (:+:) f g a
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (g a -> (:+:) f g a) -> m (g a) -> m ((:+:) f g a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GRef_ m g a -> m (g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gUnsafeFreezeRef_ GRef_ m g a
u


-- | A 'Ref' for instances of 'GMutable', which are the "GHC.Generics"
-- combinators.
newtype GMutableRef m f a = GMutableRef { GMutableRef m f a -> GRef_ m f a
getGMutableRef :: GRef_ m f a }

deriving instance Eq (GRef_ m f a) => Eq (GMutableRef m f a)
deriving instance Ord (GRef_ m f a) => Ord (GMutableRef m f a)

thawGMutableRef :: GMutable m f => f a -> m (GMutableRef m f a)
thawGMutableRef :: f a -> m (GMutableRef m f a)
thawGMutableRef = (GRef_ m f a -> GMutableRef m f a)
-> m (GRef_ m f a) -> m (GMutableRef m f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GRef_ m f a -> GMutableRef m f a
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GRef_ m f a -> GMutableRef m f a
GMutableRef (m (GRef_ m f a) -> m (GMutableRef m f a))
-> (f a -> m (GRef_ m f a)) -> f a -> m (GMutableRef m f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gThawRef_

freezeGMutableRef :: GMutable m f => GMutableRef m f a -> m (f a)
freezeGMutableRef :: GMutableRef m f a -> m (f a)
freezeGMutableRef = GRef_ m f a -> m (f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gFreezeRef_ (GRef_ m f a -> m (f a))
-> (GMutableRef m f a -> GRef_ m f a)
-> GMutableRef m f a
-> m (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GMutableRef m f a -> GRef_ m f a
forall (m :: * -> *) k (f :: k -> *) (a :: k).
GMutableRef m f a -> GRef_ m f a
getGMutableRef

copyGMutableRef :: GMutable m f => GMutableRef m f a -> f a -> m ()
copyGMutableRef :: GMutableRef m f a -> f a -> m ()
copyGMutableRef (GMutableRef r :: GRef_ m f a
r) = GRef_ m f a -> f a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> f a -> m ()
gCopyRef_ GRef_ m f a
r

moveGMutableRef :: GMutable m f => GMutableRef m f a -> GMutableRef m f a -> m ()
moveGMutableRef :: GMutableRef m f a -> GMutableRef m f a -> m ()
moveGMutableRef (GMutableRef r :: GRef_ m f a
r) (GMutableRef s :: GRef_ m f a
s) = GRef_ m f a -> GRef_ m f a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> GRef_ m f a -> m ()
gMoveRef_ GRef_ m f a
r GRef_ m f a
s

cloneGMutableRef :: GMutable m f => GMutableRef m f a -> m (GMutableRef m f a)
cloneGMutableRef :: GMutableRef m f a -> m (GMutableRef m f a)
cloneGMutableRef (GMutableRef r :: GRef_ m f a
r) = GRef_ m f a -> GMutableRef m f a
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GRef_ m f a -> GMutableRef m f a
GMutableRef (GRef_ m f a -> GMutableRef m f a)
-> m (GRef_ m f a) -> m (GMutableRef m f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GRef_ m f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (GRef_ m f a)
gCloneRef_ GRef_ m f a
r

unsafeThawGMutableRef :: GMutable m f => f a -> m (GMutableRef m f a)
unsafeThawGMutableRef :: f a -> m (GMutableRef m f a)
unsafeThawGMutableRef = (GRef_ m f a -> GMutableRef m f a)
-> m (GRef_ m f a) -> m (GMutableRef m f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GRef_ m f a -> GMutableRef m f a
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GRef_ m f a -> GMutableRef m f a
GMutableRef (m (GRef_ m f a) -> m (GMutableRef m f a))
-> (f a -> m (GRef_ m f a)) -> f a -> m (GMutableRef m f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> m (GRef_ m f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gUnsafeThawRef_

unsafeFreezeGMutableRef :: GMutable m f => GMutableRef m f a -> m (f a)
unsafeFreezeGMutableRef :: GMutableRef m f a -> m (f a)
unsafeFreezeGMutableRef = GRef_ m f a -> m (f a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gUnsafeFreezeRef_ (GRef_ m f a -> m (f a))
-> (GMutableRef m f a -> GRef_ m f a)
-> GMutableRef m f a
-> m (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GMutableRef m f a -> GRef_ m f a
forall (m :: * -> *) k (f :: k -> *) (a :: k).
GMutableRef m f a -> GRef_ m f a
getGMutableRef

instance Mutable m c => Mutable m (K1 i c a) where
    type Ref m (K1 i c a) = GMutableRef m (K1 i c) a
    thawRef :: K1 i c a -> m (Ref m (K1 i c a))
thawRef         = K1 i c a -> m (Ref m (K1 i c a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GMutableRef m f a)
thawGMutableRef
    freezeRef :: Ref m (K1 i c a) -> m (K1 i c a)
freezeRef       = Ref m (K1 i c a) -> m (K1 i c a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (f a)
freezeGMutableRef
    copyRef :: Ref m (K1 i c a) -> K1 i c a -> m ()
copyRef         = Ref m (K1 i c a) -> K1 i c a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> f a -> m ()
copyGMutableRef
    moveRef :: Ref m (K1 i c a) -> Ref m (K1 i c a) -> m ()
moveRef         = Ref m (K1 i c a) -> Ref m (K1 i c a) -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> GMutableRef m f a -> m ()
moveGMutableRef
    cloneRef :: Ref m (K1 i c a) -> m (Ref m (K1 i c a))
cloneRef        = Ref m (K1 i c a) -> m (Ref m (K1 i c a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (GMutableRef m f a)
cloneGMutableRef
    unsafeThawRef :: K1 i c a -> m (Ref m (K1 i c a))
unsafeThawRef   = K1 i c a -> m (Ref m (K1 i c a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GMutableRef m f a)
unsafeThawGMutableRef
    unsafeFreezeRef :: Ref m (K1 i c a) -> m (K1 i c a)
unsafeFreezeRef = Ref m (K1 i c a) -> m (K1 i c a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (f a)
unsafeFreezeGMutableRef

instance Monad m => Mutable m (U1 a) where
    type Ref m (U1 a) = GMutableRef m U1 a
    thawRef :: U1 a -> m (Ref m (U1 a))
thawRef         = U1 a -> m (Ref m (U1 a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GMutableRef m f a)
thawGMutableRef
    freezeRef :: Ref m (U1 a) -> m (U1 a)
freezeRef       = Ref m (U1 a) -> m (U1 a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (f a)
freezeGMutableRef
    copyRef :: Ref m (U1 a) -> U1 a -> m ()
copyRef         = Ref m (U1 a) -> U1 a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> f a -> m ()
copyGMutableRef
    moveRef :: Ref m (U1 a) -> Ref m (U1 a) -> m ()
moveRef         = Ref m (U1 a) -> Ref m (U1 a) -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> GMutableRef m f a -> m ()
moveGMutableRef
    cloneRef :: Ref m (U1 a) -> m (Ref m (U1 a))
cloneRef        = Ref m (U1 a) -> m (Ref m (U1 a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (GMutableRef m f a)
cloneGMutableRef
    unsafeThawRef :: U1 a -> m (Ref m (U1 a))
unsafeThawRef   = U1 a -> m (Ref m (U1 a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GMutableRef m f a)
unsafeThawGMutableRef
    unsafeFreezeRef :: Ref m (U1 a) -> m (U1 a)
unsafeFreezeRef = Ref m (U1 a) -> m (U1 a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (f a)
unsafeFreezeGMutableRef

instance Monad m => Mutable m (V1 a) where
    type Ref m (V1 a) = GMutableRef m V1 a
    thawRef :: V1 a -> m (Ref m (V1 a))
thawRef         = V1 a -> m (Ref m (V1 a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GMutableRef m f a)
thawGMutableRef
    freezeRef :: Ref m (V1 a) -> m (V1 a)
freezeRef       = Ref m (V1 a) -> m (V1 a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (f a)
freezeGMutableRef
    copyRef :: Ref m (V1 a) -> V1 a -> m ()
copyRef         = Ref m (V1 a) -> V1 a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> f a -> m ()
copyGMutableRef
    moveRef :: Ref m (V1 a) -> Ref m (V1 a) -> m ()
moveRef         = Ref m (V1 a) -> Ref m (V1 a) -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> GMutableRef m f a -> m ()
moveGMutableRef
    cloneRef :: Ref m (V1 a) -> m (Ref m (V1 a))
cloneRef        = Ref m (V1 a) -> m (Ref m (V1 a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (GMutableRef m f a)
cloneGMutableRef
    unsafeThawRef :: V1 a -> m (Ref m (V1 a))
unsafeThawRef   = V1 a -> m (Ref m (V1 a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GMutableRef m f a)
unsafeThawGMutableRef
    unsafeFreezeRef :: Ref m (V1 a) -> m (V1 a)
unsafeFreezeRef = Ref m (V1 a) -> m (V1 a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (f a)
unsafeFreezeGMutableRef

instance (GMutable m f, GMutable m g) => Mutable m ((f :*: g) a) where
    type Ref m ((f :*: g) a) = GMutableRef m (f :*: g) a
    thawRef :: (:*:) f g a -> m (Ref m ((:*:) f g a))
thawRef         = (:*:) f g a -> m (Ref m ((:*:) f g a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GMutableRef m f a)
thawGMutableRef
    freezeRef :: Ref m ((:*:) f g a) -> m ((:*:) f g a)
freezeRef       = Ref m ((:*:) f g a) -> m ((:*:) f g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (f a)
freezeGMutableRef
    copyRef :: Ref m ((:*:) f g a) -> (:*:) f g a -> m ()
copyRef         = Ref m ((:*:) f g a) -> (:*:) f g a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> f a -> m ()
copyGMutableRef
    moveRef :: Ref m ((:*:) f g a) -> Ref m ((:*:) f g a) -> m ()
moveRef         = Ref m ((:*:) f g a) -> Ref m ((:*:) f g a) -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> GMutableRef m f a -> m ()
moveGMutableRef
    cloneRef :: Ref m ((:*:) f g a) -> m (Ref m ((:*:) f g a))
cloneRef        = Ref m ((:*:) f g a) -> m (Ref m ((:*:) f g a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (GMutableRef m f a)
cloneGMutableRef
    unsafeThawRef :: (:*:) f g a -> m (Ref m ((:*:) f g a))
unsafeThawRef   = (:*:) f g a -> m (Ref m ((:*:) f g a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GMutableRef m f a)
unsafeThawGMutableRef
    unsafeFreezeRef :: Ref m ((:*:) f g a) -> m ((:*:) f g a)
unsafeFreezeRef = Ref m ((:*:) f g a) -> m ((:*:) f g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (f a)
unsafeFreezeGMutableRef

instance (GMutable m f, GMutable m g, PrimMonad m) => Mutable m ((f :+: g) a) where
    type Ref m ((f :+: g) a) = GMutableRef m (f :+: g) a
    thawRef :: (:+:) f g a -> m (Ref m ((:+:) f g a))
thawRef         = (:+:) f g a -> m (Ref m ((:+:) f g a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GMutableRef m f a)
thawGMutableRef
    freezeRef :: Ref m ((:+:) f g a) -> m ((:+:) f g a)
freezeRef       = Ref m ((:+:) f g a) -> m ((:+:) f g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (f a)
freezeGMutableRef
    copyRef :: Ref m ((:+:) f g a) -> (:+:) f g a -> m ()
copyRef         = Ref m ((:+:) f g a) -> (:+:) f g a -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> f a -> m ()
copyGMutableRef
    moveRef :: Ref m ((:+:) f g a) -> Ref m ((:+:) f g a) -> m ()
moveRef         = Ref m ((:+:) f g a) -> Ref m ((:+:) f g a) -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> GMutableRef m f a -> m ()
moveGMutableRef
    cloneRef :: Ref m ((:+:) f g a) -> m (Ref m ((:+:) f g a))
cloneRef        = Ref m ((:+:) f g a) -> m (Ref m ((:+:) f g a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (GMutableRef m f a)
cloneGMutableRef
    unsafeThawRef :: (:+:) f g a -> m (Ref m ((:+:) f g a))
unsafeThawRef   = (:+:) f g a -> m (Ref m ((:+:) f g a))
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GMutableRef m f a)
unsafeThawGMutableRef
    unsafeFreezeRef :: Ref m ((:+:) f g a) -> m ((:+:) f g a)
unsafeFreezeRef = Ref m ((:+:) f g a) -> m ((:+:) f g a)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GMutableRef m f a -> m (f a)
unsafeFreezeGMutableRef


-- | 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 m MyType where
--     type Ref m MyType = 'GRef' m MyType
-- @
--
-- @
-- ghci> r <- 'thawRef' (MyType 3 4.5)
-- ghci> 'freezeRef' r
-- MyType 3 4.5
-- ghci> 'Data.Mutable.Parts.freezePart' ('Data.Mutable.Parts.fieldMut' #mtInt) r
-- 3
-- ghci> 'Data.Mutable.Parts.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.
newtype GRef m a = GRef { GRef m a -> GRef_ m (Rep a) ()
unGRef :: GRef_ m (Rep a) () }

deriving instance Eq (GRef_ m (Rep a) ()) => Eq (GRef m a)
deriving instance Ord (GRef_ m (Rep a) ()) => Ord (GRef m 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' m a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'GRef' for more information.
gThawRef
    :: (Generic a, GMutable m (Rep a))
    => a
    -> m (GRef m a)
gThawRef :: a -> m (GRef m a)
gThawRef = (GRef_ m (Rep a) () -> GRef m a)
-> m (GRef_ m (Rep a) ()) -> m (GRef m a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GRef_ m (Rep a) () -> GRef m a
forall (m :: * -> *) a. GRef_ m (Rep a) () -> GRef m a
GRef (m (GRef_ m (Rep a) ()) -> m (GRef m a))
-> (a -> m (GRef_ m (Rep a) ())) -> a -> m (GRef m a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep a () -> m (GRef_ m (Rep a) ())
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gThawRef_ (Rep a () -> m (GRef_ m (Rep a) ()))
-> (a -> Rep a ()) -> a -> m (GRef_ m (Rep a) ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Rep a ()
forall a x. Generic a => a -> Rep a x
from

-- | 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' m a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'GRef' for more information.
gFreezeRef
    :: (Generic a, GMutable m (Rep a))
    => GRef m a
    -> m a
gFreezeRef :: GRef m a -> m a
gFreezeRef = (Rep a () -> a) -> m (Rep a ()) -> m a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep a () -> a
forall a x. Generic a => Rep a x -> a
to (m (Rep a ()) -> m a)
-> (GRef m a -> m (Rep a ())) -> GRef m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m (Rep a) () -> m (Rep a ())
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gFreezeRef_ (GRef_ m (Rep a) () -> m (Rep a ()))
-> (GRef m a -> GRef_ m (Rep a) ()) -> GRef m a -> m (Rep a ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef m a -> GRef_ m (Rep a) ()
forall (m :: * -> *) a. GRef m a -> GRef_ m (Rep a) ()
unGRef

-- | 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' m a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'GRef' for more information.
gCopyRef
    :: (Generic a, GMutable m (Rep a))
    => GRef m a
    -> a
    -> m ()
gCopyRef :: GRef m a -> a -> m ()
gCopyRef (GRef v :: GRef_ m (Rep a) ()
v) x :: a
x = GRef_ m (Rep a) () -> Rep a () -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> f a -> m ()
gCopyRef_ GRef_ m (Rep a) ()
v (a -> Rep a ()
forall a x. Generic a => a -> Rep a x
from a
x)

-- | 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' m a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'GRef' for more information.
gMoveRef
    :: GMutable m (Rep a)
    => GRef m a
    -> GRef m a
    -> m ()
gMoveRef :: GRef m a -> GRef m a -> m ()
gMoveRef (GRef v :: GRef_ m (Rep a) ()
v) (GRef u :: GRef_ m (Rep a) ()
u) = GRef_ m (Rep a) () -> GRef_ m (Rep a) () -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> GRef_ m f a -> m ()
gMoveRef_ GRef_ m (Rep a) ()
v GRef_ m (Rep a) ()
u

-- | 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' m a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'GRef' for more information.
gCloneRef
    :: GMutable m (Rep a)
    => GRef m a
    -> m (GRef m a)
gCloneRef :: GRef m a -> m (GRef m a)
gCloneRef (GRef v :: GRef_ m (Rep a) ()
v) = GRef_ m (Rep a) () -> GRef m a
forall (m :: * -> *) a. GRef_ m (Rep a) () -> GRef m a
GRef (GRef_ m (Rep a) () -> GRef m a)
-> m (GRef_ m (Rep a) ()) -> m (GRef m a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GRef_ m (Rep a) () -> m (GRef_ m (Rep a) ())
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (GRef_ m f a)
gCloneRef_ GRef_ m (Rep a) ()
v

-- | 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' m a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'GRef' for more information.
gUnsafeThawRef
    :: (Generic a, GMutable m (Rep a))
    => a
    -> m (GRef m a)
gUnsafeThawRef :: a -> m (GRef m a)
gUnsafeThawRef = (GRef_ m (Rep a) () -> GRef m a)
-> m (GRef_ m (Rep a) ()) -> m (GRef m a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GRef_ m (Rep a) () -> GRef m a
forall (m :: * -> *) a. GRef_ m (Rep a) () -> GRef m a
GRef (m (GRef_ m (Rep a) ()) -> m (GRef m a))
-> (a -> m (GRef_ m (Rep a) ())) -> a -> m (GRef m a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep a () -> m (GRef_ m (Rep a) ())
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gUnsafeThawRef_ (Rep a () -> m (GRef_ m (Rep a) ()))
-> (a -> Rep a ()) -> a -> m (GRef_ m (Rep a) ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Rep a ()
forall a x. Generic a => a -> Rep a x
from

-- | 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' m a@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'GRef' for more information.
gUnsafeFreezeRef
    :: (Generic a, GMutable m (Rep a))
    => GRef m a
    -> m a
gUnsafeFreezeRef :: GRef m a -> m a
gUnsafeFreezeRef = (Rep a () -> a) -> m (Rep a ()) -> m a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep a () -> a
forall a x. Generic a => Rep a x -> a
to (m (Rep a ()) -> m a)
-> (GRef m a -> m (Rep a ())) -> GRef m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m (Rep a) () -> m (Rep a ())
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gUnsafeFreezeRef_ (GRef_ m (Rep a) () -> m (Rep a ()))
-> (GRef m a -> GRef_ m (Rep a) ()) -> GRef m a -> m (Rep a ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef m a -> GRef_ m (Rep a) ()
forall (m :: * -> *) a. GRef m a -> GRef_ m (Rep a) ()
unGRef


-- | 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' m)@ as the 'Ref'.
-- However, it can be useful if you are using a @z ('RefFor' m)@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'Mutable' for more information.
thawHKD
    :: forall z m.
    ( Generic (z Identity)
    , Generic (z (RefFor m))
    , GMutable m (Rep (z Identity))
    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))
    )
    => z Identity
    -> m (z (RefFor m))
thawHKD :: z Identity -> m (z (RefFor m))
thawHKD = (Rep (z (RefFor m)) Any -> z (RefFor m))
-> m (Rep (z (RefFor m)) Any) -> m (z (RefFor m))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep (z (RefFor m)) Any -> z (RefFor m)
forall a x. Generic a => Rep a x -> a
to (m (Rep (z (RefFor m)) Any) -> m (z (RefFor m)))
-> (z Identity -> m (Rep (z (RefFor m)) Any))
-> z Identity
-> m (z (RefFor m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep (z Identity) Any -> m (Rep (z (RefFor m)) Any)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gThawRef_ (Rep (z Identity) Any -> m (Rep (z (RefFor m)) Any))
-> (z Identity -> Rep (z Identity) Any)
-> z Identity
-> m (Rep (z (RefFor m)) Any)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. z Identity -> Rep (z Identity) Any
forall a x. Generic a => a -> Rep a x
from

-- | 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' m)@ as the 'Ref'.
-- However, it can be useful if you are using a @z ('RefFor' m)@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'Mutable' for more information.
freezeHKD
    :: forall z m.
    ( Generic (z Identity)
    , Generic (z (RefFor m))
    , GMutable m (Rep (z Identity))
    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))
    )
    => z (RefFor m)
    -> m (z Identity)
freezeHKD :: z (RefFor m) -> m (z Identity)
freezeHKD = (Rep (z Identity) Any -> z Identity)
-> m (Rep (z Identity) Any) -> m (z Identity)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep (z Identity) Any -> z Identity
forall a x. Generic a => Rep a x -> a
to (m (Rep (z Identity) Any) -> m (z Identity))
-> (z (RefFor m) -> m (Rep (z Identity) Any))
-> z (RefFor m)
-> m (z Identity)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep (z (RefFor m)) Any -> m (Rep (z Identity) Any)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gFreezeRef_ (Rep (z (RefFor m)) Any -> m (Rep (z Identity) Any))
-> (z (RefFor m) -> Rep (z (RefFor m)) Any)
-> z (RefFor m)
-> m (Rep (z Identity) Any)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. z (RefFor m) -> Rep (z (RefFor m)) Any
forall a x. Generic a => a -> Rep a x
from

-- | 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' m)@ as the 'Ref'.
-- However, it can be useful if you are using a @z ('RefFor' m)@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'Mutable' for more information.
copyHKD
    :: forall z m.
    ( Generic (z Identity)
    , Generic (z (RefFor m))
    , GMutable m (Rep (z Identity))
    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))
    )
    => z (RefFor m)
    -> z Identity
    -> m ()
copyHKD :: z (RefFor m) -> z Identity -> m ()
copyHKD r :: z (RefFor m)
r x :: z Identity
x = GRef_ m (Rep (z Identity)) Any -> Rep (z Identity) Any -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> f a -> m ()
gCopyRef_ (z (RefFor m) -> Rep (z (RefFor m)) Any
forall a x. Generic a => a -> Rep a x
from z (RefFor m)
r) (z Identity -> Rep (z Identity) Any
forall a x. Generic a => a -> Rep a x
from z Identity
x)

-- | 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' m)@ as the 'Ref'.
-- However, it can be useful if you are using a @z ('RefFor' m)@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'Mutable' for more information.
moveHKD
    :: forall z m.
    ( Generic (z (RefFor m))
    , GMutable m (Rep (z Identity))
    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))
    )
    => z (RefFor m)
    -> z (RefFor m)
    -> m ()
moveHKD :: z (RefFor m) -> z (RefFor m) -> m ()
moveHKD r :: z (RefFor m)
r x :: z (RefFor m)
x = GRef_ m (Rep (z Identity)) Any
-> GRef_ m (Rep (z Identity)) Any -> m ()
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> GRef_ m f a -> m ()
gMoveRef_ (z (RefFor m) -> Rep (z (RefFor m)) Any
forall a x. Generic a => a -> Rep a x
from z (RefFor m)
r) (z (RefFor m) -> Rep (z (RefFor m)) Any
forall a x. Generic a => a -> Rep a x
from z (RefFor m)
x)

-- | 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' m)@ as the 'Ref'.
-- However, it can be useful if you are using a @z ('RefFor' m)@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'Mutable' for more information.
cloneHKD
    :: forall z m.
    ( Generic (z (RefFor m))
    , GMutable m (Rep (z Identity))
    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))
    )
    => z (RefFor m)
    -> m (z (RefFor m))
cloneHKD :: z (RefFor m) -> m (z (RefFor m))
cloneHKD = (Rep (z (RefFor m)) Any -> z (RefFor m))
-> m (Rep (z (RefFor m)) Any) -> m (z (RefFor m))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep (z (RefFor m)) Any -> z (RefFor m)
forall a x. Generic a => Rep a x -> a
to (m (Rep (z (RefFor m)) Any) -> m (z (RefFor m)))
-> (z (RefFor m) -> m (Rep (z (RefFor m)) Any))
-> z (RefFor m)
-> m (z (RefFor m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GRef_ m (Rep (z Identity)) Any -> m (Rep (z (RefFor m)) Any)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (GRef_ m f a)
gCloneRef_ (GRef_ m (Rep (z Identity)) Any -> m (Rep (z (RefFor m)) Any))
-> (z (RefFor m) -> GRef_ m (Rep (z Identity)) Any)
-> z (RefFor m)
-> m (Rep (z (RefFor m)) Any)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. z (RefFor m) -> GRef_ m (Rep (z Identity)) Any
forall a x. Generic a => a -> Rep a x
from

-- | 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' m)@ as the 'Ref'.
-- However, it can be useful if you are using a @z ('RefFor' m)@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'Mutable' for more information.
unsafeThawHKD
    :: forall z m.
    ( Generic (z Identity)
    , Generic (z (RefFor m))
    , GMutable m (Rep (z Identity))
    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))
    )
    => z Identity
    -> m (z (RefFor m))
unsafeThawHKD :: z Identity -> m (z (RefFor m))
unsafeThawHKD = (Rep (z (RefFor m)) Any -> z (RefFor m))
-> m (Rep (z (RefFor m)) Any) -> m (z (RefFor m))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep (z (RefFor m)) Any -> z (RefFor m)
forall a x. Generic a => Rep a x -> a
to (m (Rep (z (RefFor m)) Any) -> m (z (RefFor m)))
-> (z Identity -> m (Rep (z (RefFor m)) Any))
-> z Identity
-> m (z (RefFor m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep (z Identity) Any -> m (Rep (z (RefFor m)) Any)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
f a -> m (GRef_ m f a)
gUnsafeThawRef_ (Rep (z Identity) Any -> m (Rep (z (RefFor m)) Any))
-> (z Identity -> Rep (z Identity) Any)
-> z Identity
-> m (Rep (z (RefFor m)) Any)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. z Identity -> Rep (z Identity) Any
forall a x. Generic a => a -> Rep a x
from

-- | 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' m)@ as the 'Ref'.
-- However, it can be useful if you are using a @z ('RefFor' m)@ just as
-- a normal data type, independent of the 'Ref' class.  See documentation
-- for 'Mutable' for more information.
unsafeFreezeHKD
    :: forall z m.
    ( Generic (z Identity)
    , Generic (z (RefFor m))
    , GMutable m (Rep (z Identity))
    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))
    )
    => z (RefFor m)
    -> m (z Identity)
unsafeFreezeHKD :: z (RefFor m) -> m (z Identity)
unsafeFreezeHKD = (Rep (z Identity) Any -> z Identity)
-> m (Rep (z Identity) Any) -> m (z Identity)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep (z Identity) Any -> z Identity
forall a x. Generic a => Rep a x -> a
to (m (Rep (z Identity) Any) -> m (z Identity))
-> (z (RefFor m) -> m (Rep (z Identity) Any))
-> z (RefFor m)
-> m (z Identity)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep (z (RefFor m)) Any -> m (Rep (z Identity) Any)
forall k (m :: * -> *) (f :: k -> *) (a :: k).
GMutable m f =>
GRef_ m f a -> m (f a)
gUnsafeFreezeRef_ (Rep (z (RefFor m)) Any -> m (Rep (z Identity) Any))
-> (z (RefFor m) -> Rep (z (RefFor m)) Any)
-> z (RefFor m)
-> m (Rep (z Identity) Any)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. z (RefFor m) -> Rep (z (RefFor m)) Any
forall a x. Generic a => a -> Rep a x
from