mutable 0.1.0.1 → 0.2.0.0

raw patch · 10 files changed

+919/−798 lines, 10 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +10/−0
• README.md +12/−10
• bench/bench.hs +26/−26
• mutable.cabal +4/−3
• src/Data/Mutable.hs +3/−0
• src/Data/Mutable/Branches.hs +176/−142
• src/Data/Mutable/Class.hs +71/−97
• src/Data/Mutable/Instances.hs +160/−135
• src/Data/Mutable/Internal.hs +270/−252
• src/Data/Mutable/Parts.hs +187/−133

@@ -1,6 +1,16 @@ Changelog ========= +Version 0.2.0.0+---------------++*July 5, 2020*++<https://github.com/mstksg/mutable/releases/tag/v0.2.0.0>++*   Demonadification: Revamp the typeclass system to be parameterized on the+    `s` `PrimState` state token, and not the monad itself.+ Version 0.1.0.1 --------------- 

@@ -76,6 +76,8 @@     V.freeze v ``` +(running this in `ST`, the mutable memory monad that comes with GHC)+ This is because all of the other items in the vector are kept the same and not copied-over over the course of one million updates.  It is `O(n+l)` in memory updates.  It is very good even for long vectors or large matrices.@@ -105,11 +107,11 @@ That's where this library comes in.  ```haskell-instance PrimMonad m => Mutable m TwoVec where-    type Ref m TwoVec = GRef m TwoVec+instance Mutable s TwoVec where+    type Ref s TwoVec = GRef s TwoVec ``` -This gives us `thawRef :: TwoVec -> m (GRef m TwoVec)`, where `GRef m TwoVec`+This gives us `thawRef :: TwoVec -> m (GRef s TwoVec)`, where `GRef s TwoVec` is a mutable version of `TwoVec`, like how `MVector s Double` is a mutable version of `Vector Double`.  It stores each field `tv1` and `tv2` as a seaprate `MVector` in memory that can be modified independently.@@ -132,7 +134,7 @@ can compose two functions that each work piecewise on `TwoVec`:  ```haskell-mut1 :: PrimMonad m => Ref m TwoVec -> m ()+mut1 :: Ref s TwoVec -> ST s () mut1 v = do     withField #tv1 v $ \u ->       MV.modify u 0 (+ 1)@@ -141,7 +143,7 @@       MV.modify u 2 (+ 3)       MV.modify u 3 (+ 4) -mut2 :: PrimMonad m => Ref m TwoVec -> m ()+mut2 :: Ref s TwoVec -> ST s () mut2 v = do     withField #tv1 v $ \u ->       MV.modify u 4 (+ 1)@@ -176,8 +178,8 @@   deriving (Show, Generic) infixr 5 `Cons` -instance (Mutable m a, PrimMonad m) => Mutable m (List a) where-    type Ref m (List a) = GRef m (List a)+instance Mutable s a => Mutable s (List a) where+    type Ref s (List a) = GRef s (List a) ```  We can write a function to "pop" out the top value and shift the rest of the@@ -185,9 +187,9 @@  ```haskell popStack-    :: (PrimMonad m, Mutable m a)-    => Ref m (List a)-    -> m (Maybe a)+    :: Mutable s a+    => Ref s (List a)+    -> ST s (Maybe a) popStack xs = do     c <- projectBranch (constrMB #_Cons) xs     forM c $ \(y, ys) -> do

@@ -51,8 +51,8 @@   deriving (Show, Generic, Functor, Foldable, Traversable)  instance NFData a => NFData (V4 a)-instance Mutable m a => Mutable m (V4 a) where-    type Ref m (V4 a) = GRef m (V4 a)+instance Mutable s a => Mutable s (V4 a) where+    type Ref s (V4 a) = GRef s (V4 a) instance Applicative V4 where     pure x = V4 x x x x     V4 a b c d <*> V4 x y z w = V4 (a x) (b y) (c z) (d w)@@ -62,8 +62,8 @@   deriving (Show, Generic, Functor, Foldable, Traversable)   deriving Applicative via (V4 :.: V4 :.: V4 :.: V4) instance NFData a => NFData (V256 a)-instance Mutable m a => Mutable m (V256 a) where-    type Ref m (V256 a) = CoerceRef m (V256 a) (V4 (V4 (V4 (V4 a))))+instance Mutable s a => Mutable s (V256 a) where+    type Ref s (V256 a) = CoerceRef s (V256 a) (V4 (V4 (V4 (V4 a)))) makeLenses 'V256  -- HKD variant of V4@@ -74,16 +74,16 @@                    }   deriving (Show, Generic) instance NFData (f a) => NFData (V4F a f)-instance Mutable m a => Mutable m (V4F a Identity) where-    type Ref m (V4F a Identity) = V4F a (RefFor m)+instance Mutable s a => Mutable s (V4F a Identity) where+    type Ref s (V4F a Identity) = V4F a (RefFor s)  -- HKD variant of V256 newtype V256F a = V256F { _v256F :: V4F (V4F (V4F (V4F a Identity) Identity) Identity) Identity }   deriving (Show, Generic) instance NFData a => NFData (Identity a) instance NFData a => NFData (V256F a)-instance Mutable m a => Mutable m (V256F a) where-    type Ref m (V256F a) = CoerceRef m (V256F a) (V4F (V4F (V4F (V4F a Identity) Identity) Identity) Identity)+instance Mutable s a => Mutable s (V256F a) where+    type Ref s (V256F a) = CoerceRef s (V256F a) (V4F (V4F (V4F (V4F a Identity) Identity) Identity) Identity)   type ADT  = V256 Double@@ -113,7 +113,7 @@   -mutLoop :: (forall s. Mutable (ST s) a) => (forall s. Ref (ST s) a -> ST s ()) -> Int -> a -> a+mutLoop :: (forall s. Mutable s a) => (forall s. Ref s a -> ST s ()) -> Int -> a -> a mutLoop f n x0 = runST $ do     r <- thawRef x0     let go !i@@ -124,10 +124,10 @@     go 0     unsafeFreezeRef r -modifyPartMut :: (forall s. Mutable (ST s) a) => (forall s. MutPart (ST s) a Double) -> Int -> a -> a+modifyPartMut :: (forall s. Mutable s a) => (forall s. MutPart s a Double) -> Int -> a -> a modifyPartMut f = mutLoop $ \r -> modifyPart' f r (+1) -modifyWholeMut :: (forall s b. Mutable (ST s) b => Ref (ST s) (V4 b) -> ContT () (ST s) (Ref (ST s) b)) -> Int -> ADT -> ADT+modifyWholeMut :: (forall s b. Mutable s b => Ref s (V4 b) -> ContT () (ST s) (Ref s b)) -> Int -> ADT -> ADT modifyWholeMut f = mutLoop          $ \r ->                      withAllRefV256 f r $ \s ->                        modifyRef s (+ 1)@@ -137,11 +137,11 @@                       withAllRefV256HKD r $ \s ->                         modifyRef s (+ 1) -modifyPartMutV :: (forall s. Mutable (ST s) a) => (forall s. MutPart (ST s) a (Vector Double)) -> Int -> a -> a+modifyPartMutV :: (forall s. Mutable s a) => (forall s. MutPart s a (Vector Double)) -> Int -> a -> a modifyPartMutV f = mutLoop $ \r -> withPart f r $ \mv ->                      (MV.write mv 0 $!) . (+ 1) =<< MV.read mv 0 -modifyWholeMutV :: (forall s. Mutable (ST s) a) => (forall s. Ref (ST s) a -> ContT () (ST s) (MV.MVector s Double)) -> Int -> a -> a+modifyWholeMutV :: (forall s. Mutable s a) => (forall s. Ref s a -> ContT () (ST s) (MV.MVector s Double)) -> Int -> a -> a modifyWholeMutV f = mutLoop $ \r -> runContT (f r) $ \mv -> do     forM_ [0 .. MV.length mv - 1] $ \i ->       (MV.write mv i $!) . (+ 1) =<< MV.read mv i@@ -220,16 +220,16 @@ toVF :: V4 a -> V4F a Identity toVF (V4 a b c d) = V4F (Identity a) (Identity b) (Identity c) (Identity d) -vfParts :: forall m a. Mutable m a => V4F a (MutPart m (V4F a Identity))+vfParts :: forall s a. Mutable s a => V4F a (MutPart s (V4F a Identity)) vfParts = hkdMutParts @(V4F a) -partRep :: Mutable m a => (forall b. Mutable m b => MutPart m (V4 b) b) -> MutPart m (V256 a) a+partRep :: Mutable s a => (forall b. Mutable s b => MutPart s (V4 b) b) -> MutPart s (V256 a) a partRep f = f . f . f . f . coerceRef -firstTuple :: Mutable m a => MutPart m (V4 a) a+firstTuple :: Mutable s a => MutPart s (V4 a) a firstTuple = MutPart (\(x,_,_,_) -> x) . tupleMut -modPartHKD :: forall m a. Mutable m a => MutPart m (V256F a) a+modPartHKD :: Mutable s a => MutPart s (V256F a) a modPartHKD = _vf4X vfParts            . _vf4X vfParts            . _vf4X vfParts@@ -238,21 +238,21 @@   -withAllRefV4Field :: Mutable m a => Ref m (V4 a) -> ContT () m (Ref m a)+withAllRefV4Field :: (Mutable s a, Monad m) => Ref s (V4 a) -> ContT () m (Ref s a) withAllRefV4Field r = ContT $ \f -> do     withPart (fieldMut #_v4X) r f     withPart (fieldMut #_v4Y) r f     withPart (fieldMut #_v4Z) r f     withPart (fieldMut #_v4W) r f -withAllRefV4Pos :: Mutable m a => Ref m (V4 a) -> ContT () m (Ref m a)+withAllRefV4Pos :: (Mutable s a, Monad m) => Ref s (V4 a) -> ContT () m (Ref s a) withAllRefV4Pos r = ContT $ \f -> do     withPart (posMut @1) r f     withPart (posMut @2) r f     withPart (posMut @3) r f     withPart (posMut @4) r f -withAllRefV4Tuple :: Mutable m a => Ref m (V4 a) -> ContT () m (Ref m a)+withAllRefV4Tuple :: (Mutable s a, Monad m) => Ref s (V4 a) -> ContT () m (Ref s a) withAllRefV4Tuple r = ContT       $ \f ->                         withTuple r $ \(x, y, z, w) -> do       f x@@ -260,7 +260,7 @@       f z       f w -withAllRefV4HKD :: forall m a. Mutable m a => V4F a (RefFor m) -> ContT () m (Ref m a)+withAllRefV4HKD :: forall m s a. (Mutable s a, Monad m) => V4F a (RefFor s) -> ContT () m (Ref s a) withAllRefV4HKD r = ContT $ \f -> do     withPart (_vf4X vfParts) r f     withPart (_vf4Y vfParts) r f@@ -268,10 +268,10 @@     withPart (_vf4W vfParts) r f  withAllRefV256-    :: Mutable m a-    => (forall b. Mutable m b => Ref m (V4 b) -> ContT () m (Ref m b))-    -> Ref m (V256 a)-    -> (Ref m a -> m ())+    :: (Mutable s a, Monad m)+    => (forall b. Mutable s b => Ref s (V4 b) -> ContT () m (Ref s b))+    -> Ref s (V256 a)+    -> (Ref s a -> m ())     -> m () withAllRefV256 a r f = flip runContT pure $ do     s   <- a =<< a =<< a =<< a@@ -279,7 +279,7 @@     lift $ f s  -withAllRefV256HKD :: Mutable m a => Ref m (V256F a) -> (Ref m a -> m ()) -> m ()+withAllRefV256HKD :: (Mutable s a, Monad m) => Ref s (V256F a) -> (Ref s a -> m ()) -> m () withAllRefV256HKD r f = flip runContT pure $ do     s   <- withAllRefV4HKD        =<< withAllRefV4HKD

@@ -1,13 +1,13 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.31.2.+-- This file has been generated from package.yaml by hpack version 0.33.0. -- -- see: https://github.com/sol/hpack ----- hash: 71081ba24c9c597ffd540904a9115e3f1dc62b4606dab2916c17c6961d9cbdd8+-- hash: b7384039190c92bb1ccdc49dabc8288ac734520f4aa13ad47f6893e933a83ebb  name:           mutable-version:        0.1.0.1+version:        0.2.0.0 synopsis:       Automatic piecewise-mutable references for your types description:    Associate and generate "piecewise-mutable" versions for your composite data                 types.  Think of it like a "generalized MVector for all ADTs".@@ -55,6 +55,7 @@     , constraints     , generic-lens >=2.0     , generic-lens-core >=2.0+    , microlens     , primitive >=0.6.4     , reflection     , transformers

@@ -24,7 +24,10 @@   , CoerceRef(..)   , TraverseRef(..)   , GMutableRef(..)+  , RecRef(..)   , HListRef(..)+  , UnitRef(..)+  , VoidRef   -- * Providing/overriding instances   , VarMut(..)   , CoerceMut(..)

@@ -1,4 +1,5 @@ {-# LANGUAGE AllowAmbiguousTypes    #-}+{-# LANGUAGE DeriveGeneric          #-} {-# LANGUAGE FlexibleContexts       #-} {-# LANGUAGE FlexibleInstances      #-} {-# LANGUAGE FunctionalDependencies #-}@@ -59,6 +60,7 @@ import           Control.Monad import           Control.Monad.Primitive import           Data.Generics.Product.Internal.HList+import           Data.Kind import           Data.Maybe import           Data.Mutable.Class import           Data.Mutable.Instances@@ -69,11 +71,11 @@ import qualified Data.GenericLens.Internal              as GL import qualified Data.Generics.Internal.Profunctor.Lens as GLP --- | A @'MutBranch' m s a@ represents the information that @s@ could--- potentially be an @a@.  Similar in spirit to a @Prism' s a@.+-- | A @'MutBranch' s b a@ represents the information that @b@ could+-- potentially be an @a@.  Similar in spirit to a @Prism' b a@. ----- @'MutBranch' m s a@ means that @a@ is one potential option that @s@--- could be in, or that @s@ is a sum type and @a@ is one of the+-- @'MutBranch' s b a@ means that @a@ is one potential option that @b@+-- could be in, or that @b@ is a sum type and @a@ is one of the -- branches/constructors. -- -- See <https://mutable.jle.im/06-mutable-branches.html> for an@@ -89,8 +91,8 @@ -- get the two branches of an 'Either': -- -- @--- constrMB #_Left   :: MutBranch m (Either a b) a--- constrMB #_Right  :: MutBranch m (Either a b) b+-- constrMB #_Left   :: MutBranch s (Either a b) a+-- constrMB #_Right  :: MutBranch s (Either a b) b -- @ -- -- @@@ -129,18 +131,18 @@ -- data List a = Nil | Cons a (List a) --   deriving Generic ----- instance Mutable m a => 'Mutable' m (List a) where---     type Ref m (List a) = 'GRef' m (List a)+-- instance Mutable s a => 'Mutable' s (List a) where+--     type Ref s (List a) = 'GRef' s (List a) -- @ ----- @'GRef' m (List a)@ is now a mutable linked list!  Once we make the+-- @'GRef' s (List a)@ is now a mutable linked list!  Once we make the -- 'MutBranch' for the nil and cons cases: -- -- @--- nilBranch :: MutBranch m (List a) ()+-- nilBranch :: MutBranch s (List a) () -- nilBranch = constrMB #_Nil ----- consBranch :: MutBranch m (List a) (a, List a)+-- consBranch :: MutBranch s (List a) (a, List a) -- consBranch = constrMB #_Cons -- @ --@@ -149,8 +151,8 @@ -- -- @ -- isEmpty---     :: (PrimMonad m, Mutable m a)---     => Ref m (List a)+--     :: (PrimMonad m, Mutable s a)+--     => Ref s (List a) --     -> m Bool -- isEmpty = hasBranch nilBranch -- @@@ -160,8 +162,8 @@ -- -- @ -- popStack---     :: (PrimMonad m, Mutable m a)---     => Ref m (List a)+--     :: (PrimMonad m, Mutable s a)+--     => Ref s (List a) --     -> m (Maybe a) -- popStack r = do --     c <- projectBranch consBranch r@@ -177,9 +179,9 @@ -- -- @ -- concatLists---     :: (PrimMonad m, Mutable m a)---     => Ref m (List a)---     -> Ref m (List a)+--     :: (PrimMonad m, Mutable s a)+--     => Ref s (List a)+--     -> Ref s (List a) --     -> m () -- concatLists l1 l2 = do --     c <- projectBranch consBranch l1@@ -187,7 +189,7 @@ --       Nothing      -> moveRef l1 l2 --       Just (_, xs) -> concatLists xs l2 -- @-data MutBranch m s a = MutBranch+data MutBranch s b a = MutBranch     { -- | With a 'MutBranch', attempt to get the mutable contents of       -- a branch of a mutable       -- @s@, if possible.@@ -205,7 +207,7 @@       -- ghci> case s of Nothing -> "it was Right"       -- "it was Right"       -- @-      projectBranch :: Ref m s -> m (Maybe (Ref m a))+      projectBranch :: forall m. (PrimMonad m, PrimState m ~ s) => Ref s b -> m (Maybe (Ref s a))       -- | Embed an @a@ ref as a part of a larger @s@ ref.  Note that this       -- /does not copy or clone/: any mutations to the @a@ ref will be       -- reflected in the @s@ ref, as long as the @s@ ref maintains the@@ -239,11 +241,11 @@       -- ghci> freezeRef r       -- 0       -- @-    , embedBranch :: Ref m a -> m (Ref m s)+    , embedBranch :: forall m. (PrimMonad m, PrimState m ~ s) => Ref s a -> m (Ref s b)     }  -- | Compose two 'MutBranch's, to drill down on what is being focused.-compMB :: Monad m => MutBranch m a b -> MutBranch m b c -> MutBranch m a c+compMB :: MutBranch s a b -> MutBranch s b c -> MutBranch s a c compMB mb1 mb2 = MutBranch     { projectBranch = projectBranch mb1 >=> \case         Nothing -> pure Nothing@@ -253,7 +255,7 @@  -- | An identity 'MutBranch', treating the item itself as a whole branch. -- 'cloneBranch' will always "match".-idMB :: Applicative m => MutBranch m a a+idMB :: MutBranch s a a idMB = MutBranch (pure . Just) pure  -- | With a 'MutBranch', thaw an @a@ into a mutable @s@ on that branch.@@ -264,10 +266,10 @@ -- Left 10 -- @ thawBranch-    :: Mutable m a-    => MutBranch m s a+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a     -> a-    -> m (Ref m s)+    -> m (Ref s b) thawBranch mb = embedBranch mb <=< thawRef  -- | With a 'MutBranch', read out a specific @a@ branch of an @s@, if it exists.@@ -280,25 +282,25 @@ -- Nothing -- @ freezeBranch-    :: Mutable m a-    => MutBranch m s a    -- ^ How to check if is @s@ is an @a@-    -> Ref m s            -- ^ Structure to read out of+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a    -- ^ How to check if is @s@ is an @a@+    -> Ref s b            -- ^ Structure to read out of     -> m (Maybe a) freezeBranch mb = mapM freezeRef <=< projectBranch mb  -- | Check if an @s@ is currently a certain branch @a@. hasBranch-    :: Mutable m a-    => MutBranch m s a-    -> Ref m s+    :: (PrimMonad m, PrimState m ~ s)+    => MutBranch s b a+    -> Ref s b     -> m Bool hasBranch mb = fmap isJust . projectBranch mb  -- | Check if an @s@ is /not/ currently a certain branch @a@. hasn'tBranch-    :: Mutable m a-    => MutBranch m s a-    -> Ref m s+    :: (PrimMonad m, PrimState m ~ s)+    => MutBranch s b a+    -> Ref s b     -> m Bool hasn'tBranch mb = fmap isNothing . projectBranch mb @@ -314,9 +316,9 @@ -- Right True -- @ copyBranch-    :: (Mutable m s, Mutable m a)-    => MutBranch m s a      -- ^ How to check if @s@ is an @a@-    -> Ref m s              -- ^ Structure to write into+    :: (Mutable s b, Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a      -- ^ How to check if @s@ is an @a@+    -> Ref s b              -- ^ Structure to write into     -> a                    -- ^ Value to set @s@ to be     -> m () copyBranch mb r = moveBranch mb r <=< thawRef@@ -335,10 +337,10 @@ -- Right True -- @ moveBranch-    :: Mutable m s-    => MutBranch m s a-    -> Ref m s-    -> Ref m a+    :: (Mutable s b, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a+    -> Ref s b+    -> Ref s a     -> m () moveBranch mb r = moveRef r <=< embedBranch mb @@ -359,10 +361,10 @@ -- "it was Right" -- @ cloneBranch-    :: Mutable m a-    => MutBranch m s a      -- ^ How to check if @s@ is an @a@-    -> Ref m s              -- ^ Structure to read out of-    -> m (Maybe (Ref m a))+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a      -- ^ How to check if @s@ is an @a@+    -> Ref s b              -- ^ Structure to read out of+    -> m (Maybe (Ref s a)) cloneBranch mb = mapM cloneRef <=< projectBranch mb  -- | A non-copying version of 'freezeBranch' that can be more efficient@@ -373,9 +375,9 @@ -- reference, since it can potentially directly mutate the frozen value -- magically. unsafeFreezeBranch-    :: Mutable m a-    => MutBranch m s a    -- ^ How to check if is @s@ is an @a@-    -> Ref m s            -- ^ Structure to read out of+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a    -- ^ How to check if is @s@ is an @a@+    -> Ref s b            -- ^ Structure to read out of     -> m (Maybe a) unsafeFreezeBranch mb = mapM unsafeFreezeRef <=< projectBranch mb @@ -386,10 +388,10 @@ -- This is safe as long as you never again use the original pure value, -- since it can potentially directly mutate it. unsafeThawBranch-    :: Mutable m a-    => MutBranch m s a+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a     -> a-    -> m (Ref m s)+    -> m (Ref s b) unsafeThawBranch mb = embedBranch mb <=< unsafeThawRef  @@ -413,19 +415,19 @@ -- Nothing -- @ withBranch-    :: Mutable m a-    => MutBranch m s a    -- ^ How to check if is @s@ is an @a@-    -> Ref m s            -- ^ Structure to read out of and write into-    -> (Ref m a -> m b)   -- ^ Action to perform on the @a@ branch of @s@-    -> m (Maybe b)+    :: (PrimMonad m, PrimState m ~ s)+    => MutBranch s b a    -- ^ How to check if is @s@ is an @a@+    -> Ref s b            -- ^ Structure to read out of and write into+    -> (Ref s a -> m r)   -- ^ Action to perform on the @a@ branch of @s@+    -> m (Maybe r) withBranch mb r f = mapM f =<< projectBranch mb r  -- | 'withBranch', but discarding the returned value. withBranch_-    :: Mutable m a-    => MutBranch m s a    -- ^ How to check if is @s@ is an @a@-    -> Ref m s            -- ^ Structure to read out of and write into-    -> (Ref m a -> m b)   -- ^ Action to perform on the @a@ branch of @s@+    :: (PrimMonad m, PrimState m ~ s)+    => MutBranch s b a    -- ^ How to check if is @s@ is an @a@+    -> Ref s b            -- ^ Structure to read out of and write into+    -> (Ref s a -> m r)   -- ^ Action to perform on the @a@ branch of @s@     -> m () withBranch_ mb r = void . withBranch mb r @@ -446,9 +448,9 @@ -- Nothing -- @ modifyBranch-    :: Mutable m a-    => MutBranch m s a      -- ^ How to check if @s@ is an @a@-    -> Ref m s            -- ^ Structure to read out of and write into+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a      -- ^ How to check if @s@ is an @a@+    -> Ref s b            -- ^ Structure to read out of and write into     -> (a -> a)             -- ^ Pure function modifying @a@     -> m () modifyBranch mb r f = withBranch_ mb r (`modifyRef` f)@@ -456,9 +458,9 @@ -- | 'modifyBranch', but forces the result before storing it back in the -- reference. modifyBranch'-    :: Mutable m a-    => MutBranch m s a      -- ^ How to check if @s@ is an @a@-    -> Ref m s            -- ^ Structure to read out of and write into+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a      -- ^ How to check if @s@ is an @a@+    -> Ref s b            -- ^ Structure to read out of and write into     -> (a -> a)             -- ^ Pure function modifying @a@     -> m () modifyBranch' mb r f = withBranch_ mb r (`modifyRef'` f)@@ -466,9 +468,9 @@ -- | 'modifyBranch' but for a monadic function.  Uses 'copyRef' into the -- reference after the action is completed. modifyBranchM-    :: Mutable m a-    => MutBranch m s a      -- ^ How to check if @s@ is an @a@-    -> Ref m s            -- ^ Structure to read out of and write into+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a      -- ^ How to check if @s@ is an @a@+    -> Ref s b            -- ^ Structure to read out of and write into     -> (a -> m a)             -- ^ Monadic function modifying @a@     -> m () modifyBranchM mb r f = withBranch_ mb r (`modifyRefM` f)@@ -476,9 +478,9 @@ -- | 'modifyBranchM', but forces the result before storing it back in the -- reference. modifyBranchM'-    :: Mutable m a-    => MutBranch m s a      -- ^ How to check if @s@ is an @a@-    -> Ref m s            -- ^ Structure to read out of and write into+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a      -- ^ How to check if @s@ is an @a@+    -> Ref s b            -- ^ Structure to read out of and write into     -> (a -> m a)             -- ^ Monadic function modifying @a@     -> m () modifyBranchM' mb r f = withBranch_ mb r (`modifyRefM'` f)@@ -503,41 +505,41 @@ -- Nothing -- @ updateBranch-    :: Mutable m a-    => MutBranch m s a      -- ^ How to check if @s@ is an @a@-    -> Ref m s            -- ^ Structure to read out of and write into-    -> (a -> (a, b))-    -> m (Maybe b)+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a      -- ^ How to check if @s@ is an @a@+    -> Ref s b            -- ^ Structure to read out of and write into+    -> (a -> (a, r))+    -> m (Maybe r) updateBranch mb r f = withBranch mb r (`updateRef` f)  -- | 'updateBranch', but forces the result before storing it back in the -- reference. updateBranch'-    :: Mutable m a-    => MutBranch m s a      -- ^ How to check if @s@ is an @a@-    -> Ref m s            -- ^ Structure to read out of and write into-    -> (a -> (a, b))-    -> m (Maybe b)+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a      -- ^ How to check if @s@ is an @a@+    -> Ref s b            -- ^ Structure to read out of and write into+    -> (a -> (a, r))+    -> m (Maybe r) updateBranch' mb r f = withBranch mb r (`updateRef'` f)  -- | 'updateBranch' but for a monadic function.  Uses 'copyRef' into the -- reference after the action is completed. updateBranchM-    :: Mutable m a-    => MutBranch m s a      -- ^ How to check if @s@ is an @a@-    -> Ref m s            -- ^ Structure to read out of and write into-    -> (a -> m (a, b))-    -> m (Maybe b)+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a      -- ^ How to check if @s@ is an @a@+    -> Ref s b            -- ^ Structure to read out of and write into+    -> (a -> m (a, r))+    -> m (Maybe r) updateBranchM mb r f = withBranch mb r (`updateRefM` f)  -- | 'updateBranchM', but forces the result before storing it back in the -- reference. updateBranchM'-    :: Mutable m a-    => MutBranch m s a      -- ^ How to check if @s@ is an @a@-    -> Ref m s            -- ^ Structure to read out of and write into-    -> (a -> m (a, b))-    -> m (Maybe b)+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutBranch s b a      -- ^ How to check if @s@ is an @a@+    -> Ref s b            -- ^ Structure to read out of and write into+    -> (a -> m (a, r))+    -> m (Maybe r) updateBranchM' mb r f = withBranch mb r (`updateRefM'` f)  @@ -556,76 +558,86 @@ -- | Typeclass powering 'constrMB' using GHC Generics. -- -- Heavily inspired by "Data.Generics.Sum.Constructors".-class (GMutable m f, Mutable m a) => GMutBranchConstructor (ctor :: Symbol) m f a | ctor f -> a where-    gmbcProj  :: CLabel ctor -> GRef_ m f x -> m (Maybe (Ref m a))-    gmbcEmbed :: CLabel ctor -> Ref m a -> m (GRef_ m f x)+class (GMutable s f, Mutable s a) => GMutBranchConstructor (ctor :: Symbol) s f a | ctor f -> a where+    gmbcProj  :: (PrimMonad m, PrimState m ~ s) => CLabel ctor -> GRef_ s f x -> m (Maybe (Ref s a))+    gmbcEmbed :: (PrimMonad m, PrimState m ~ s) => CLabel ctor -> Ref s a -> m (GRef_ s f x)  instance-      ( GMutable m f-      , Mutable m a-      , GIsList (GRef_ m f) (GRef_ m f) (MapRef m as) (MapRef m as)+      ( GMutable s f+      , Mutable s a+      , GIsList (GRef_ s f) (GRef_ s f) (MapRef s as) (MapRef s as)       , GIsList f f as as       , ListTuple a a as as-      , ListTuple b b (MapRef m as) (MapRef m as)-      , Ref m a ~ b+      , ListRefTuple s b as+      , Ref s a ~ b       )-      => GMutBranchConstructor ctor m (M1 C ('MetaCons ctor fixity fields) f) a where+      => GMutBranchConstructor ctor s (M1 C ('MetaCons ctor fixity fields) f) a where     gmbcProj _  = pure . Just-                . listToTuple @b @b @(MapRef m as) @(MapRef m as)-                . GLP.view glist . unM1-    gmbcEmbed _ = pure . M1 . GLP.view (GL.fromIso glist)-                . tupleToList @b @_ @(MapRef m as)+                . GLP.view (glist . tupledRef @s @b @as)+                . unM1+    gmbcEmbed _ = pure+                . M1+                . GLP.view (GL.fromIso (glist . tupledRef @s @b @as)) + instance GMutBranchConstructor ctor m f a => GMutBranchConstructor ctor m (M1 D meta f) a where     gmbcProj  lb = gmbcProj lb . unM1     gmbcEmbed lb = fmap M1 . gmbcEmbed lb  instance-      ( PrimMonad m-      , Mutable m a-      , GMutBranchSum ctor (GL.HasCtorP ctor l) m l r a+      ( Mutable s a+      , GMutBranchSum ctor (GL.HasCtorP ctor l) s l r a       )-      => GMutBranchConstructor ctor m (l :+: r) a where+      => GMutBranchConstructor ctor s (l :+: r) a where     gmbcProj  = gmbsProj @ctor @(GL.HasCtorP ctor l)     gmbcEmbed = gmbsEmbed @ctor @(GL.HasCtorP ctor l) -class (GMutable m l, GMutable m r, Mutable m a) => GMutBranchSum (ctor :: Symbol) (contains :: Bool) m l r a | ctor l r -> a where-    gmbsProj  :: CLabel ctor -> MutSumF m (GRef_ m l) (GRef_ m r) x -> m (Maybe (Ref m a))-    gmbsEmbed :: CLabel ctor -> Ref m a -> m (MutSumF m (GRef_ m l) (GRef_ m r) x)+class ( GMutable s l+      , GMutable s r+      , Mutable s a+      ) => GMutBranchSum (ctor :: Symbol) (contains :: Bool) s l r a | ctor l r -> a where+    gmbsProj+        :: (PrimMonad m, PrimState m ~ s)+        => CLabel ctor+        -> MutSumF s (GRef_ s l) (GRef_ s r) x+        -> m (Maybe (Ref s a))+    gmbsEmbed+        :: (PrimMonad m, PrimState m ~ s)+        => CLabel ctor+        -> Ref s a+        -> m (MutSumF s (GRef_ s l) (GRef_ s r) x)  instance-      ( PrimMonad m-      , GMutable m r-      , GMutBranchConstructor ctor m l a-      , GIsList (GRef_ m l) (GRef_ m l) (MapRef m as) (MapRef m as)+      ( GMutable s r+      , GMutBranchConstructor ctor s l a+      , GIsList (GRef_ s l) (GRef_ s l) (MapRef s as) (MapRef s as)       , GIsList l l as as       , ListTuple a a as as-      , ListTuple b b (MapRef m as) (MapRef m as)-      , Ref m a ~ b+      , ListRefTuple s b as+      , Ref s a ~ b       )-      => GMutBranchSum ctor 'True m l r a where+      => GMutBranchSum ctor 'True s l r a where     gmbsProj lb (MutSumF r) = readMutVar r >>= \case       L1 x -> gmbcProj lb x       R1 _ -> pure Nothing-    gmbsEmbed _ = fmap MutSumF . newMutVar . L1 . GLP.view (GL.fromIso glist)-                . tupleToList @b @_ @(MapRef m as)+    gmbsEmbed _ = fmap MutSumF . newMutVar . L1+                . GLP.view (GL.fromIso (glist . tupledRef @s @b @as))  instance-      ( PrimMonad m-      , GMutable m l-      , GMutBranchConstructor ctor m r a-      , GIsList (GRef_ m r) (GRef_ m r) (MapRef m as) (MapRef m as)+      ( GMutable s l+      , GMutBranchConstructor ctor s r a+      , GIsList (GRef_ s r) (GRef_ s r) (MapRef s as) (MapRef s as)       , GIsList r r as as       , ListTuple a a as as-      , ListTuple b b (MapRef m as) (MapRef m as)-      , Ref m a ~ b+      , ListRefTuple s b as+      , Ref s a ~ b       )-      => GMutBranchSum ctor 'False m l r a where+      => GMutBranchSum ctor 'False s l r a where     gmbsProj lb (MutSumF r) = readMutVar r >>= \case       L1 _ -> pure Nothing       R1 x -> gmbcProj lb x-    gmbsEmbed _ = fmap MutSumF . newMutVar . R1 . GLP.view (GL.fromIso glist)-                . tupleToList @b @_ @(MapRef m as)+    gmbsEmbed _ = fmap MutSumF . newMutVar . R1+                . GLP.view (GL.fromIso (glist . tupledRef @s @b @as))  -- | Create a 'MutBranch' for any data type with a 'Generic' instance by -- specifying the constructor name using OverloadedLabels@@ -647,41 +659,63 @@ -- -- @ -- -- | 'MutBranch' focusing on the cons case of a list--- consMB :: (PrimMonad m, Mutable m a) => MutBranch m [a] (a, [a])+-- consMB :: (PrimMonad m, Mutable s a) => MutBranch s [a] (a, [a]) -- consMB = 'constrMB' ('CLabel' @":") -- @ constrMB-    :: forall ctor m s a.-     ( Ref m s ~ GRef m s-     , GMutBranchConstructor ctor m (Rep s) a+    :: forall ctor s b a.+     ( Ref s b ~ GRef s b+     , GMutBranchConstructor ctor s (Rep b) a      )     => CLabel ctor-    -> MutBranch m s a+    -> MutBranch s b a constrMB l = MutBranch     { projectBranch = gmbcProj l . unGRef     , embedBranch   = fmap GRef . gmbcEmbed l     }  -- | 'MutBranch' focusing on the nil case of a list-nilMB :: (PrimMonad m, Mutable m a) => MutBranch m [a] ()+nilMB :: Mutable s a => MutBranch s [a] () nilMB = constrMB (CLabel @"[]")  -- | 'MutBranch' focusing on the cons case of a list-consMB :: (PrimMonad m, Mutable m a) => MutBranch m [a] (a, [a])+consMB :: Mutable s a => MutBranch s [a] (a, [a]) consMB = constrMB (CLabel @":")  -- | 'MutBranch' focusing on the 'Nothing' case of a 'Maybe'-nothingMB :: (PrimMonad m, Mutable m a) => MutBranch m (Maybe a) ()+nothingMB :: Mutable s a => MutBranch s (Maybe a) () nothingMB = constrMB #_Nothing  -- | 'MutBranch' focusing on the 'Just' case of a 'Maybe'-justMB :: (PrimMonad m, Mutable m a) => MutBranch m (Maybe a) a+justMB :: Mutable s a => MutBranch s (Maybe a) a justMB = constrMB #_Just  -- | 'MutBranch' focusing on the 'Left' case of an 'Either'-leftMB :: (PrimMonad m, Mutable m a, Mutable m b) => MutBranch m (Either a b) a+leftMB :: (Mutable s a, Mutable s b) => MutBranch s (Either a b) a leftMB = constrMB #_Left  -- | 'MutBranch' focusing on the 'Right' case of an 'Either'-rightMB :: (PrimMonad m, Mutable m a, Mutable m b) => MutBranch m (Either a b) b+rightMB :: (Mutable s a, Mutable s b) => MutBranch s (Either a b) b rightMB = constrMB #_Right++class ListRefTuple (s :: Type) (b :: Type) (as :: [Type]) | as s -> b where+    tupledRef :: GL.Iso' (HList (MapRef s as)) b+    tupledRef = GL.iso (listRefToTuple @s @b @as) (tupleToListRef @s @b @as)+    {-# INLINE tupledRef #-}+    tupleToListRef :: b -> HList (MapRef s as)+    listRefToTuple :: HList (MapRef s as) -> b++instance ListRefTuple s (UnitRef s) '[] where+    tupleToListRef _ = Nil+    listRefToTuple _ = UnitRef+instance (Ref s a ~ ra) => ListRefTuple s ra '[a] where+    tupleToListRef x = x :> Nil+    listRefToTuple (x :> _) = x+instance (Ref s a ~ ra, Ref s b ~ rb) => ListRefTuple s (ra, rb) '[a, b] where+    tupleToListRef (x, y) = x :> y :> Nil+    listRefToTuple (x :> y :> _) = (x, y)+++++

@@ -25,7 +25,8 @@ -- Portability : non-portable -- -- Provides the 'Mutable' typeclass and various helpers.  See--- 'Data.Mutable' for the main "entrypoint".+-- "Data.Mutable" for the main "entrypoint".  Many of the datatypes used+-- for 'Ref' instances are defined in "Data.Mutable.Instances" module Data.Mutable.Class (     Mutable(..)   , copyRefWhole, moveRefWhole, cloneRefWhole@@ -40,8 +41,6 @@   , CoerceMut(..)   , TraverseMut(..)   , Immutable(..)-  -- * Changing underlying monad-  , reMutable, reMutableConstraint   -- * Util   , MapRef   ) where@@ -49,45 +48,60 @@ import           Control.Monad import           Control.Monad.Primitive import           Data.Coerce-import           Data.Constraint-import           Data.Constraint.Unsafe-import           Data.Kind import           Data.Mutable.Instances import           Data.Mutable.Internal import           Data.Primitive.MutVar-import           Data.Proxy-import           Data.Reflection import           GHC.Generics-import qualified Data.Vinyl.XRec         as X+import qualified Data.Vinyl.XRec           as X  -- | Apply a pure function on an immutable value onto a value stored in -- a mutable reference.-modifyRef  :: Mutable m a => Ref m a -> (a -> a) -> m ()+modifyRef+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => Ref s a+    -> (a -> a)+    -> m () modifyRef v f = copyRef v . f =<< freezeRef v {-# INLINE modifyRef #-}  -- | 'modifyRef', but forces the result before storing it back in the -- reference.-modifyRef' :: Mutable m a => Ref m a -> (a -> a) -> m ()+modifyRef'+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => Ref s a+    -> (a -> a)+    -> m () modifyRef' v f = (copyRef v $!) . f =<< freezeRef v {-# INLINE modifyRef' #-}  -- | Apply a monadic function on an immutable value onto a value stored in -- a mutable reference.  Uses 'copyRef' into the reference after the -- action is completed.-modifyRefM  :: Mutable m a => Ref m a -> (a -> m a) -> m ()+modifyRefM+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => Ref s a+    -> (a -> m a)+    -> m () modifyRefM v f = copyRef v =<< f =<< freezeRef v {-# INLINE modifyRefM #-}  -- | 'modifyRefM', but forces the result before storing it back in the -- reference.-modifyRefM' :: Mutable m a => Ref m a -> (a -> m a) -> m ()+modifyRefM'+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => Ref s a+    -> (a -> m a)+    -> m () modifyRefM' v f = (copyRef v $!) =<< f =<< freezeRef v {-# INLINE modifyRefM' #-}  -- | Apply a pure function on an immutable value onto a value stored in -- a mutable reference, returning a result value from that function.-updateRef  :: Mutable m a => Ref m a -> (a -> (a, b)) -> m b+updateRef+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => Ref s a+    -> (a -> (a, b))+    -> m b updateRef v f = do     (x, y) <- f <$> freezeRef v     copyRef v x@@ -95,7 +109,11 @@  -- | 'updateRef', but forces the updated value before storing it back in the -- reference.-updateRef' :: Mutable m a => Ref m a -> (a -> (a, b)) -> m b+updateRef'+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => Ref s a+    -> (a -> (a, b))+    -> m b updateRef' v f = do     (x, y) <- f <$> freezeRef v     x `seq` copyRef v x@@ -104,7 +122,11 @@ -- | Apply a monadic function on an immutable value onto a value stored in -- a mutable reference, returning a result value from that function.  Uses -- 'copyRef' into the reference after the action is completed.-updateRefM  :: Mutable m a => Ref m a -> (a -> m (a, b)) -> m b+updateRefM+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => Ref s a+    -> (a -> m (a, b))+    -> m b updateRefM v f = do     (x, y) <- f =<< freezeRef v     copyRef v x@@ -112,7 +134,11 @@  -- | 'updateRefM', but forces the updated value before storing it back in the -- reference.-updateRefM' :: Mutable m a => Ref m a -> (a -> m (a, b)) -> m b+updateRefM'+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => Ref s a+    -> (a -> m (a, b))+    -> m b updateRefM' v f = do     (x, y) <- f =<< freezeRef v     x `seq` copyRef v x@@ -120,8 +146,8 @@  -- | A default implementation of 'copyRef' using 'thawRef' and 'moveRef'. copyRefWhole-    :: Mutable m a-    => Ref m a          -- ^ destination to overwrite+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => Ref s a          -- ^ destination to overwrite     -> a                -- ^ pure value     -> m () copyRefWhole r v = moveRef r =<< thawRef v@@ -131,9 +157,9 @@ -- pure type, using 'freezeRef' and 'copyRef'.  It freezes the entire source -- and then re-copies it into the destination. moveRefWhole-    :: Mutable m a-    => Ref m a          -- ^ destination-    -> Ref m a          -- ^ source+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => Ref s a          -- ^ destination+    -> Ref s a          -- ^ source     -> m () moveRefWhole r v = copyRef r =<< freezeRef v {-# INLINE moveRefWhole #-}@@ -142,9 +168,9 @@ -- pure type, using 'freezeRef' and 'thawRef'.  It freezes the entire -- source and then re-copies it into the destination. cloneRefWhole-    :: Mutable m a-    => Ref m a-    -> m (Ref m a)+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => Ref s a+    -> m (Ref s a) cloneRefWhole = thawRef <=< freezeRef {-# INLINE cloneRefWhole #-} @@ -176,8 +202,8 @@ -- This can then be auto-derived: -- -- @--- instance Mutable m MyType where---     type Ref m MyType = GRef m MyType+-- instance Mutable s MyType where+--     type Ref s MyType = GRef s MyType -- @ -- -- It can also be used to /override/ a 'Mutable' instance.  For example,@@ -196,8 +222,8 @@     unHKD = VarMut     toHKD = getVarMut -instance PrimMonad m => Mutable m (VarMut a) where-    type Ref m (VarMut a) = MutVar (PrimState m) (VarMut a)+instance Mutable s (VarMut a) where+    type Ref s (VarMut a) = MutVar s (VarMut a)   -- | Similar to 'VarMut', this allows you to overwrite the normal 'Mutable'@@ -217,8 +243,8 @@     unHKD = TraverseMut     toHKD = getTraverseMut -instance (Traversable f, Mutable m a) => Mutable m (TraverseMut f a) where-    type Ref m (TraverseMut f a) = TraverseRef m (TraverseMut f) a+instance (Traversable f, Mutable s a) => Mutable s (TraverseMut f a) where+    type Ref s (TraverseMut f a) = TraverseRef s (TraverseMut f) a  -- | Similar to 'VarMut', this allows you to overwrite the normal 'Mutable' -- instance of a type to utilize a coercible type's 'Mutable' instance@@ -235,8 +261,8 @@ -- 'MV.MVector'), but you don't want to write an orphan instance like -- -- @--- instance Mutable m DoubleVec where---     type 'Ref' m DoubleVec = 'CoerceRef' m DoubleVec (Vector Double)+-- instance Mutable s DoubleVec where+--     type 'Ref' s DoubleVec = 'CoerceRef' s DoubleVec (Vector Double) -- @ -- -- then you can instead use @'CoerceMut' DoubleVec (Vector Double)@ as the@@ -250,8 +276,8 @@     unHKD = CoerceMut     toHKD = getCoerceMut -instance (Mutable m a, Coercible s a) => Mutable m (CoerceMut s a) where-    type Ref m (CoerceMut s a) = CoerceRef m (CoerceMut s a) a+instance (Mutable s a, Coercible s a) => Mutable s (CoerceMut s a) where+    type Ref s (CoerceMut s a) = CoerceRef s (CoerceMut s a) a  -- | Similar to 'VarMut', this allows you to overwrite the normal 'Mutable' -- instance of a type to make it /immutable/.@@ -267,8 +293,8 @@ --     } --   deriving Generic ----- instance Mutable m MyType where---     type Ref m MyType = GRef m MyType+-- instance Mutable s MyType where+--     type Ref s MyType = GRef s MyType -- @ -- -- This basically uses three mutable references: the 'Int', the @'V.Vector'@@ -284,73 +310,21 @@ --     } --   deriving Generic ----- instance Mutable m MyType where---     type Ref m MyType = GRef m MyType+-- instance Mutable s MyType where+--     type Ref s MyType = GRef s MyType -- @ -- -- which has that behavior.  The 'Int' and the 'V.Vector' will be mutable--- within @'Ref' m MyType@, but not the 'String'.-newtype Immutable a = Immutable { getImmutable :: a }+-- within @'Ref' s MyType@, but not the 'String'.+newtype Immutable s a = Immutable { getImmutable :: a }  -- | Use an @'Immutable' a@ as if it were an @a@-instance X.IsoHKD Immutable a where-    type HKD Immutable a = a+instance X.IsoHKD (Immutable s) a where+    type HKD (Immutable s) a = a     unHKD = Immutable     toHKD = getImmutable  -instance Monad m => Mutable m (Immutable a) where-    type Ref m (Immutable a) = ImmutableRef (Immutable a)---newtype ReMutable (s :: Type) m a = ReMutable a-newtype ReMutableTrans m n = RMT { runRMT :: forall x. m x -> n x }--instance (Monad n, Mutable m a, Reifies s (ReMutableTrans m n)) => Mutable n (ReMutable s m a) where-    type Ref n (ReMutable s m a) = ReMutable s m (Ref m a)-    thawRef (ReMutable x) = runRMT rmt $ ReMutable <$> thawRef @m @a x-      where-        rmt = reflect (Proxy @s)-    freezeRef (ReMutable v) = runRMT rmt $ ReMutable <$> freezeRef @m @a v-      where-        rmt = reflect (Proxy @s)-    copyRef (ReMutable x) (ReMutable v) = runRMT rmt $ copyRef @m @a x v-      where-        rmt = reflect (Proxy @s)-    moveRef (ReMutable x) (ReMutable v) = runRMT rmt $ moveRef @m @a x v-      where-        rmt = reflect (Proxy @s)-    cloneRef (ReMutable x) = runRMT rmt $ ReMutable <$> cloneRef @m @a x-      where-        rmt = reflect (Proxy @s)-    unsafeThawRef (ReMutable x) = runRMT rmt $ ReMutable <$> unsafeThawRef @m @a x-      where-        rmt = reflect (Proxy @s)-    unsafeFreezeRef (ReMutable v) = runRMT rmt $ ReMutable <$> unsafeFreezeRef @m @a v-      where-        rmt = reflect (Proxy @s)--unsafeReMutable :: forall s m n a. Mutable n (ReMutable s m a) :- Mutable n a-unsafeReMutable = unsafeCoerceConstraint---- | If you can provice a natural transformation from @m@ to @n@, you--- should be able to use a value as if it had @'Mutable' n a@ if you have--- @'Mutable' m a@.-reMutable-    :: forall m n a r. (Mutable m a, Monad n)-    => (forall x. m x -> n x)-    -> (Mutable n a => r)-    -> r-reMutable f x = x \\ reMutableConstraint @m @n @a f---- | If you can provice a natural transformation from @m@ to @n@, then--- @'Mutable' m a@ should also imply @'Mutable' n a@.-reMutableConstraint-    :: forall m n a. (Mutable m a, Monad n)-    => (forall x. m x -> n x)-    -> Mutable m a :- Mutable n a-reMutableConstraint f = reify (RMT f) $ \(Proxy :: Proxy s) ->-    case unsafeReMutable @s @m @n @a of-      Sub Data.Constraint.Dict -> Sub Data.Constraint.Dict-+instance Mutable s (Immutable s a) where+    type Ref s (Immutable s a) = ImmutableRef s (Immutable s a) 

@@ -1,16 +1,19 @@-{-# LANGUAGE BangPatterns          #-}-{-# LANGUAGE EmptyCase             #-}-{-# LANGUAGE FlexibleContexts      #-}-{-# LANGUAGE FlexibleInstances     #-}-{-# LANGUAGE GADTs                 #-}-{-# LANGUAGE LambdaCase            #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE StandaloneDeriving    #-}-{-# LANGUAGE TypeFamilies          #-}-{-# LANGUAGE TypeInType            #-}-{-# LANGUAGE TypeOperators         #-}-{-# LANGUAGE UndecidableInstances  #-}-{-# OPTIONS_GHC -fno-warn-orphans  #-}+{-# LANGUAGE BangPatterns           #-}+{-# LANGUAGE DeriveFoldable         #-}+{-# LANGUAGE DeriveTraversable      #-}+{-# LANGUAGE EmptyCase              #-}+{-# LANGUAGE EmptyDataDeriving      #-}+{-# LANGUAGE FlexibleContexts       #-}+{-# LANGUAGE FlexibleInstances      #-}+{-# LANGUAGE GADTs                  #-}+{-# LANGUAGE LambdaCase             #-}+{-# LANGUAGE MultiParamTypeClasses  #-}+{-# LANGUAGE StandaloneDeriving     #-}+{-# LANGUAGE TypeFamilies           #-}+{-# LANGUAGE TypeInType             #-}+{-# LANGUAGE TypeOperators          #-}+{-# LANGUAGE UndecidableInstances   #-}+{-# OPTIONS_GHC -fno-warn-orphans   #-}  -- | -- Module      : Data.Mutable.Instances@@ -21,11 +24,14 @@ -- Stability   : experimental -- Portability : non-portable ----- Provides 'Ref' instances for various data types, as well as automatic--- derivation of instances.  See "Data.Mutable" for more information.+-- Exports 'Ref' data types for various common data types, and also the+-- tools for automatic derivation of instances.  See "Data.Mutable" for+-- more information. module Data.Mutable.Instances (     RecRef(..)   , HListRef(..)+  , UnitRef(..)+  , VoidRef   -- * Generic   , GRef(..)   , gThawRef, gFreezeRef@@ -56,7 +62,6 @@   ) where  import           Control.Applicative-import           Control.Monad.Primitive import           Data.Complex import           Data.Functor.Compose import           Data.Functor.Identity@@ -93,93 +98,93 @@ import qualified Data.Vinyl.Functor                        as V import qualified Data.Vinyl.TypeLevel                      as V -instance PrimMonad m => Mutable m Int-instance PrimMonad m => Mutable m Integer-instance PrimMonad m => Mutable m Natural-instance PrimMonad m => Mutable m (Ratio a)-instance PrimMonad m => Mutable m Float-instance PrimMonad m => Mutable m Double-instance PrimMonad m => Mutable m (Complex a)-instance PrimMonad m => Mutable m Bool-instance PrimMonad m => Mutable m Char+instance Mutable s Int+instance Mutable s Integer+instance Mutable s Natural+instance Mutable s (Ratio a)+instance Mutable s Float+instance Mutable s Double+instance Mutable s (Complex a)+instance Mutable s Bool+instance Mutable s Char -instance PrimMonad m => Mutable m Word-instance PrimMonad m => Mutable m Word8-instance PrimMonad m => Mutable m Word16-instance PrimMonad m => Mutable m Word64+instance Mutable s Word+instance Mutable s Word8+instance Mutable s Word16+instance Mutable s Word64 -instance PrimMonad m => Mutable m CChar-instance PrimMonad m => Mutable m CSChar-instance PrimMonad m => Mutable m CUChar-instance PrimMonad m => Mutable m CShort-instance PrimMonad m => Mutable m CUShort-instance PrimMonad m => Mutable m CInt-instance PrimMonad m => Mutable m CUInt-instance PrimMonad m => Mutable m CLong-instance PrimMonad m => Mutable m CULong-instance PrimMonad m => Mutable m CPtrdiff-instance PrimMonad m => Mutable m CSize-instance PrimMonad m => Mutable m CWchar-instance PrimMonad m => Mutable m CSigAtomic-instance PrimMonad m => Mutable m CLLong-instance PrimMonad m => Mutable m CULLong-instance PrimMonad m => Mutable m CBool-instance PrimMonad m => Mutable m CIntPtr-instance PrimMonad m => Mutable m CUIntPtr-instance PrimMonad m => Mutable m CIntMax-instance PrimMonad m => Mutable m CUIntMax-instance PrimMonad m => Mutable m CClock-instance PrimMonad m => Mutable m CTime-instance PrimMonad m => Mutable m CUSeconds-instance PrimMonad m => Mutable m CSUSeconds-instance PrimMonad m => Mutable m CFloat-instance PrimMonad m => Mutable m CDouble+instance Mutable s CChar+instance Mutable s CSChar+instance Mutable s CUChar+instance Mutable s CShort+instance Mutable s CUShort+instance Mutable s CInt+instance Mutable s CUInt+instance Mutable s CLong+instance Mutable s CULong+instance Mutable s CPtrdiff+instance Mutable s CSize+instance Mutable s CWchar+instance Mutable s CSigAtomic+instance Mutable s CLLong+instance Mutable s CULLong+instance Mutable s CBool+instance Mutable s CIntPtr+instance Mutable s CUIntPtr+instance Mutable s CIntMax+instance Mutable s CUIntMax+instance Mutable s CClock+instance Mutable s CTime+instance Mutable s CUSeconds+instance Mutable s CSUSeconds+instance Mutable s CFloat+instance Mutable s CDouble -instance Mutable m a => Mutable m (Identity a) where-    type Ref m (Identity a) = CoerceRef m (Identity a) a+instance Mutable s a => Mutable s (Identity a) where+    type Ref s (Identity a) = CoerceRef s (Identity a) a -instance Mutable m a => Mutable m (Const a b) where-    type Ref m (Const a b) = CoerceRef m (Const a b) a+instance Mutable s a => Mutable s (Const a b) where+    type Ref s (Const a b) = CoerceRef s (Const a b) a -instance Mutable m a => Mutable m (V.Const a b) where-    type Ref m (V.Const a b) = CoerceRef m (V.Const a b) a+instance Mutable s a => Mutable s (V.Const a b) where+    type Ref s (V.Const a b) = CoerceRef s (V.Const a b) a -instance Mutable m a => Mutable m (M.Product a) where-    type Ref m (M.Product a) = CoerceRef m (M.Product a) a+instance Mutable s a => Mutable s (M.Product a) where+    type Ref s (M.Product a) = CoerceRef s (M.Product a) a -instance Mutable m a => Mutable m (M.Sum a) where-    type Ref m (M.Sum a) = CoerceRef m (M.Sum a) a+instance Mutable s a => Mutable s (M.Sum a) where+    type Ref s (M.Sum a) = CoerceRef s (M.Sum a) a -instance Mutable m a => Mutable m (Down a) where-    type Ref m (Down a) = CoerceRef m (Down a) a+instance Mutable s a => Mutable s (Down a) where+    type Ref s (Down a) = CoerceRef s (Down a) a -instance Mutable m a => Mutable m (M.Dual a) where-    type Ref m (M.Dual a) = CoerceRef m (M.Dual a) a+instance Mutable s a => Mutable s (M.Dual a) where+    type Ref s (M.Dual a) = CoerceRef s (M.Dual a) a -instance (Mutable m a, PrimMonad m) => Mutable m (Maybe a) where-    type Ref m (Maybe a) = GRef m (Maybe a)+instance Mutable s a => Mutable s (Maybe a) where+    type Ref s (Maybe a) = GRef s (Maybe a) -instance (Mutable m a, Mutable m b, PrimMonad m) => Mutable m (Either a b) where-    type Ref m (Either a b) = GRef m (Either a b)+instance (Mutable s a, Mutable s b) => Mutable s (Either a b) where+    type Ref s (Either a b) = GRef s (Either a b) -instance (Mutable m (f a), Mutable m (g a)) => Mutable m (Product f g a) where-    type Ref m (Product f g a) = GRef m (Product f g a)+instance (Mutable s (f a), Mutable s (g a)) => Mutable s (Product f g a) where+    type Ref s (Product f g a) = GRef s (Product f g a) -instance (Mutable m (f a), Mutable m (g a), PrimMonad m) => Mutable m (Sum f g a) where-    type Ref m (Sum f g a) = GRef m (Sum f g a)+instance (Mutable s (f a), Mutable s (g a)) => Mutable s (Sum f g a) where+    type Ref s (Sum f g a) = GRef s (Sum f g a) -instance (Mutable m (f (g a))) => Mutable m (Compose f g a) where-    type Ref m (Compose f g a) = CoerceRef m (Compose f g a) (f (g a))+instance (Mutable s (f (g a))) => Mutable s (Compose f g a) where+    type Ref s (Compose f g a) = CoerceRef s (Compose f g a) (f (g a))  -- | Mutable linked list with mutable references in each cell.  See -- 'Data.Mutable.MutBranch' documentation for an example of using this as -- a mutable linked list.l-instance (PrimMonad m, Mutable m a) => Mutable m [a] where-    type Ref m [a] = GRef m [a]+instance Mutable s a => Mutable s [a] where+    type Ref s [a] = GRef s [a]  -- | Meant for usage with higher-kinded data pattern (See 'X.HKD')-instance Mutable m a => Mutable m (V.Identity a) where-    type Ref m (V.Identity a) = RefFor m a+instance Mutable s a => Mutable s (V.Identity a) where+    type Ref s (V.Identity a) = RefFor s a     thawRef (V.Identity x) = RefFor <$> thawRef x     freezeRef (RefFor r) = V.Identity <$> freezeRef r     copyRef (RefFor r) (V.Identity x) = copyRef r x@@ -189,8 +194,8 @@     unsafeFreezeRef (RefFor r) = V.Identity <$> unsafeFreezeRef r  -- | Mutable reference is 'MV.MVector'.-instance PrimMonad m => Mutable m (V.Vector a) where-    type Ref m (V.Vector a) = MV.MVector (PrimState m) a+instance Mutable s (V.Vector a) where+    type Ref s (V.Vector a) = MV.MVector s a     thawRef         = VG.thaw     freezeRef       = VG.freeze     copyRef         = VG.copy@@ -200,8 +205,8 @@     unsafeFreezeRef = VG.unsafeFreeze  -- | Mutable reference is 'MVS.MVector'.-instance (PrimMonad m, Storable a) => Mutable m (VS.Vector a) where-    type Ref m (VS.Vector a) = MVS.MVector (PrimState m) a+instance Storable a => Mutable s (VS.Vector a) where+    type Ref s (VS.Vector a) = MVS.MVector s a     thawRef         = VG.thaw     freezeRef       = VG.freeze     copyRef         = VG.copy@@ -211,8 +216,8 @@     unsafeFreezeRef = VG.unsafeFreeze  -- | Mutable reference is 'MVU.MVector'.-instance (PrimMonad m, VU.Unbox a) => Mutable m (VU.Vector a) where-    type Ref m (VU.Vector a) = MVU.MVector (PrimState m) a+instance VU.Unbox a => Mutable s (VU.Vector a) where+    type Ref s (VU.Vector a) = MVU.MVector s a     thawRef         = VG.thaw     freezeRef       = VG.freeze     copyRef         = VG.copy@@ -222,8 +227,8 @@     unsafeFreezeRef = VG.unsafeFreeze  -- | Mutable reference is 'MVP.MVector'.-instance (PrimMonad m, Prim a) => Mutable m (VP.Vector a) where-    type Ref m (VP.Vector a) = MVP.MVector (PrimState m) a+instance Prim a => Mutable s (VP.Vector a) where+    type Ref s (VP.Vector a) = MVP.MVector s a     thawRef         = VG.thaw     freezeRef       = VG.freeze     copyRef         = VG.copy@@ -232,8 +237,8 @@     unsafeThawRef   = VG.unsafeThaw     unsafeFreezeRef = VG.unsafeFreeze -instance PrimMonad m => Mutable m (Array a) where-    type Ref m (Array a) = MutableArray (PrimState m) a+instance Mutable s (Array a) where+    type Ref s (Array a) = MutableArray s a      thawRef xs = thawArray xs 0 (sizeofArray xs)     freezeRef rs = freezeArray rs 0 (sizeofMutableArray rs)@@ -247,8 +252,8 @@     unsafeThawRef   = unsafeThawArray     unsafeFreezeRef = unsafeFreezeArray -instance PrimMonad m => Mutable m (SmallArray a) where-    type Ref m (SmallArray a) = SmallMutableArray (PrimState m) a+instance Mutable s (SmallArray a) where+    type Ref s (SmallArray a) = SmallMutableArray s a      thawRef xs = thawSmallArray xs 0 (sizeofSmallArray xs)     freezeRef rs = freezeSmallArray rs 0 (sizeofSmallMutableArray rs)@@ -262,8 +267,8 @@     unsafeThawRef   = unsafeThawSmallArray     unsafeFreezeRef = unsafeFreezeSmallArray -instance PrimMonad m => Mutable m ByteArray where-    type Ref m ByteArray = MutableByteArray (PrimState m)+instance Mutable s ByteArray where+    type Ref s ByteArray = MutableByteArray s      thawRef xs = do         rs <- newByteArray (sizeofByteArray xs)@@ -286,8 +291,8 @@     unsafeThawRef   = unsafeThawByteArray     unsafeFreezeRef = unsafeFreezeByteArray -instance (PrimMonad m, Prim a) => Mutable m (PrimArray a) where-    type Ref m (PrimArray a) = MutablePrimArray (PrimState m) a+instance Prim a => Mutable s (PrimArray a) where+    type Ref s (PrimArray a) = MutablePrimArray s a      thawRef xs = do         rs <- newPrimArray (sizeofPrimArray xs)@@ -311,10 +316,11 @@     unsafeFreezeRef = unsafeFreezePrimArray  -    +data VoidRef s+  deriving (Show, Read, Eq, Ord, Functor, Traversable, Foldable) -instance Monad m => Mutable m Void where-    type Ref m Void = Void+instance Mutable s Void where+    type Ref s Void = VoidRef s     thawRef         = \case {}     freezeRef       = \case {}     copyRef         = \case {}@@ -323,23 +329,34 @@     unsafeThawRef   = \case {}     unsafeFreezeRef = \case {} -instance Monad m => Mutable m () where-    type Ref m () = ()-    thawRef   _       = pure ()+data UnitRef s = UnitRef+  deriving (Show, Read, Eq, Ord, Functor, Traversable, Foldable)++instance Applicative UnitRef where+    pure _  = UnitRef+    _ <*> _ = UnitRef++instance Monad UnitRef where+    return   = pure+    _ >>= _ = UnitRef++instance Mutable s () where+    type Ref s () = UnitRef s+    thawRef   _       = pure UnitRef     freezeRef _       = pure ()     copyRef _ _       = pure ()     moveRef _ _       = pure ()-    cloneRef _        = pure ()-    unsafeThawRef _   = pure ()+    cloneRef _        = pure UnitRef+    unsafeThawRef _   = pure UnitRef     unsafeFreezeRef _ = pure ()  -- | A 'Ref' of a tuple is a tuple of 'Ref's, for easy accessing. -- -- @--- Ref m (Int, 'V.Vector' Double) = ('Data.Primitive.MutVar.MutVar' s Int, 'MV.MVector' s Double)+-- Ref s (Int, 'V.Vector' Double) = ('Data.Primitive.MutVar.MutVar' s Int, 'MV.MVector' s Double) -- @-instance (Monad m, Mutable m a, Mutable m b) => Mutable m (a, b) where-    type Ref m (a, b) = (Ref m a, Ref m b)+instance (Mutable s a, Mutable s b) => Mutable s (a, b) where+    type Ref s (a, b) = (Ref s a, Ref s b)     thawRef   (!x, !y) = (,) <$> thawRef x   <*> thawRef y     freezeRef (u , v ) = (,) <$> freezeRef u <*> freezeRef v     copyRef   (u , v ) (!x, !y) = copyRef u x *> copyRef v y@@ -349,8 +366,8 @@     unsafeFreezeRef (u , v ) = (,) <$> unsafeFreezeRef u <*> unsafeFreezeRef v  -- | A 'Ref' of a tuple is a tuple of 'Ref's, for easy accessing.-instance (Monad m, Mutable m a, Mutable m b, Mutable m c) => Mutable m (a, b, c) where-    type Ref m (a, b, c) = (Ref m a, Ref m b, Ref m c)+instance (Mutable s a, Mutable s b, Mutable s c) => Mutable s (a, b, c) where+    type Ref s (a, b, c) = (Ref s a, Ref s b, Ref s c)     thawRef   (!x, !y, !z) = (,,) <$> thawRef x   <*> thawRef y   <*> thawRef z     freezeRef (u , v , w ) = (,,) <$> freezeRef u <*> freezeRef v <*> freezeRef w     copyRef   (u , v , w ) (!x, !y, !z) = copyRef u x *> copyRef v y *> copyRef w z@@ -360,8 +377,8 @@     unsafeFreezeRef (u , v , w ) = (,,) <$> unsafeFreezeRef u <*> unsafeFreezeRef v <*> unsafeFreezeRef w  -- | A 'Ref' of a tuple is a tuple of 'Ref's, for easy accessing.-instance (Monad m, Mutable m a, Mutable m b, Mutable m c, Mutable m d) => Mutable m (a, b, c, d) where-    type Ref m (a, b, c, d) = (Ref m a, Ref m b, Ref m c, Ref m d)+instance (Mutable s a, Mutable s b, Mutable s c, Mutable s d) => Mutable s (a, b, c, d) where+    type Ref s (a, b, c, d) = (Ref s a, Ref s b, Ref s c, Ref s d)     thawRef   (!x, !y, !z, !a) = (,,,) <$> thawRef x   <*> thawRef y   <*> thawRef z   <*> thawRef a     freezeRef (u , v , w , j ) = (,,,) <$> freezeRef u <*> freezeRef v <*> freezeRef w <*> freezeRef j     copyRef   (u , v , w , j ) (!x, !y, !z, !a) = copyRef u x *> copyRef v y *> copyRef w z *> copyRef j a@@ -371,8 +388,8 @@     unsafeFreezeRef (u , v , w , j ) = (,,,) <$> unsafeFreezeRef u <*> unsafeFreezeRef v <*> unsafeFreezeRef w <*> unsafeFreezeRef j  -- | A 'Ref' of a tuple is a tuple of 'Ref's, for easy accessing.-instance (Monad m, Mutable m a, Mutable m b, Mutable m c, Mutable m d, Mutable m e) => Mutable m (a, b, c, d, e) where-    type Ref m (a, b, c, d, e) = (Ref m a, Ref m b, Ref m c, Ref m d, Ref m e)+instance (Mutable s a, Mutable s b, Mutable s c, Mutable s d, Mutable s e) => Mutable s (a, b, c, d, e) where+    type Ref s (a, b, c, d, e) = (Ref s a, Ref s b, Ref s c, Ref s d, Ref s e)     thawRef   (!x, !y, !z, !a, !b) = (,,,,) <$> thawRef x   <*> thawRef y   <*> thawRef z   <*> thawRef a   <*> thawRef b     freezeRef (u , v , w , j , k ) = (,,,,) <$> freezeRef u <*> freezeRef v <*> freezeRef w <*> freezeRef j <*> freezeRef k     copyRef   (u , v , w , j , k ) (!x, !y, !z, !a, !b) = copyRef u x *> copyRef v y *> copyRef w z *> copyRef j a *> copyRef k b@@ -382,13 +399,13 @@     unsafeFreezeRef (u , v , w , j , k ) = (,,,,) <$> unsafeFreezeRef u <*> unsafeFreezeRef v <*> unsafeFreezeRef w <*> unsafeFreezeRef j <*> unsafeFreezeRef k  -- | 'Ref' for components in a vinyl 'Rec'.-newtype RecRef m f a = RecRef { getRecRef :: Ref m (f a) }+newtype RecRef s f a = RecRef { getRecRef :: Ref s (f a) } -deriving instance Eq (Ref m (f a)) => Eq (RecRef m f a)-deriving instance Ord (Ref m (f a)) => Ord (RecRef m f a)+deriving instance Eq (Ref s (f a)) => Eq (RecRef s f a)+deriving instance Ord (Ref s (f a)) => Ord (RecRef s f a) -instance Monad m => Mutable m (Rec f '[]) where-    type Ref m (Rec f '[]) = Rec (RecRef m f) '[]+instance Mutable s (Rec f '[]) where+    type Ref s (Rec f '[]) = Rec (RecRef s f) '[]     thawRef   _       = pure RNil     freezeRef _       = pure RNil     copyRef _ _       = pure ()@@ -397,8 +414,11 @@     unsafeThawRef _   = pure RNil     unsafeFreezeRef _ = pure RNil -instance (Monad m, Mutable m (f a), Mutable m (Rec f as), Ref m (Rec f as) ~ Rec (RecRef m f) as) => Mutable m (Rec f (a ': as)) where-    type Ref m (Rec f (a ': as)) = Rec (RecRef m f) (a ': as)+instance ( Mutable s (f a)+         , Mutable s (Rec f as)+         , Ref s (Rec f as) ~ Rec (RecRef s f) as+         ) => Mutable s (Rec f (a ': as)) where+    type Ref s (Rec f (a ': as)) = Rec (RecRef s f) (a ': as)     thawRef   = \case       x :& xs -> (:&) <$> (RecRef <$> thawRef x) <*> thawRef xs     freezeRef = \case@@ -418,8 +438,13 @@       RecRef v :& vs -> (:&) <$> unsafeFreezeRef v <*> unsafeFreezeRef vs  -instance (Monad m, RecApplicative as, V.NatToInt (V.RLength as), RPureConstrained (V.IndexableField as) as, Mutable m (Rec f as), Ref m (Rec f as) ~ Rec (RecRef m f) as) => Mutable m (ARec f as) where-    type Ref m (ARec f as) = ARec (RecRef m f) as+instance ( RecApplicative as+         , V.NatToInt (V.RLength as)+         , RPureConstrained (V.IndexableField as) as+         , Mutable s (Rec f as)+         , Ref s (Rec f as) ~ Rec (RecRef s f) as+         ) => Mutable s (ARec f as) where+    type Ref s (ARec f as) = ARec (RecRef s f) as      thawRef         = fmap toARec . thawRef   . fromARec     freezeRef       = fmap toARec . freezeRef . fromARec@@ -435,18 +460,18 @@ -- ghci> :kind! MapRef IO '[Int, V.Vector Double] -- '[ MutVar RealWorld Int, MVector RealWorld Double ] -- @-type family MapRef m as where-    MapRef m '[] = '[]-    MapRef m (a ': as) = Ref m a ': MapRef m as+type family MapRef s as where+    MapRef s '[] = '[]+    MapRef s (a ': as) = Ref s a ': MapRef s as  -- | The mutable reference of the 'HList' type from generic-lens.-data HListRef :: (Type -> Type) -> [Type] -> Type where-    NilRef :: HListRef m '[]-    (:!>)  :: Ref m a -> HListRef m as -> HListRef m (a ': as)+data HListRef :: Type -> [Type] -> Type where+    NilRef :: HListRef s '[]+    (:!>)  :: Ref s a -> HListRef s as -> HListRef s (a ': as) infixr 5 :!> -instance Monad m => Mutable m (HList '[]) where-    type Ref m (HList '[]) = HListRef m '[]+instance Mutable s (HList '[]) where+    type Ref s (HList '[]) = HListRef s '[]     thawRef   _       = pure NilRef     freezeRef _       = pure Nil     copyRef _ _       = pure ()@@ -455,8 +480,8 @@     unsafeThawRef _   = pure NilRef     unsafeFreezeRef _ = pure Nil -instance (Monad m, Mutable m a, Mutable m (HList as), Ref m (HList as) ~ HListRef m as) => Mutable m (HList (a ': as)) where-    type Ref m (HList (a ': as)) = HListRef m (a ': as)+instance (Mutable s a, Mutable s (HList as), Ref s (HList as) ~ HListRef s as) => Mutable s (HList (a ': as)) where+    type Ref s (HList (a ': as)) = HListRef s (a ': as)     thawRef   = \case       x :> xs -> (:!>) <$> thawRef x <*> thawRef xs     freezeRef = \case

@@ -1,3 +1,4 @@+{-# LANGUAGE AllowAmbiguousTypes    #-} {-# LANGUAGE DefaultSignatures      #-} {-# LANGUAGE EmptyCase              #-} {-# LANGUAGE FlexibleContexts       #-}@@ -59,10 +60,11 @@ 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@.+-- | An instance of @'Mutable' s a@ means that @a@ can be stored+-- a mutable reference in a 'PrimMonad' @m@ (where @s@ is the mutable state+-- token 'PrimState' of that monad). ----- The associated type @'Ref' m a@ links any @a@ to the type of its+-- The associated type @'Ref' s a@ links any @a@ to the type of its -- canonical mutable version. -- -- The /benefit/ of this typeclass, instead of just using@@ -80,7 +82,7 @@ --     instance -- --     @---     instance (Mutable m a, Mutable m b) => Mutable m (a, b)+--     instance (Mutable s a, Mutable s b) => Mutable s (a, b) --     @ -- --     If @a@ and @b@ are piecwise-mutable, then the instance here will@@ -101,18 +103,18 @@ --     } --   deriving Generic ----- instance Mutable m TwoVectors where---     type Ref m TwoVectors = 'GRef' m TwoVectors+-- instance Mutable s TwoVectors where+--     type Ref s TwoVectors = 'GRef' s TwoVectors -- @ -- -- Then now we get: -- -- @--- 'thawRef'   :: TwoVectors -> m ('GRef' m TwoVectors)--- 'freezeRef' :: 'GRef' m TwoVectors -> m TwoVectors+-- 'thawRef'   :: TwoVectors -> m ('GRef' s TwoVectors)+-- 'freezeRef' :: 'GRef' s TwoVectors -> m TwoVectors -- @ ----- And @'GRef' m TwoVectors@ is now a piecewise-mutable reference storing each+-- And @'GRef' s 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@@ -132,7 +134,7 @@ --   deriving Generic -- -- instance Mutable (TwoVectors 'Identity') where---     type Ref (TwoVectors 'Identity') = TwoVectors ('RefFor' m)+--     type Ref (TwoVectors 'Identity') = TwoVectors ('RefFor' s) -- @ -- -- And now your mutable ref is literally going to be a product of the@@ -141,11 +143,11 @@ -- @ -- ghci> tvr@(TV is ds) <- thawRef (TV xs ys) -- ghci> :t tvr--- TV ('RefFor' IO)+-- TV ('RefFor' 'RealWorld') -- ghci> :t is -- 'MV.MVector' RealWorld Int -- ghci> :t ds--- 'MV.MVector' RealWorld Double+-- MV.MVector RealWorld Double -- @ -- -- So 'thawRef' will actually just get you the same record type but with@@ -161,14 +163,14 @@ -- -- of the underlying type -- newtype MyType = MT (Vector Double) ----- type Ref m MyType = CoerceRef m MyType (Vector Double)+-- type Ref s MyType = CoerceRef s 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+-- type Ref s (MyContainer a) = TraverseRef s MyContainer a -- @ -- -- See <https://mutable.jle.im/02-mutable-and-ref.html> for more@@ -179,14 +181,14 @@ --    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+class Mutable s 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+    -- type Ref s ('V.Vector' a) = 'MV.MVector' s a     -- @     --     -- This means that using 'thawRef' on a 'V.Vector' will give you an@@ -195,24 +197,24 @@     --     -- @     -- 'thawRef'-    --     :: ('PrimMonad' m, s ~ 'PrimState' m)+    --     :: ('PrimMonad' m, 'PrimState' m ~ s)     --     => 'V.Vector' a     --     -> m ('MV.Vector' s a)     --     -- 'freezeRef'-    --     :: ('PrimMonad' m, s ~ 'PrimState' m)+    --     :: ('PrimMonad' m, 'PrimState' m ~ s)     --     => 'MV.Vector' s a     --     -> m ('V.Vector' a)     --     -- 'copyRef'-    --     :: ('PrimMonad' m, s ~ 'PrimState' m)+    --     :: ('PrimMonad' m, 'PrimState' m ~ s)     --     => '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+    -- have the same @'Ref' s 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'.     --@@ -229,7 +231,7 @@     -- @     -- -- Works for all 'Generic' instances, preserves piecewise mutation     -- -- for products-    -- type Ref m a = 'GRef' m a+    -- type Ref s a = 'GRef' s a     -- @     --     -- If you just set up a blank instance, the implementations of@@ -240,25 +242,25 @@     -- data MyType     --     -- -- The default setup is OK-    -- instance Mutable m MyType+    -- instance Mutable s MyType     --     -- -- This is equivalent to the above-    -- instance Mutable m MyType-    --     type Ref m MyType = 'MutVar' ('PrimState' m) MyType+    -- instance Mutable s MyType+    --     type Ref s MyType = 'MutVar' s 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+    -- instance Mutable s MyType where+    --     type Ref s MyType = 'GRef' s 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+    type Ref s a = (v :: Type) | v -> a s+    type Ref s a = MutVar s a      -- | "Thaw" a pure/persistent value into its mutable version, which can     -- be manipulated using 'Data.Mutable.modifyRef' or other methods@@ -268,7 +270,7 @@     --     -- @     -- 'thawRef'-    --     :: ('PrimMonad' m, s ~ 'PrimState' m)+    --     :: ('PrimMonad' m, 'PrimState' m ~ s)     --     => 'V.Vector' a     --     -> m ('MV.Vector' s a)     -- @@@ -276,7 +278,7 @@     -- 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)+    thawRef   :: (PrimMonad m, PrimState m ~ s) => a -> m (Ref s a)      -- | "Freeze" a mutable value into its pure/persistent version.     --@@ -287,7 +289,7 @@     --     -- @     -- 'freezeRef'-    --     :: ('PrimMonad' m, s ~ 'PrimState' m)+    --     :: ('PrimMonad' m, 'PrimState' m ~ s)     --     => 'MV.Vector' s a     --     -> m ('V.Vector' a)     -- @@@ -295,7 +297,7 @@     -- 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+    freezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s a -> m a      -- | Overwrite a mutable value by provivding a pure/persistent value.     -- 'copyRef'@@ -304,7 +306,7 @@     --     -- @     -- 'copyRef'-    --     :: ('PrimMonad' m, s ~ 'PrimState' m)+    --     :: ('PrimMonad' m, 'PrimState' m ~ s)     --     => 'MV.Vector' s a     --     -> 'V.Vector' a     --     -> m ()@@ -318,7 +320,8 @@     -- function, like 'Data.IORef.writeIORef' / 'Data.STRef.writeSTRef'     -- / 'writeMutVar' etc.     copyRef-        :: Ref m a      -- ^ destination to overwrite+        :: (PrimMonad m, PrimState m ~ s)+        => Ref s a      -- ^ destination to overwrite         -> a            -- ^ value         -> m () @@ -330,8 +333,9 @@     -- because the copying is done piecewise, so the intermediate pure value     -- is never created.     moveRef-        :: Ref m a      -- ^ destination-        -> Ref m a      -- ^ source+        :: (PrimMonad m, PrimState m ~ s)+        => Ref s a      -- ^ destination+        -> Ref s a      -- ^ source         -> m ()      -- | Create a deep copy of a mutable reference, allocated to a separate@@ -341,7 +345,7 @@     -- 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)+    cloneRef :: (PrimMonad m, PrimState m ~ s) => Ref s a -> m (Ref s a)      -- this is nice but you can't write an instance for 'TraverseRef' on     -- this, so maybe not.@@ -350,7 +354,7 @@     -- -- 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)+    -- initRef :: m (Ref s a)      -- | A non-copying version of 'thawRef' that can be more efficient for     -- types where the mutable representation is the same as the immutable@@ -358,7 +362,7 @@     --     -- 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)+    unsafeThawRef   :: (PrimMonad m, PrimState m ~ s) => a -> m (Ref s a)      -- | A non-copying version of 'freezeRef' that can be more efficient for     -- types where the mutable representation is the same as the immutable@@ -367,21 +371,21 @@     -- 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+    unsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => Ref s a -> m a -    default thawRef :: DefaultMutable m a (Ref m a) => a -> m (Ref m a)+    default thawRef :: (DefaultMutable s a (Ref s a), PrimMonad m, PrimState m ~ s) => a -> m (Ref s a)     thawRef   = defaultThawRef-    default freezeRef :: DefaultMutable m a (Ref m a) => Ref m a -> m a+    default freezeRef :: (DefaultMutable s a (Ref s a), PrimMonad m, PrimState m ~ s) => Ref s a -> m a     freezeRef = defaultFreezeRef-    default copyRef :: DefaultMutable m a (Ref m a) => Ref m a -> a -> m ()+    default copyRef :: (DefaultMutable s a (Ref s a), PrimMonad m, PrimState m ~ s) => Ref s a -> a -> m ()     copyRef   = defaultCopyRef-    default moveRef :: DefaultMutable m a (Ref m a) => Ref m a -> Ref m a -> m ()+    default moveRef :: (DefaultMutable s a (Ref s a), PrimMonad m, PrimState m ~ s) => Ref s a -> Ref s a -> m ()     moveRef   = defaultMoveRef-    default cloneRef :: DefaultMutable m a (Ref m a) => Ref m a -> m (Ref m a)+    default cloneRef :: (DefaultMutable s a (Ref s a), PrimMonad m, PrimState m ~ s) => Ref s a -> m (Ref s a)     cloneRef  = defaultCloneRef-    default unsafeThawRef :: DefaultMutable m a (Ref m a) => a -> m (Ref m a)+    default unsafeThawRef :: (DefaultMutable s a (Ref s a), PrimMonad m, PrimState m ~ s) => a -> m (Ref s a)     unsafeThawRef   = defaultUnsafeThawRef-    default unsafeFreezeRef :: DefaultMutable m a (Ref m a) => Ref m a -> m a+    default unsafeFreezeRef :: (DefaultMutable s a (Ref s a), PrimMonad m, PrimState m ~ s) => Ref s a -> m a     unsafeFreezeRef = defaultUnsafeFreezeRef  -- | The default implementations of 'thawRef', 'freezeRef', and 'copyRef'@@ -394,26 +398,26 @@ -- -- @ -- -- default, if you don't specify 'Ref'--- instance Mutable m MyType+-- instance Mutable s MyType -- -- -- the above is the same as:--- instance Mutable m MyType---     type Ref m MyType = MutVar (PrimState m) MyType+-- instance Mutable s MyType+--     type Ref s MyType = MutVar s) MyType -- @ -- -- The case for any instance of 'Generic': -- -- @--- instance Mutable m MyType---     type Ref m MyType = GRef m MyType+-- instance Mutable s MyType+--     type Ref s MyType = GRef s 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)+-- instance Mutable s (MyTypeF Identity)+--     type Ref s (MyTypeF Identity) = MyTypeF (RefFor s) -- @ -- -- The case for any newtype wrapper:@@ -421,8 +425,8 @@ -- @ -- newtype MyType = MT (Vector Double) ----- instance Mutable m MyType where---     type Ref m MyType = CoerceRef m MyType (Vector Double)+-- instance Mutable s MyType where+--     type Ref s MyType = CoerceRef s MyType (Vector Double) -- @ -- -- And the case for any 'Traversable instance, where the items will all be@@ -432,20 +436,20 @@ -- 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+-- instance Mutable s a => Mutable s (MyContainer a) where+--     type Ref s (MyContainer a) = TraverseRef s 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+class DefaultMutable s a r | r -> a s where+    defaultThawRef         :: (PrimMonad m, PrimState m ~ s) => a -> m r+    defaultFreezeRef       :: (PrimMonad m, PrimState m ~ s) => r -> m a+    defaultCopyRef         :: (PrimMonad m, PrimState m ~ s) => r -> a -> m ()+    defaultMoveRef         :: (PrimMonad m, PrimState m ~ s) => r -> r -> m ()+    defaultCloneRef        :: (PrimMonad m, PrimState m ~ s) => r -> m r+    defaultUnsafeThawRef   :: (PrimMonad m, PrimState m ~ s) => a -> m r+    defaultUnsafeFreezeRef :: (PrimMonad m, PrimState m ~ s) => r -> m a -instance (PrimMonad m, s ~ PrimState m) => DefaultMutable m a (MutVar s a) where+instance DefaultMutable s a (MutVar s a) where     defaultThawRef         = newMutVar     defaultFreezeRef       = readMutVar     defaultCopyRef         = writeMutVar@@ -454,7 +458,7 @@     defaultUnsafeThawRef   = newMutVar     defaultUnsafeFreezeRef = readMutVar -instance (Generic a, GMutable m (Rep a)) => DefaultMutable m a (GRef m a) where+instance (Generic a, GMutable s (Rep a)) => DefaultMutable s a (GRef s a) where     defaultThawRef         = gThawRef     defaultFreezeRef       = gFreezeRef     defaultCopyRef         = gCopyRef@@ -463,8 +467,8 @@     defaultUnsafeThawRef   = gUnsafeThawRef     defaultUnsafeFreezeRef = 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+instance (Generic (z Identity), Generic (z (RefFor s)), GMutable s (Rep (z Identity)), GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s)))+        => DefaultMutable s (z Identity) (z (RefFor s)) where     defaultThawRef         = thawHKD     defaultFreezeRef       = freezeHKD     defaultCopyRef         = copyHKD@@ -473,7 +477,7 @@     defaultUnsafeThawRef   = unsafeThawHKD     defaultUnsafeFreezeRef = unsafeFreezeHKD -instance (Traversable f, Mutable m a) => DefaultMutable m (f a) (TraverseRef m f a) where+instance (Traversable f, Mutable s a) => DefaultMutable s (f a) (TraverseRef s f a) where     defaultThawRef         = thawTraverse     defaultFreezeRef       = freezeTraverse     defaultCopyRef         = copyTraverse@@ -482,7 +486,7 @@     defaultUnsafeThawRef   = unsafeThawTraverse     defaultUnsafeFreezeRef = unsafeFreezeTraverse -instance (Coercible s a, Mutable m a) => DefaultMutable m s (CoerceRef m s a) where+instance (Coercible b a, Mutable s a) => DefaultMutable s b (CoerceRef s b a) where     defaultThawRef         = thawCoerce     defaultFreezeRef       = freezeCoerce     defaultCopyRef         = copyCoerce@@ -491,7 +495,7 @@     defaultUnsafeThawRef   = unsafeThawCoerce     defaultUnsafeFreezeRef = unsafeFreezeCoerce -instance Applicative m => DefaultMutable m a (ImmutableRef a) where+instance DefaultMutable s a (ImmutableRef s a) where     defaultThawRef         = thawImmutable     defaultFreezeRef       = freezeImmutable     defaultCopyRef         = copyImmutable@@ -501,18 +505,18 @@     defaultUnsafeFreezeRef = 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.+-- @'RefFor' m a@ is the same as @'Ref' s 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 { getRefFor :: Ref m a }+-- a @'Ref' s a@.+newtype RefFor s a = RefFor { getRefFor :: Ref s a } -deriving instance Eq (Ref m a) => Eq (RefFor m a)-deriving instance Ord (Ref m a) => Ord (RefFor m a)+deriving instance Eq (Ref s a) => Eq (RefFor s a)+deriving instance Ord (Ref s a) => Ord (RefFor s 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+-- | Use a @'RefFor' m a@ as if it were a @'Ref' s a@.+instance X.IsoHKD (RefFor s) a where+    type HKD (RefFor s) a = Ref s a     unHKD = RefFor     toHKD = getRefFor @@ -541,11 +545,11 @@ -- [20,21,22,23,24,25,26,27,28,29] -- @ ---newtype TraverseRef m f a = TraverseRef { getTraverseRef :: f (Ref m a) }+newtype TraverseRef s f a = TraverseRef { getTraverseRef :: f (Ref s 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)+-- | Use a @'TraverseRef' s f a@ as if it were a @f ('Ref' s a)@+instance X.IsoHKD (TraverseRef s f) a where+    type HKD (TraverseRef s f) a = f (Ref s a)     unHKD = TraverseRef     toHKD = getTraverseRef @@ -556,7 +560,7 @@ -- '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 :: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s) => f a -> m (TraverseRef s f a) thawTraverse = fmap TraverseRef . traverse thawRef  -- | Default 'freezeRef' for 'TraverseRef'.@@ -566,7 +570,7 @@ -- '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 :: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s) => TraverseRef s f a -> m (f a) freezeTraverse = traverse freezeRef . getTraverseRef  -- | Default 'copyRef' for 'TraverseRef'.@@ -576,7 +580,7 @@ -- '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 :: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s) => TraverseRef s f a -> f a -> m () copyTraverse (TraverseRef rs) xs = evalStateT (traverse_ go rs) (toList xs)   where     go r = do@@ -591,9 +595,9 @@ -- 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+    :: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s)+    => TraverseRef s f a        -- ^ destination+    -> TraverseRef s f a        -- ^ source     -> m () moveTraverse (TraverseRef rs) (TraverseRef vs) = evalStateT (traverse_ go rs) (toList vs)   where@@ -608,7 +612,7 @@ -- '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 :: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s) => TraverseRef s f a -> m (TraverseRef s f a) cloneTraverse = fmap TraverseRef . traverse cloneRef . getTraverseRef  -- | Default 'unsafeThawRef' for 'TraverseRef'.@@ -618,7 +622,7 @@ -- '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 :: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s) => f a -> m (TraverseRef s f a) unsafeThawTraverse = fmap TraverseRef . traverse unsafeThawRef  -- | Default 'unsafeFreezeRef' for 'TraverseRef'.@@ -628,7 +632,7 @@ -- '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 :: (Traversable f, Mutable s a, PrimMonad m, PrimState m ~ s) => TraverseRef s f a -> m (f a) unsafeFreezeTraverse = traverse unsafeFreezeRef . getTraverseRef  -- | A 'Ref' that works by using the 'Mutable' instance of an equivalent@@ -638,21 +642,21 @@ -- @ -- newtype MyVec = MyVec ('V.Vector' Double) ----- instance 'Mutable' m MyVec where---     type 'Ref' m MyVec = 'CoerceRef' m s ('V.Vector' Double)+-- instance 'Mutable' s MyVec where+--     type 'Ref' s MyVec = 'CoerceRef' s s ('V.Vector' Double) -- @ ----- The @Ref m MyVec@ uses the a @'MV.MVector' Double@ under the hood.+-- The @Ref s 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 { getCoerceRef :: Ref m a }+newtype CoerceRef s b a = CoerceRef { getCoerceRef :: Ref s a } -deriving instance Eq (Ref m a) => Eq (CoerceRef m s a)-deriving instance Ord (Ref m a) => Ord (CoerceRef m s a)+deriving instance Eq (Ref s a) => Eq (CoerceRef s b a)+deriving instance Ord (Ref s a) => Ord (CoerceRef s b 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+-- | Use a @'CoerceRef' s b a@ as if it were a @'Ref' s a@+instance X.IsoHKD (CoerceRef s b) a where+    type HKD (CoerceRef s b) a = Ref s a     unHKD = CoerceRef     toHKD = getCoerceRef @@ -660,70 +664,70 @@ -- -- 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+-- However, it can be useful if you are using a @'CoerceRef' s b a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'CoerceRef' for more information.-thawCoerce :: (Coercible s a, Mutable m a) => s -> m (CoerceRef m s a)+thawCoerce :: (Coercible b a, Mutable s a, PrimMonad m, PrimState m ~ s) => b -> m (CoerceRef s b a) thawCoerce = fmap CoerceRef . thawRef . 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+-- However, it can be useful if you are using a @'CoerceRef' s b a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'CoerceRef' for more information.-freezeCoerce :: (Coercible s a, Mutable m a) => CoerceRef m s a -> m s+freezeCoerce :: (Coercible b a, Mutable s a, PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> m b freezeCoerce = fmap coerce . freezeRef . 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+-- However, it can be useful if you are using a @'CoerceRef' s b a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'CoerceRef' for more information.-copyCoerce :: (Coercible s a, Mutable m a) => CoerceRef m s a -> s -> m ()+copyCoerce :: (Coercible b a, Mutable s a, PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> b -> m () copyCoerce (CoerceRef r) = copyRef r . 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+-- However, it can be useful if you are using a @'CoerceRef' s b a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'CoerceRef' for more information.-moveCoerce :: Mutable m a => CoerceRef m s a -> CoerceRef m s a -> m ()+moveCoerce :: (Mutable s a, PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> CoerceRef s b a -> m () moveCoerce (CoerceRef r) (CoerceRef s) = moveRef r 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+-- However, it can be useful if you are using a @'CoerceRef' s b a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'CoerceRef' for more information.-cloneCoerce :: Mutable m a => CoerceRef m s a -> m (CoerceRef m s a)+cloneCoerce :: (Mutable s a, PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> m (CoerceRef s b a) cloneCoerce = fmap CoerceRef . cloneRef . 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+-- However, it can be useful if you are using a @'CoerceRef' s b a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'CoerceRef' for more information.-unsafeThawCoerce :: (Coercible s a, Mutable m a) => s -> m (CoerceRef m s a)+unsafeThawCoerce :: (Coercible b a, Mutable s a, PrimMonad m, PrimState m ~ s) => b -> m (CoerceRef s b a) unsafeThawCoerce = fmap CoerceRef . unsafeThawRef . 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+-- However, it can be useful if you are using a @'CoerceRef' s b a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'CoerceRef' for more information.-unsafeFreezeCoerce :: (Coercible s a, Mutable m a) => CoerceRef m s a -> m s+unsafeFreezeCoerce :: (Coercible b a, Mutable s a, PrimMonad m, PrimState m ~ s) => CoerceRef s b a -> m b unsafeFreezeCoerce = fmap coerce . unsafeFreezeRef . getCoerceRef  -- | A "'Ref'" that can be used to give a default 'Mutable' instance that@@ -731,11 +735,11 @@ -- 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 { getImmutableRef :: a }+newtype ImmutableRef s a = ImmutableRef { getImmutableRef :: a }  -- | Use a @'ImmutableRef' a@ as if it were an @a@-instance X.IsoHKD ImmutableRef a where-    type HKD ImmutableRef a = a+instance X.IsoHKD (ImmutableRef s) a where+    type HKD (ImmutableRef s) a = a     unHKD = ImmutableRef     toHKD = getImmutableRef @@ -743,10 +747,10 @@ -- -- 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+-- However, it can be useful if you are using a @'ImmutableRef' s b a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'ImmutableRef' for more information.-thawImmutable :: Applicative m => a -> m (ImmutableRef a)+thawImmutable :: Applicative m => a -> m (ImmutableRef s a) thawImmutable = pure . ImmutableRef  -- | Default 'freezeRef' for 'ImmutableRef'.  This will always return the@@ -754,10 +758,10 @@ -- -- 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+-- However, it can be useful if you are using a @'ImmutableRef' s b a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'ImmutableRef' for more information.-freezeImmutable :: Applicative m => ImmutableRef a -> m a+freezeImmutable :: Applicative m => ImmutableRef s a -> m a freezeImmutable = pure . getImmutableRef  -- | Default 'copyRef' for 'ImmutableRef'.  This is a no-op and does@@ -765,10 +769,10 @@ -- -- 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+-- However, it can be useful if you are using a @'ImmutableRef' s b a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'ImmutableRef' for more information.-copyImmutable :: Applicative m => ImmutableRef a -> a -> m ()+copyImmutable :: Applicative m => ImmutableRef s a -> a -> m () copyImmutable _ _ = pure ()  -- | Default 'moveRef' for 'ImmutableRef'.  This is a no-op and does@@ -776,10 +780,10 @@ -- -- 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+-- However, it can be useful if you are using a @'ImmutableRef' s b a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'ImmutableRef' for more information.-moveImmutable :: Applicative m => ImmutableRef a -> ImmutableRef a -> m ()+moveImmutable :: Applicative m => ImmutableRef s a -> ImmutableRef s a -> m () moveImmutable _ _ = pure ()  -- | Default 'cloneRef' for 'ImmutableRef'.  'freezeRef' on this value will@@ -787,29 +791,29 @@ -- -- 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+-- However, it can be useful if you are using a @'ImmutableRef' s b a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'ImmutableRef' for more information.-cloneImmutable :: Applicative m => ImmutableRef a -> m (ImmutableRef a)+cloneImmutable :: Applicative m => ImmutableRef s a -> m (ImmutableRef s a) cloneImmutable = 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+class GMutable s (f :: Type -> Type) where+    type GRef_ s f = (u :: Type -> 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)+    gThawRef_         :: (PrimMonad m, PrimState m ~ s) => f a -> m (GRef_ s f a)+    gFreezeRef_       :: (PrimMonad m, PrimState m ~ s) => GRef_ s f a -> m (f a)+    gCopyRef_         :: (PrimMonad m, PrimState m ~ s) => GRef_ s f a -> f a -> m ()+    gMoveRef_         :: (PrimMonad m, PrimState m ~ s) => GRef_ s f a -> GRef_ s f a -> m ()+    gCloneRef_        :: (PrimMonad m, PrimState m ~ s) => GRef_ s f a -> m (GRef_ s f a)+    gUnsafeThawRef_   :: (PrimMonad m, PrimState m ~ s) => f a -> m (GRef_ s f a)+    gUnsafeFreezeRef_ :: (PrimMonad m, PrimState m ~ s) => GRef_ s 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)+instance Mutable s c => GMutable s (K1 i c) where+    type GRef_ s (K1 i c) = K1 i (Ref s c)      gThawRef_               = fmap K1 . thawRef . unK1     gFreezeRef_             = fmap K1 . freezeRef . unK1@@ -819,8 +823,8 @@     gUnsafeThawRef_         = fmap K1 . unsafeThawRef . unK1     gUnsafeFreezeRef_       = fmap K1 . unsafeFreezeRef . unK1 -instance Monad m => GMutable m U1 where-    type GRef_ m U1 = U1+instance GMutable s U1 where+    type GRef_ s U1 = U1      gThawRef_   _       = pure U1     gFreezeRef_ _       = pure U1@@ -830,8 +834,8 @@     gUnsafeThawRef_   _ = pure U1     gUnsafeFreezeRef_ _ = pure U1 -instance Monad m => GMutable m V1 where-    type GRef_ m V1 = V1+instance GMutable s V1 where+    type GRef_ s V1 = V1      gThawRef_         = \case {}     gFreezeRef_       = \case {}@@ -841,8 +845,8 @@     gUnsafeThawRef_   = \case {}     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+instance (GMutable s f, GMutable s g) => GMutable s (f :*: g) where+    type GRef_ s (f :*: g) = GRef_ s f :*: GRef_ s g      gThawRef_ (x :*: y)             = (:*:) <$> gThawRef_ x <*> gThawRef_ y     gFreezeRef_ (v :*: u)           = (:*:) <$> gFreezeRef_ v <*> gFreezeRef_ u@@ -852,8 +856,8 @@     gUnsafeThawRef_ (x :*: y)       = (:*:) <$> gUnsafeThawRef_ x <*> gUnsafeThawRef_ y     gUnsafeFreezeRef_ (v :*: u)     = (:*:) <$> gUnsafeFreezeRef_ v <*> gUnsafeFreezeRef_ 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)+instance GMutable s f => GMutable s (M1 i c f) where+    type GRef_ s (M1 i c f) = M1 i c (GRef_ s f)      gThawRef_               = fmap M1 . gThawRef_ . unM1     gFreezeRef_             = fmap M1 . gFreezeRef_ . unM1@@ -865,11 +869,11 @@  -- | Wraps ':+:' in a mutable reference.  Used internally to represent -- generic sum references.-newtype MutSumF m f g a = MutSumF { getMutSumF :: MutVar (PrimState m) ((f :+: g) a) }+newtype MutSumF s f g a = MutSumF { getMutSumF :: MutVar s ((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)+instance (GMutable s f, GMutable s g) => GMutable s (f :+: g) where+    type GRef_ s (f :+: g) = MutSumF s (GRef_ s f) (GRef_ s g)+    -- MutVar s :.: (GRef_ s f :+: GRef_ s g)      gThawRef_ = \case       L1 x -> fmap MutSumF . newMutVar . L1 =<< gThawRef_ x@@ -904,34 +908,34 @@  -- | A 'Ref' for instances of 'GMutable', which are the "GHC.Generics" -- combinators.-newtype GMutableRef m f a = GMutableRef { getGMutableRef :: GRef_ m f a }+newtype GMutableRef s f a = GMutableRef { getGMutableRef :: GRef_ s 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)+deriving instance Eq (GRef_ s f a) => Eq (GMutableRef s f a)+deriving instance Ord (GRef_ s f a) => Ord (GMutableRef s f a) -thawGMutableRef :: GMutable m f => f a -> m (GMutableRef m f a)+thawGMutableRef :: (GMutable s f, PrimMonad m, PrimState m ~ s) => f a -> m (GMutableRef s f a) thawGMutableRef = fmap GMutableRef . gThawRef_ -freezeGMutableRef :: GMutable m f => GMutableRef m f a -> m (f a)+freezeGMutableRef :: (GMutable s f, PrimMonad m, PrimState m ~ s) => GMutableRef s f a -> m (f a) freezeGMutableRef = gFreezeRef_ . getGMutableRef -copyGMutableRef :: GMutable m f => GMutableRef m f a -> f a -> m ()+copyGMutableRef :: (GMutable s f, PrimMonad m, PrimState m ~ s) => GMutableRef s f a -> f a -> m () copyGMutableRef (GMutableRef r) = gCopyRef_ r -moveGMutableRef :: GMutable m f => GMutableRef m f a -> GMutableRef m f a -> m ()+moveGMutableRef :: (GMutable s f, PrimMonad m, PrimState m ~ s) => GMutableRef s f a -> GMutableRef s f a -> m () moveGMutableRef (GMutableRef r) (GMutableRef s) = gMoveRef_ r s -cloneGMutableRef :: GMutable m f => GMutableRef m f a -> m (GMutableRef m f a)+cloneGMutableRef :: (GMutable s f, PrimMonad m, PrimState m ~ s) => GMutableRef s f a -> m (GMutableRef s f a) cloneGMutableRef (GMutableRef r) = GMutableRef <$> gCloneRef_ r -unsafeThawGMutableRef :: GMutable m f => f a -> m (GMutableRef m f a)+unsafeThawGMutableRef :: (GMutable s f, PrimMonad m, PrimState m ~ s) => f a -> m (GMutableRef s f a) unsafeThawGMutableRef = fmap GMutableRef . gUnsafeThawRef_ -unsafeFreezeGMutableRef :: GMutable m f => GMutableRef m f a -> m (f a)+unsafeFreezeGMutableRef :: (GMutable s f, PrimMonad m, PrimState m ~ s) => GMutableRef s f a -> m (f a) unsafeFreezeGMutableRef = gUnsafeFreezeRef_ . 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+instance Mutable s c => Mutable s (K1 i c (a :: Type)) where+    type Ref s (K1 i c a) = GMutableRef s (K1 i c) a     thawRef         = thawGMutableRef     freezeRef       = freezeGMutableRef     copyRef         = copyGMutableRef@@ -940,8 +944,8 @@     unsafeThawRef   = unsafeThawGMutableRef     unsafeFreezeRef = unsafeFreezeGMutableRef -instance Monad m => Mutable m (U1 a) where-    type Ref m (U1 a) = GMutableRef m U1 a+instance Mutable s (U1 (a :: Type)) where+    type Ref s (U1 a) = GMutableRef s U1 a     thawRef         = thawGMutableRef     freezeRef       = freezeGMutableRef     copyRef         = copyGMutableRef@@ -950,8 +954,8 @@     unsafeThawRef   = unsafeThawGMutableRef     unsafeFreezeRef = unsafeFreezeGMutableRef -instance Monad m => Mutable m (V1 a) where-    type Ref m (V1 a) = GMutableRef m V1 a+instance Mutable s (V1 (a :: Type)) where+    type Ref s (V1 a) = GMutableRef s V1 a     thawRef         = thawGMutableRef     freezeRef       = freezeGMutableRef     copyRef         = copyGMutableRef@@ -960,8 +964,8 @@     unsafeThawRef   = unsafeThawGMutableRef     unsafeFreezeRef = 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+instance (GMutable s f, GMutable s g) => Mutable s ((f :*: g) a) where+    type Ref s ((f :*: g) a) = GMutableRef s (f :*: g) a     thawRef         = thawGMutableRef     freezeRef       = freezeGMutableRef     copyRef         = copyGMutableRef@@ -970,8 +974,8 @@     unsafeThawRef   = unsafeThawGMutableRef     unsafeFreezeRef = 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+instance (GMutable s f, GMutable s g) => Mutable s ((f :+: g) a) where+    type Ref s ((f :+: g) a) = GMutableRef s (f :+: g) a     thawRef         = thawGMutableRef     freezeRef       = freezeGMutableRef     copyRef         = copyGMutableRef@@ -989,8 +993,8 @@ -- data MyType = MyType { mtInt :: Int, mtDouble :: Double } --   deriving (Generic, Show) ----- instance Mutable m MyType where---     type Ref m MyType = 'GRef' m MyType+-- instance Mutable s MyType where+--     type Ref s MyType = 'GRef' s MyType -- @ -- -- @@@ -1016,34 +1020,34 @@ -- /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 { unGRef :: GRef_ m (Rep a) () }+newtype GRef s a = GRef { unGRef :: GRef_ s (Rep a) () } -deriving instance Eq (GRef_ m (Rep a) ()) => Eq (GRef m a)-deriving instance Ord (GRef_ m (Rep a) ()) => Ord (GRef m a)+deriving instance Eq (GRef_ s (Rep a) ()) => Eq (GRef s a)+deriving instance Ord (GRef_ s (Rep a) ()) => Ord (GRef s a)  -- | Default 'thawRef' for 'GRef'. -- -- You likely won't ever use this directly, since it is automatically -- provided if you have a 'Mutable' instance with 'GRef' as the 'Ref'.--- However, it can be useful if you are using a @'GRef' m a@ just as+-- However, it can be useful if you are using a @'GRef' s a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'GRef' for more information. gThawRef-    :: (Generic a, GMutable m (Rep a))+    :: (Generic a, GMutable s (Rep a), PrimMonad m, PrimState m ~ s)     => a-    -> m (GRef m a)+    -> m (GRef s a) gThawRef = fmap GRef . gThawRef_ . 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+-- However, it can be useful if you are using a @'GRef' s a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'GRef' for more information. gFreezeRef-    :: (Generic a, GMutable m (Rep a))-    => GRef m a+    :: (Generic a, GMutable s (Rep a), PrimMonad m, PrimState m ~ s)+    => GRef s a     -> m a gFreezeRef = fmap to . gFreezeRef_ . unGRef @@ -1051,12 +1055,12 @@ -- -- 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+-- However, it can be useful if you are using a @'GRef' s a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'GRef' for more information. gCopyRef-    :: (Generic a, GMutable m (Rep a))-    => GRef m a+    :: (Generic a, GMutable s (Rep a), PrimMonad m, PrimState m ~ s)+    => GRef s a     -> a     -> m () gCopyRef (GRef v) x = gCopyRef_ v (from x)@@ -1065,13 +1069,13 @@ -- -- 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+-- However, it can be useful if you are using a @'GRef' s a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'GRef' for more information. gMoveRef-    :: GMutable m (Rep a)-    => GRef m a-    -> GRef m a+    :: (GMutable s (Rep a), PrimMonad m, PrimState m ~ s)+    => GRef s a+    -> GRef s a     -> m () gMoveRef (GRef v) (GRef u) = gMoveRef_ v u @@ -1079,38 +1083,38 @@ -- -- 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+-- However, it can be useful if you are using a @'GRef' s a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'GRef' for more information. gCloneRef-    :: GMutable m (Rep a)-    => GRef m a-    -> m (GRef m a)+    :: (GMutable s (Rep a), PrimMonad m, PrimState m ~ s)+    => GRef s a+    -> m (GRef s a) gCloneRef (GRef v) = GRef <$> gCloneRef_ 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+-- However, it can be useful if you are using a @'GRef' s a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'GRef' for more information. gUnsafeThawRef-    :: (Generic a, GMutable m (Rep a))+    :: (Generic a, GMutable s (Rep a), PrimMonad m, PrimState m ~ s)     => a-    -> m (GRef m a)+    -> m (GRef s a) gUnsafeThawRef = fmap GRef . gUnsafeThawRef_ . 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+-- However, it can be useful if you are using a @'GRef' s a@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'GRef' for more information. gUnsafeFreezeRef-    :: (Generic a, GMutable m (Rep a))-    => GRef m a+    :: (Generic a, GMutable s (Rep a), PrimMonad m, PrimState m ~ s)+    => GRef s a     -> m a gUnsafeFreezeRef = fmap to . gUnsafeFreezeRef_ . unGRef @@ -1119,37 +1123,41 @@ -- <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+-- provided if you have a 'Mutable' instance with @z ('RefFor' s)@ as the 'Ref'.+-- However, it can be useful if you are using a @z ('RefFor' s)@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'Mutable' for more information. thawHKD-    :: forall z m.+    :: forall z m s.     ( Generic (z Identity)-    , Generic (z (RefFor m))-    , GMutable m (Rep (z Identity))-    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))+    , Generic (z (RefFor s))+    , GMutable s (Rep (z Identity))+    , GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s))+    , PrimMonad m+    , PrimState m ~ s     )     => z Identity-    -> m (z (RefFor m))+    -> m (z (RefFor s)) thawHKD = fmap to . gThawRef_ . 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+-- provided if you have a 'Mutable' instance with @z ('RefFor' s)@ as the 'Ref'.+-- However, it can be useful if you are using a @z ('RefFor' s)@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'Mutable' for more information. freezeHKD-    :: forall z m.+    :: forall z m s.     ( Generic (z Identity)-    , Generic (z (RefFor m))-    , GMutable m (Rep (z Identity))-    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))+    , Generic (z (RefFor s))+    , GMutable s (Rep (z Identity))+    , GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s))+    , PrimMonad m+    , PrimState m ~ s     )-    => z (RefFor m)+    => z (RefFor s)     -> m (z Identity) freezeHKD = fmap to . gFreezeRef_ . from @@ -1157,18 +1165,20 @@ -- <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+-- provided if you have a 'Mutable' instance with @z ('RefFor' s)@ as the 'Ref'.+-- However, it can be useful if you are using a @z ('RefFor' s)@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'Mutable' for more information. copyHKD-    :: forall z m.+    :: forall z m s.     ( Generic (z Identity)-    , Generic (z (RefFor m))-    , GMutable m (Rep (z Identity))-    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))+    , Generic (z (RefFor s))+    , GMutable s (Rep (z Identity))+    , GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s))+    , PrimMonad m+    , PrimState m ~ s     )-    => z (RefFor m)+    => z (RefFor s)     -> z Identity     -> m () copyHKD r x = gCopyRef_ (from r) (from x)@@ -1177,18 +1187,20 @@ -- <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+-- provided if you have a 'Mutable' instance with @z ('RefFor' s)@ as the 'Ref'.+-- However, it can be useful if you are using a @z ('RefFor' s)@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'Mutable' for more information. moveHKD-    :: forall z m.-    ( Generic (z (RefFor m))-    , GMutable m (Rep (z Identity))-    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))+    :: forall z m s.+    ( Generic (z (RefFor s))+    , GMutable s (Rep (z Identity))+    , GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s))+    , PrimMonad m+    , PrimState m ~ s     )-    => z (RefFor m)-    -> z (RefFor m)+    => z (RefFor s)+    -> z (RefFor s)     -> m () moveHKD r x = gMoveRef_ (from r) (from x) @@ -1196,54 +1208,60 @@ -- <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+-- provided if you have a 'Mutable' instance with @z ('RefFor' s)@ as the 'Ref'.+-- However, it can be useful if you are using a @z ('RefFor' s)@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'Mutable' for more information. cloneHKD-    :: forall z m.-    ( Generic (z (RefFor m))-    , GMutable m (Rep (z Identity))-    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))+    :: forall z m s.+    ( Generic (z (RefFor s))+    , GMutable s (Rep (z Identity))+    , GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s))+    , PrimMonad m+    , PrimState m ~ s     )-    => z (RefFor m)-    -> m (z (RefFor m))+    => z (RefFor s)+    -> m (z (RefFor s)) cloneHKD = fmap to . gCloneRef_ . 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+-- provided if you have a 'Mutable' instance with @z ('RefFor' s)@ as the 'Ref'.+-- However, it can be useful if you are using a @z ('RefFor' s)@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'Mutable' for more information. unsafeThawHKD-    :: forall z m.+    :: forall z m s.     ( Generic (z Identity)-    , Generic (z (RefFor m))-    , GMutable m (Rep (z Identity))-    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))+    , Generic (z (RefFor s))+    , GMutable s (Rep (z Identity))+    , GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s))+    , PrimMonad m+    , PrimState m ~ s     )     => z Identity-    -> m (z (RefFor m))+    -> m (z (RefFor s)) unsafeThawHKD = fmap to . gUnsafeThawRef_ . 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+-- provided if you have a 'Mutable' instance with @z ('RefFor' s)@ as the 'Ref'.+-- However, it can be useful if you are using a @z ('RefFor' s)@ just as -- a normal data type, independent of the 'Ref' class.  See documentation -- for 'Mutable' for more information. unsafeFreezeHKD-    :: forall z m.+    :: forall z m s.     ( Generic (z Identity)-    , Generic (z (RefFor m))-    , GMutable m (Rep (z Identity))-    , GRef_ m (Rep (z Identity)) ~ Rep (z (RefFor m))+    , Generic (z (RefFor s))+    , GMutable s (Rep (z Identity))+    , GRef_ s (Rep (z Identity)) ~ Rep (z (RefFor s))+    , PrimMonad m+    , PrimState m ~ s     )-    => z (RefFor m)+    => z (RefFor s)     -> m (z Identity) unsafeFreezeHKD = fmap to . gUnsafeFreezeRef_ . from

@@ -57,6 +57,7 @@   , MapRef   ) where +import           Control.Monad.Primitive import           Data.Coerce import           Data.Generics.Product.Internal.HList import           Data.Kind@@ -77,10 +78,10 @@ import qualified Data.Vinyl.XRec                          as X  --- | A @'MutPart' m s a@ is a way to "zoom into" an @a@, as a part of--- a mutable reference on @s@.  This allows you to only modify a single--- @a@ part of the @s@, without touching the rest.  It's spiritually--- similar to a @Lens' s a@.+-- | A @'MutPart' s b a@ is a way to "zoom into" an @a@, as a part of+-- a mutable reference on @b@.  This allows you to only modify a single+-- @a@ part of the @b@, without touching the rest.  It's spiritually+-- similar to a @Lens' b a@. -- -- If 'Data.Mutable.Branches.MutBranch' is for sum types, then 'MutPart' is -- for product types.@@ -102,8 +103,8 @@ -- tuples: -- -- @--- 'mutFst' :: 'MutPart' m (a, b) a--- 'mutSnd' :: MutPart m (a, b) b+-- 'mutFst' :: 'MutPart' s (a, b) a+-- 'mutSnd' :: MutPart s (a, b) b -- @ -- -- @@@ -120,51 +121,60 @@ -- If you are using the "Higher-kinded data" pattern, then there's an easy -- way to generate a 'MutPart' for every single field, if you have -- a product type --- see 'hkdMutParts' for more information.-newtype MutPart m s a = MutPart { getMutPart :: Ref m s -> Ref m a }+newtype MutPart s b a = MutPart { getMutPart :: Ref s b -> Ref s a }  -- | Compose two 'MutPart's one after the other. -- -- Note this is also available (albeit flipped in arguments) through the -- 'C.Category' instance.-compMP :: MutPart m a b -> MutPart m b c -> MutPart m a c+compMP :: MutPart s a b -> MutPart s b c -> MutPart s a c compMP (MutPart f) (MutPart g) = MutPart (g . f) infixr 9 `compMP`  -- | The identity 'MutPart': simply focus into the same type itself. -- -- Note this is also available through the 'C.Category' instance.-idMP :: MutPart m a a+idMP :: MutPart s a a idMP = MutPart id -instance C.Category (MutPart m) where+instance C.Category (MutPart s) where     id = idMP     (.) = flip compMP -instance X.IsoHKD (MutPart m s) a+instance X.IsoHKD (MutPart s b) a  -- | 'MutPart' into the first field of a tuple reference.-mutFst :: MutPart m (a, b) a+mutFst :: MutPart s (a, b) a mutFst = MutPart fst  -- | 'MutPart' into the second field of a tuple reference.-mutSnd :: MutPart m (a, b) b+mutSnd :: MutPart s (a, b) b mutSnd = MutPart snd --- | Using a 'MutPart', perform a function on a @'Ref' m s@ as if you had--- a @'Ref' m a@.+-- | Using a 'MutPart', perform a function on a @'Ref' s s@ as if you had+-- a @'Ref' s a@. withPart-    :: MutPart m s a        -- ^ How to zoom into an @a@ from an @s@-    -> Ref m s              -- ^ The larger reference of @s@-    -> (Ref m a -> m r)     -- ^ What do do with the smaller sub-reference of @a@+    :: MutPart s b a        -- ^ How to zoom into an @a@ from an @s@+    -> Ref s b              -- ^ The larger reference of @s@+    -> (Ref s a -> m r)     -- ^ What do do with the smaller sub-reference of @a@     -> m r withPart mp x f = f (getMutPart mp x)  -- | With a 'MutPart', read out a specific part of a 'Ref'.-freezePart :: Mutable m a => MutPart m s a -> Ref m s -> m a+freezePart+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b+    -> m a freezePart mp = freezeRef . getMutPart mp  -- | With a 'MutPart', overwrite into a specific part of a 'Ref'.-copyPart :: Mutable m a => MutPart m s a -> Ref m s -> a -> m ()+copyPart+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b+    -> a+    -> m () copyPart mp = copyRef . getMutPart mp  -- | With a 'MutPart', copy a 'Ref' containing a subvalue into a specific@@ -174,8 +184,8 @@ -- data MyType = MT { mtInt :: Int, mtDouble :: Double } --   deriving Generic ----- instance Mutable m MyType where---     type Ref m MyType = GRef m MyType+-- instance Mutable s MyType where+--     type Ref s MyType = GRef s MyType -- @ -- -- @@@ -186,10 +196,10 @@ -- MyType 100 4.5 -- @ movePartInto-    :: Mutable m a-    => MutPart m s a-    -> Ref m s          -- ^ bigger type (destination)-    -> Ref m a          -- ^ smaller type (source)+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b          -- ^ bigger type (destination)+    -> Ref s a          -- ^ smaller type (source)     -> m () movePartInto mp = moveRef . getMutPart mp @@ -200,8 +210,8 @@ -- data MyType = MT { mtInt :: Int, mtDouble :: Double } --   deriving Generic ----- instance Mutable m MyType where---     type Ref m MyType = GRef m MyType+-- instance Mutable s MyType where+--     type Ref s MyType = GRef s MyType -- @ -- -- @@@ -212,10 +222,10 @@ -- 3 -- @ movePartOver-    :: Mutable m a-    => MutPart m s a-    -> Ref m a          -- ^ smaller type (destination)-    -> Ref m s          -- ^ bigger type (source)+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s a          -- ^ smaller type (destination)+    -> Ref s b          -- ^ bigger type (source)     -> m () movePartOver mp r = moveRef r . getMutPart mp @@ -226,8 +236,8 @@ -- data MyType = MT { mtInt :: Int, mtDouble :: Double } --   deriving Generic ----- instance Mutable m MyType where---     type Ref m MyType = GRef m MyType+-- instance Mutable s MyType where+--     type Ref s MyType = GRef s MyType -- @ -- -- @@@ -238,19 +248,19 @@ -- MyType 100 4.5 -- @ movePartWithin-    :: Mutable m a-    => MutPart m s a-    -> Ref m s              -- ^ destination-    -> Ref m s              -- ^ source+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b              -- ^ destination+    -> Ref s b              -- ^ source     -> m () movePartWithin mp r v = moveRef (getMutPart mp r) (getMutPart mp v)  -- | Clone out a subvalue of a larger 'Ref'. clonePart-    :: Mutable m a-    => MutPart m s a-    -> Ref m s-    -> m (Ref m a)+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b+    -> m (Ref s a) clonePart mp = cloneRef . getMutPart mp  -- | A non-copying version of 'unsafeFreezeRef' that can be more efficient for@@ -260,50 +270,94 @@ -- This is safe as long as you never again modify the mutable -- reference, since it can potentially directly mutate the frozen value -- magically.-unsafeFreezePart :: Mutable m a => MutPart m s a -> Ref m s -> m a+unsafeFreezePart+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b+    -> m a unsafeFreezePart mp = unsafeFreezeRef . getMutPart mp    -- | With a 'MutPart', modify a specific part of a 'Ref' with a pure -- function.-modifyPart :: Mutable m a => MutPart m s a -> Ref m s -> (a -> a) -> m ()+modifyPart+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b+    -> (a -> a)+    -> m () modifyPart mp = modifyRef . getMutPart mp  -- | 'modifyPart', but forces the result before storing it back in the -- reference.-modifyPart' :: Mutable m a => MutPart m s a -> Ref m s -> (a -> a) -> m ()+modifyPart'+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b+    -> (a -> a)+    -> m () modifyPart' mp = modifyRef' . getMutPart mp  -- | 'updateRef', under a 'MutPart' to only modify a specific part of -- a 'Ref'.-updatePart :: Mutable m a => MutPart m s a -> Ref m s -> (a -> (a, b)) -> m b+updatePart+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b+    -> (a -> (a, r))+    -> m r updatePart mp = updateRef . getMutPart mp  -- | 'updatePart', but forces the result before storing it back in the -- reference.-updatePart' :: Mutable m a => MutPart m s a -> Ref m s -> (a -> (a, b)) -> m b+updatePart'+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b+    -> (a -> (a, r))+    -> m r updatePart' mp = updateRef' . getMutPart mp  -- | With a 'MutPart', modify a specific part of a 'Ref' with a monadic -- function.  Uses 'copyRef' into the reference after the action is -- completed.-modifyPartM :: Mutable m a => MutPart m s a -> Ref m s -> (a -> m a) -> m ()+modifyPartM+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b+    -> (a -> m a)+    -> m () modifyPartM mp = modifyRefM . getMutPart mp  -- | 'modifyPartM', but forces the result before storing it back in the -- reference.-modifyPartM' :: Mutable m a => MutPart m s a -> Ref m s -> (a -> m a) -> m ()+modifyPartM'+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b+    -> (a -> m a)+    -> m () modifyPartM' mp = modifyRefM' . getMutPart mp  -- | 'updateRefM', under a 'MutPart' to only modify a specific part of -- a 'Ref'.  'copyRef' into the reference after the action is completed.-updatePartM :: Mutable m a => MutPart m s a -> Ref m s -> (a -> m (a, b)) -> m b+updatePartM+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b+    -> (a -> m (a, r))+    -> m r updatePartM mp = updateRefM . getMutPart mp  -- | 'updatePartM', but forces the result before storing it back in the -- reference.-updatePartM' :: Mutable m a => MutPart m s a -> Ref m s -> (a -> m (a, b)) -> m b+updatePartM'+    :: (Mutable s a, PrimMonad m, PrimState m ~ s)+    => MutPart s b a+    -> Ref s b+    -> (a -> m (a, r))+    -> m r updatePartM' mp = updateRefM' . getMutPart mp  -- | A 'MutPart' for a field in a vinyl 'Data.Vinyl.Rec', automatically@@ -317,46 +371,46 @@ -- [1,2,3] :& [False, True] :& RNil -- @ mutRec-    :: forall a as f rec m.-     ( Ref m (rec f as) ~ rec (RecRef m f) as+    :: forall a as f rec s.+     ( Ref s (rec f as) ~ rec (RecRef s f) as      , RecElem rec a a as as (V.RIndex a as)-     , RecElemFCtx rec (RecRef m f)+     , RecElemFCtx rec (RecRef s f)      )-    => MutPart m (rec f as) (f a)-mutRec = MutPart $ getRecRef . rget @a @as @(RecRef m f) @rec+    => MutPart s (rec f as) (f a)+mutRec = MutPart $ getRecRef . rget @a @as @(RecRef s f) @rec  -- | A 'MutPart' to get into a 'CoerceRef'.-coerceRef :: (Ref m s ~ CoerceRef m s a) => MutPart m s a+coerceRef :: (Ref s b ~ CoerceRef s b a) => MutPart s b a coerceRef = MutPart coerce  -- | Handy wrapper over @'getMutPart' 'coerceRef'@. withCoerceRef-    :: CoerceRef m s a-    -> (Ref m a -> m r)+    :: CoerceRef s b a+    -> (Ref s a -> m r)     -> m r withCoerceRef x f = f (coerce x)  -- | Typeclass used to implement 'hkdMutParts'.  See documentation of -- 'hkdMutParts' for more information.-class (Mutable m (z Identity), Ref m (z Identity) ~ z (RefFor m)) => HKDMutParts m z i o where-    hkdMutParts_ :: (z (RefFor m) -> i a) -> o a+class (Mutable s (z Identity), Ref s (z Identity) ~ z (RefFor s)) => HKDMutParts s z i o where+    hkdMutParts_ :: (z (RefFor s) -> i a) -> o a -instance (Mutable m (z Identity), Ref m (z Identity) ~ z (RefFor m)) => HKDMutParts m z (K1 i (RefFor m c)) (K1 i (MutPart m (z Identity) c)) where+instance (Mutable s (z Identity), Ref s (z Identity) ~ z (RefFor s)) => HKDMutParts s z (K1 i (RefFor s c)) (K1 i (MutPart s (z Identity) c)) where     hkdMutParts_ f = K1 $ MutPart $ getRefFor . unK1 . f -instance (Mutable m (z Identity), Ref m (z Identity) ~ z (RefFor m)) => HKDMutParts m z U1 U1 where+instance (Mutable s (z Identity), Ref s (z Identity) ~ z (RefFor s)) => HKDMutParts s z U1 U1 where     hkdMutParts_ _ = U1 -instance (Mutable m (z Identity), Ref m (z Identity) ~ z (RefFor m), TypeError ('Text "Cannot use hkdMutParts for uninhabited types: " ':<>: 'ShowType z)) => HKDMutParts m z V1 V1 where+instance (Mutable s (z Identity), Ref s (z Identity) ~ z (RefFor s), TypeError ('Text "Cannot use hkdMutParts for uninhabited types: " ':<>: 'ShowType z)) => HKDMutParts s z V1 V1 where     hkdMutParts_ _ = undefined -instance HKDMutParts m z i o => HKDMutParts m z (M1 a b i) (M1 a b o) where-    hkdMutParts_ f = M1 $ hkdMutParts_ @m (unM1 . f)+instance HKDMutParts s z i o => HKDMutParts s z (M1 a b i) (M1 a b o) where+    hkdMutParts_ f = M1 $ hkdMutParts_ @s (unM1 . f) -instance (HKDMutParts m z i o, HKDMutParts m z i' o') => HKDMutParts m z (i :*: i') (o :*: o') where-    hkdMutParts_ f = hkdMutParts_ @m ((\(x:*:_)->x) . f) :*: hkdMutParts_ @m ((\(_:*:y)->y) . f)+instance (HKDMutParts s z i o, HKDMutParts s z i' o') => HKDMutParts s z (i :*: i') (o :*: o') where+    hkdMutParts_ f = hkdMutParts_ @s ((\(x:*:_)->x) . f) :*: hkdMutParts_ @s ((\(_:*:y)->y) . f) -instance (Mutable m (z Identity), Ref m (z Identity) ~ z (RefFor m), TypeError ('Text "Cannot use hkdMutParts for sum types: " ':<>: 'ShowType z)) => HKDMutParts m z (i :+: i') o where+instance (Mutable s (z Identity), Ref s (z Identity) ~ z (RefFor s), TypeError ('Text "Cannot use hkdMutParts for sum types: " ':<>: 'ShowType z)) => HKDMutParts s z (i :+: i') o where     hkdMutParts_ _ = undefined  -- | If you are using the "higher-kinded data" pattern, a la@@ -375,8 +429,8 @@ -- instance Mutable (MyTypeF 'Identity') where --     type Ref (MyTypeF 'Identity') = MyTypeF ('RefFor' m) ----- mx :: MutPart m (MyTypeF Identity) ('V.Vector' Int)--- my :: MutPart m (MyTypeF Identity) (Vector Double)+-- mx :: MutPart s (MyTypeF Identity) ('V.Vector' Int)+-- my :: MutPart s (MyTypeF Identity) (Vector Double) -- MT mx my = hkdMutParts @MyTypeF -- @ --@@ -397,20 +451,20 @@ -- shallow access is often faster with 'hkdMutParts'...but this probably -- does vary on a case-by-case basis. hkdMutParts-    :: forall z m.-     ( Generic (z (RefFor m))-     , Generic (z (MutPart m (z Identity)))-     , HKDMutParts m z (Rep (z (RefFor m))) (Rep (z (MutPart m (z Identity))))+    :: forall z s.+     ( Generic (z (RefFor s))+     , Generic (z (MutPart s (z Identity)))+     , HKDMutParts s z (Rep (z (RefFor s))) (Rep (z (MutPart s (z Identity))))      )-    => z (MutPart m (z Identity))-hkdMutParts = to $ hkdMutParts_ @m @z from+    => z (MutPart s (z Identity))+hkdMutParts = to $ hkdMutParts_ @s @z from  -- | Create a 'MutPart' for a field name.  Should work for any type with -- one constructor whose mutable reference is 'GRef'.  See 'fieldMut' for -- usage directions. -- -- Mostly leverages the power of "Data.Generics.Product.Fields".-class (Mutable m s, Mutable m a) => FieldMut (fld :: Symbol) m s a | fld s -> a where+class (Mutable s b, Mutable s a) => FieldMut (fld :: Symbol) s b a | fld b -> a where     -- | Create a 'MutPart' for a field name.  Should work for any type with     -- one constructor whose mutable reference is 'GRef'.     --@@ -420,8 +474,8 @@     -- data MyType = MyType { mtInt :: Int, mtDouble :: Double }     --   deriving (Generic, Show)     ---    -- instance Mutable m MyType where-    --     type Ref m MyType = 'GRef' m MyType+    -- instance Mutable s MyType where+    --     type Ref s MyType = 'GRef' s MyType     -- @     --     -- @@@ -447,16 +501,16 @@     -- more or less identical performance characteristics.     fieldMut         :: Label fld        -- ^ field label (usually given using OverloadedLabels, @#blah)-        -> MutPart m s a+        -> MutPart s b a  instance-      ( Mutable m s-      , Mutable m a-      , Ref m s ~ GRef m s-      , GL.GLens' (HasTotalFieldPSym fld) (GRef_ m (Rep s)) (Ref m a)-      , GL.HasField' fld s a+      ( Mutable s b+      , Mutable s a+      , Ref s b ~ GRef s b+      , GL.GLens' (HasTotalFieldPSym fld) (GRef_ s (Rep b)) (Ref s a)+      , GL.HasField' fld b a       )-      => FieldMut fld m s a where+      => FieldMut fld s b a where     fieldMut _ = MutPart $ GLP.view (GL.glens @(HasTotalFieldPSym fld)) . unGRef  data HasTotalFieldPSym :: Symbol -> GL.TyFun (Type -> Type) (Maybe Type)@@ -465,28 +519,28 @@ -- | A helpful wrapper over @'withPart' ('fieldMut' #blah)@.  Create -- a 'fieldMut' and directly use it. withField-    :: FieldMut fld m s a+    :: FieldMut fld s b a     => Label fld            -- ^ field label (usually given using OverloadedLabels, @#blah)-    -> Ref m s              -- ^ Larger record reference-    -> (Ref m a -> m b)     -- ^ What to do with the mutable field-    -> m b+    -> Ref s b              -- ^ Larger record reference+    -> (Ref s a -> m r)     -- ^ What to do with the mutable field+    -> m r withField l = withPart (fieldMut l)  -- | A helpful wrapper around @'getMutPart' ('fieldMut' #blah)@.  Directly -- use a 'fieldMut' to access a mutable field. mutField-    :: forall fld m s a. FieldMut fld m s a+    :: forall fld s b a. FieldMut fld s b a     => Label fld            -- ^ field label (usually given using OverloadedLabels, @#blah)-    -> Ref m s              -- ^ Larger record reference-    -> Ref m a              -- ^ Internal mutable field-mutField = getMutPart . fieldMut @_ @m+    -> Ref s b              -- ^ Larger record reference+    -> Ref s a              -- ^ Internal mutable field+mutField = getMutPart . fieldMut @_ @s  -- | Create a 'MutPart' for a position in a product type.  Should work for any -- type with one constructor whose mutable reference is 'GRef'.  See -- 'posMut' for usage directions. -- -- Mostly leverages the power of "Data.Generics.Product.Positions".-class (Mutable m s, Mutable m a) => PosMut (i :: Nat) m s a | i s -> a where+class (Mutable s b, Mutable s a) => PosMut (i :: Nat) s b a | i b -> a where     -- | Create a 'MutPart' for a position in a product type.  Should work for any     -- type with one constructor whose mutable reference is 'GRef'.     --@@ -496,8 +550,8 @@     -- data MyType = MyType Int Double     --   deriving (Generic, Show)     ---    -- instance Mutable m MyType where-    --     type Ref m MyType = 'GRef' m MyType+    -- instance Mutable s MyType where+    --     type Ref s MyType = 'GRef' s MyType     -- @     --     -- @@@ -513,18 +567,18 @@     -- a type whose mutable reference is 'GRef'.  Note that because all of     -- the lookups are done at compile-time, 'posMut' and 'fieldMut' have     -- more or less identical performance characteristics.-    posMut :: MutPart m s a+    posMut :: MutPart s b a  instance-      ( Mutable m s-      , Mutable m a-      , Ref m s ~ GRef m s-      , gref ~ Fst (Traverse (GRef_ m (GL.CRep s)) 1)-      , Coercible (GRef_ m (Rep s) ()) (gref ())-      , GL.GLens' (HasTotalPositionPSym i) gref (Ref m a)-      , GL.HasPosition' i s a+      ( Mutable s b+      , Mutable s a+      , Ref s b ~ GRef s b+      , gref ~ Fst (Traverse (GRef_ s (GL.CRep b)) 1)+      , Coercible (GRef_ s (Rep b) ()) (gref ())+      , GL.GLens' (HasTotalPositionPSym i) gref (Ref s a)+      , GL.HasPosition' i b a       )-      => PosMut i m s a where+      => PosMut i s b a where     posMut = MutPart $ GLP.view (GL.glens @(HasTotalPositionPSym i) @gref) . coerce @_ @(gref ()) . unGRef  data HasTotalPositionPSym :: Nat -> GL.TyFun (Type -> Type) (Maybe Type)@@ -533,19 +587,19 @@ -- | A helpful wrapper over @'withPart' ('posMut' \@n)@.  Create -- a 'posMut' and directly use it. withPos-    :: forall i m s a r. PosMut i m s a-    => Ref m s              -- ^ Larger record reference-    -> (Ref m a -> m r)     -- ^ What to do with the mutable field+    :: forall i s m b a r. PosMut i s b a+    => Ref s b              -- ^ Larger record reference+    -> (Ref s a -> m r)     -- ^ What to do with the mutable field     -> m r withPos = withPart (posMut @i)  -- | A helpful wrapper around @'getMutPart' ('posMut' \@n)@.  Directly -- use a 'posMut' to access a mutable field. mutPos-    :: forall i m s a. PosMut i m s a-    => Ref m s              -- ^ Larger record reference-    -> Ref m a              -- ^ Internal mutable field-mutPos = getMutPart (posMut @i @m)+    :: forall i s b a. PosMut i s b a+    => Ref s b              -- ^ Larger record reference+    -> Ref s a              -- ^ Internal mutable field+mutPos = getMutPart (posMut @i @s)  -- | Create a 'MutPart' splitting out a product type into a tuple of refs -- for every field in that product type. Should work for any type with one@@ -553,7 +607,7 @@ -- directions. -- -- Mostly leverages the power of "Data.Generics.Product.HList".-class (Mutable m s, Mutable m a) => TupleMut m s a | s -> a where+class (Mutable s b, Mutable s a) => TupleMut s b a | b -> a where     -- | Create a 'MutPart' splitting out a product type into a tuple of refs     -- for every field in that product type. Should work for any type with one     -- constructor whose mutable reference is 'GRef'.@@ -564,8 +618,8 @@     -- data MyType = MyType Int Double     --   deriving (Generic, Show)     ---    -- instance Mutable m MyType where-    --     type Ref m MyType = 'GRef' m MyType+    -- instance Mutable s MyType where+    --     type Ref s MyType = 'GRef' s MyType     -- @     --     -- Now there is an instance of @'TupleMut' m MyType (Int, Double)@.@@ -585,20 +639,20 @@     -- Performance-wise, this appears to be faster than 'fieldMut' and     -- 'posMut' when using a single reference, but slower if using all     -- references.-    tupleMut :: MutPart m s a+    tupleMut :: MutPart s b a  instance-      ( Mutable m s-      , Mutable m a-      , Ref m s ~ GRef m s-      , GIsList (GRef_ m (Rep s)) (GRef_ m (Rep s)) (MapRef m as) (MapRef m as)-      , GIsList (Rep s) (Rep s) as as+      ( Mutable s b+      , Mutable s a+      , Ref s b ~ GRef s b+      , GIsList (GRef_ s (Rep b)) (GRef_ s (Rep b)) (MapRef s as) (MapRef s as)+      , GIsList (Rep b) (Rep b) as as       , ListTuple a a as as-      , ListTuple b b (MapRef m as) (MapRef m as)-      , Ref m a ~ b+      , ListTuple c c (MapRef s as) (MapRef s as)+      , Ref s a ~ c       )-      => TupleMut m s a where-    tupleMut = MutPart $ listToTuple @b @b @(MapRef m as) @(MapRef m as)+      => TupleMut s b a where+    tupleMut = MutPart $ listToTuple @c @c @(MapRef s as) @(MapRef s as)                        . GLP.view glist                        . unGRef @@ -610,8 +664,8 @@ -- data MyType = MyType Int Double --   deriving (Generic, Show) ----- instance Mutable m MyType where---     type Ref m MyType = 'GRef' m MyType+-- instance Mutable s MyType where+--     type Ref s MyType = 'GRef' s MyType -- @ -- -- @@@ -623,10 +677,10 @@ -- MyType (-3) 9 -- @ withTuple-    :: TupleMut m s a-    => Ref m s              -- ^ Larger record reference-    -> (Ref m a -> m r)     -- ^ What to do with each mutable field.  The-                            -- @'Ref' m a@ will be a tuple of every field's ref.+    :: TupleMut s b a+    => Ref s b              -- ^ Larger record reference+    -> (Ref s a -> m r)     -- ^ What to do with each mutable field.  The+                            -- @'Ref' s a@ will be a tuple of every field's ref.     -> m r withTuple = withPart tupleMut