diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,15 @@ Changelog ========= +Version 0.1.0.1 +--------------- + +*February 11, 2020* + + + +* Update to work with *generic-lens-2.0.0.0* and *generic-lens-core-2.0.0.0*. + Version 0.1.0.0 --------------- diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -4,10 +4,14 @@ [![mutable on Hackage](https://img.shields.io/hackage/v/mutable.svg?maxAge=86400)](https://hackage.haskell.org/package/mutable) [![Build Status](https://travis-ci.org/mstksg/mutable.svg?branch=master)](https://travis-ci.org/mstksg/mutable) -[**Documentation and Walkthrough**][docs] +**[Documentation and Walkthrough][docs]** [docs]: https://mutable.jle.im +**[Introductory Blog Post][blog]** + +[blog]: https://blog.jle.im/entry/introducing-the-mutable-library.html + Beautiful Mutable Values ------------------------ @@ -32,8 +36,9 @@ one field), and also efficient entire-datatype copies/updates, as well, in many cases. -Check out the [documentation home page][docs], [haddock reference][haddock], or -read below for motivation and high-level descriptions. +Check out the [documentation home page][docs], [haddock reference][haddock], +[introductory blog post on insights and lessons learned][blog], or read below +for motivation and high-level descriptions. [haddock]: https://hackage.haskell.org/package/mutable @@ -80,8 +85,7 @@ functions that each modify different items in a vector in sequence, and you want to run them many times interleaved, or one after the other.) -Composite Datatype ------------------- +### Composite Datatype That all works for `MVector`, but let's say you have a simple composite data type that is two vectors: @@ -158,6 +162,47 @@ This is a type of composition and interleaving that cannot be achieved by simply breaking down `TwoVec` and running functions that work purely on each of the two vectors individually. + +Mutable Sum Types +----------------- + +There is also support for mutable sum types, as well. Here is the automatic +definition of a *[mutable linked list][ll]*: + +[ll]: https://en.wikipedia.org/wiki/Linked_list + +```haskell +data List a = Nil | Cons a (List a) + 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) +``` + +We can write a function to "pop" out the top value and shift the rest of the +list up: + +```haskell +popStack + :: (PrimMonad m, Mutable m a) + => Ref m (List a) + -> m (Maybe a) +popStack xs = do + c <- projectBranch (constrMB #_Cons) xs + forM c $ \(y, ys) -> do + o <- freezeRef y + moveRef xs ys + pure o +``` + +```haskell +ghci> runST $ do + r <- thawRef $ 1 `Cons` 2 `Cons` 3 `Cons` Nil + y <- popStack r + (y,) <$> freezeRef r +-- => (Just 1, 2 `Cons` 3 `Cons` Nil) +``` Show me the numbers ------------------- diff --git a/mutable.cabal b/mutable.cabal --- a/mutable.cabal +++ b/mutable.cabal @@ -4,10 +4,10 @@ -- -- see: https://github.com/sol/hpack -- --- hash: 4bc371a3f5a9dc170b74be324280aeabe3d89a2be7c8766d3b5c3e27b5b29333 +-- hash: 71081ba24c9c597ffd540904a9115e3f1dc62b4606dab2916c17c6961d9cbdd8 name: mutable -version: 0.1.0.0 +version: 0.1.0.1 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". @@ -53,7 +53,8 @@ build-depends: base >=4.11 && <5 , constraints - , generic-lens >=1.1 + , generic-lens >=2.0 + , generic-lens-core >=2.0 , primitive >=0.6.4 , reflection , transformers diff --git a/src/Data/Mutable/Branches.hs b/src/Data/Mutable/Branches.hs --- a/src/Data/Mutable/Branches.hs +++ b/src/Data/Mutable/Branches.hs @@ -58,6 +58,7 @@ import Control.Monad import Control.Monad.Primitive +import Data.Generics.Product.Internal.HList import Data.Maybe import Data.Mutable.Class import Data.Mutable.Instances @@ -138,7 +139,7 @@ -- @ -- nilBranch :: MutBranch m (List a) () -- nilBranch = constrMB #_Nil --- +-- -- consBranch :: MutBranch m (List a) (a, List a) -- consBranch = constrMB #_Cons -- @ @@ -193,14 +194,14 @@ -- -- @ -- ghci> r <- thawRef (Left 10) - -- ghci> s <- cloneBranch (constrMB #_Left) + -- ghci> s <- projectBranch (constrMB #_Left) r -- ghci> case s of Just s' -> freezeRef s' -- 10 -- @ -- -- @ -- ghci> r <- thawRef (Right True) - -- ghci> s <- cloneBranch (constrMB #_Left) + -- ghci> s <- projectBranch (constrMB #_Left) r -- ghci> case s of Nothing -> "it was Right" -- "it was Right" -- @ @@ -562,15 +563,18 @@ instance ( GMutable m f , Mutable m a - , GL.GIsList (GRef_ m f) (GRef_ m f) (MapRef m as) (MapRef m as) - , GL.GIsList f f as as - , GL.ListTuple a as - , GL.ListTuple b (MapRef m as) + , GIsList (GRef_ m f) (GRef_ m f) (MapRef m as) (MapRef m as) + , GIsList f f as as + , ListTuple a a as as + , ListTuple b b (MapRef m as) (MapRef m as) , Ref m a ~ b ) => GMutBranchConstructor ctor m (M1 C ('MetaCons ctor fixity fields) f) a where - gmbcProj _ = pure . Just . GL.listToTuple . GLP.view GL.glist . unM1 - gmbcEmbed _ = pure . M1 . GLP.view GL.glistR . GL.tupleToList + 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) instance GMutBranchConstructor ctor m f a => GMutBranchConstructor ctor m (M1 D meta f) a where gmbcProj lb = gmbcProj lb . unM1 @@ -593,33 +597,35 @@ ( PrimMonad m , GMutable m r , GMutBranchConstructor ctor m l a - , GL.GIsList (GRef_ m l) (GRef_ m l) (MapRef m as) (MapRef m as) - , GL.GIsList l l as as - , GL.ListTuple a as - , GL.ListTuple b (MapRef m as) + , GIsList (GRef_ m l) (GRef_ m l) (MapRef m as) (MapRef m as) + , GIsList l l as as + , ListTuple a a as as + , ListTuple b b (MapRef m as) (MapRef m as) , Ref m a ~ b ) => GMutBranchSum ctor 'True m 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.glistR . GL.tupleToList + gmbsEmbed _ = fmap MutSumF . newMutVar . L1 . GLP.view (GL.fromIso glist) + . tupleToList @b @_ @(MapRef m as) instance ( PrimMonad m , GMutable m l , GMutBranchConstructor ctor m r a - , GL.GIsList (GRef_ m r) (GRef_ m r) (MapRef m as) (MapRef m as) - , GL.GIsList r r as as - , GL.ListTuple a as - , GL.ListTuple b (MapRef m as) + , GIsList (GRef_ m r) (GRef_ m r) (MapRef m as) (MapRef m as) + , GIsList r r as as + , ListTuple a a as as + , ListTuple b b (MapRef m as) (MapRef m as) , Ref m a ~ b ) => GMutBranchSum ctor 'False m 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.glistR . GL.tupleToList + gmbsEmbed _ = fmap MutSumF . newMutVar . R1 . GLP.view (GL.fromIso glist) + . tupleToList @b @_ @(MapRef m as) -- | Create a 'MutBranch' for any data type with a 'Generic' instance by -- specifying the constructor name using OverloadedLabels diff --git a/src/Data/Mutable/Instances.hs b/src/Data/Mutable/Instances.hs --- a/src/Data/Mutable/Instances.hs +++ b/src/Data/Mutable/Instances.hs @@ -62,7 +62,7 @@ import Data.Functor.Identity import Data.Functor.Product import Data.Functor.Sum -import Data.GenericLens.Internal (HList(..)) +import Data.Generics.Product.Internal.HList (HList(..)) import Data.Kind import Data.Mutable.Internal import Data.Ord diff --git a/src/Data/Mutable/Internal.hs b/src/Data/Mutable/Internal.hs --- a/src/Data/Mutable/Internal.hs +++ b/src/Data/Mutable/Internal.hs @@ -173,7 +173,12 @@ -- -- See for more -- information on this typeclass and how to define instances --- automatically. +-- automatically, and also +-- +-- * for more information +-- on dealing with record types +-- * for more information +-- on dealing with sum types class Monad m => Mutable m a where -- | Links the type @a@ to the type of its canonical "mutable version". -- diff --git a/src/Data/Mutable/Parts.hs b/src/Data/Mutable/Parts.hs --- a/src/Data/Mutable/Parts.hs +++ b/src/Data/Mutable/Parts.hs @@ -58,20 +58,23 @@ ) where import Data.Coerce +import Data.Generics.Product.Internal.HList import Data.Kind import Data.Mutable.Class import Data.Mutable.Instances -import Data.Vinyl hiding (HList) +import Data.Vinyl hiding (HList) import Data.Vinyl.Functor import GHC.Generics import GHC.TypeLits -import qualified Control.Category as C -import qualified Data.GenericLens.Internal as GL -import qualified Data.Generics.Internal.Profunctor.Lens as GLP -import qualified Data.Generics.Product.Fields as GL -import qualified Data.Generics.Product.Positions as GL -import qualified Data.Vinyl.TypeLevel as V -import qualified Data.Vinyl.XRec as X +import qualified Control.Category as C +import qualified Data.GenericLens.Internal as GL +import qualified Data.Generics.Internal.Profunctor.Lens as GLP +import qualified Data.Generics.Product.Fields as GL +import qualified Data.Generics.Product.Internal.GLens as GL +import qualified Data.Generics.Product.Internal.Positions as GL +import qualified Data.Generics.Product.Positions as GL +import qualified Data.Vinyl.TypeLevel as V +import qualified Data.Vinyl.XRec as X -- | A @'MutPart' m s a@ is a way to "zoom into" an @a@, as a part of @@ -588,15 +591,15 @@ ( Mutable m s , Mutable m a , Ref m s ~ GRef m s - , GL.GIsList (GRef_ m (Rep s)) (GRef_ m (Rep s)) (MapRef m as) (MapRef m as) - , GL.GIsList (Rep s) (Rep s) as as - , GL.ListTuple a as - , GL.ListTuple b (MapRef m as) + , GIsList (GRef_ m (Rep s)) (GRef_ m (Rep s)) (MapRef m as) (MapRef m as) + , GIsList (Rep s) (Rep s) as as + , ListTuple a a as as + , ListTuple b b (MapRef m as) (MapRef m as) , Ref m a ~ b ) => TupleMut m s a where - tupleMut = MutPart $ GL.listToTuple - . GLP.view GL.glist + tupleMut = MutPart $ listToTuple @b @b @(MapRef m as) @(MapRef m as) + . GLP.view glist . unGRef -- | A helpful wrapper over @'withPart' 'tupleMut'@. Directly operate on