newtype-zoo 1.1.0.0 → 1.2.0.0

raw patch · 10 files changed

+241/−7 lines, 10 filesdep +comonadPVP ok

version bump matches the API change (PVP)

Dependencies added: comonad

API changes (from Hackage documentation)

Files

• CHANGELOG.md +9/−0
• newtype-zoo.cabal +3/−1
• src/NewtypeZoo.hs +3/−0
• src/NewtypeZoo/Active.hs +5/−1
• src/NewtypeZoo/Allocated.hs +5/−1
• src/NewtypeZoo/Available.hs +141/−0
• src/NewtypeZoo/Broken.hs +5/−1
• src/NewtypeZoo/Cached.hs +2/−1
• src/NewtypeZoo/Complete.hs +2/−1
• src/NewtypeZoo/Consistent.hs +66/−1

@@ -1,5 +1,14 @@ # Revision history for newtype-zoo +## 1.2.0.0 -- 2019-09-27++* Add `Available`+* Add experimental two-parameter newtype wrappers:+  * `AvailableIn`+  * `ConsistentTo`+* Add comonad instances to a few wrappers. If this proves valuable,+  all type will get instances in a future release.+ ## 1.1.0.0 -- 2019-09-19  * Add module `NewtypeZoo` which exports all reexports all wrappers.

@@ -13,7 +13,7 @@ -- PVP summary:      +-+------- breaking API changes --                   | | +----- non-breaking API additions --                   | | | +--- code changes with no API change-version:             1.1.0.0+version:             1.2.0.0  -- A short (one-line) description of the package. synopsis:            Newtype Wrapper Zoo@@ -56,6 +56,7 @@       NewtypeZoo     , NewtypeZoo.Active     , NewtypeZoo.Allocated+    , NewtypeZoo.Available     , NewtypeZoo.Broken     , NewtypeZoo.Cached     , NewtypeZoo.Complete@@ -115,6 +116,7 @@   -- Other library packages from which modules are imported.   build-depends:       base ^>=4.12.0.0+    , comonad     , data-default     , deepseq     , pointed

@@ -1,3 +1,5 @@+{-# LANGUAGE KindSignatures #-}+{-# LANGUAGE TypeOperators #-} -- | General Purpose Newtype Wrappers -- -- A zoo of /newtype/ wrappers.@@ -60,5 +62,6 @@ import NewtypeZoo.Complete as X import NewtypeZoo.Cached as X import NewtypeZoo.Broken as X+import NewtypeZoo.Available as X import NewtypeZoo.Allocated as X import NewtypeZoo.Active as X

@@ -5,6 +5,7 @@   , theActive   ) where +import           Control.Comonad (Comonad) import           Control.DeepSeq (NFData) import           Control.Monad.Fix (MonadFix) import           Control.Monad.Zip (MonadZip)@@ -23,6 +24,7 @@ import           System.Random   (Random) import           Test.QuickCheck (Arbitrary) +-- | A wrapper for something that is `Active`. newtype Active a = Active a   deriving ( Eq            , Ord@@ -64,14 +66,16 @@            , MonadFix            , Monad            , MonadZip-+           , Comonad            )            via Identity +-- | An accessor function for something 'Active'. _theActive :: Active x -> x _theActive (Active !x) = x {-# INLINE _theActive #-} +-- | A lens for something 'Active'. theActive :: forall a b p f. (Profunctor p, Functor f) => p a (f b) -> p (Active a) (f (Active b)) theActive = dimap _theActive (fmap Active) {-# INLINE theActive #-}

@@ -5,6 +5,7 @@   , theAllocated   ) where +import           Control.Comonad (Comonad) import           Control.DeepSeq (NFData) import           Control.Monad.Fix (MonadFix) import           Control.Monad.Zip (MonadZip)@@ -23,6 +24,7 @@ import           System.Random   (Random) import           Test.QuickCheck (Arbitrary) +-- | A wrapper for something that is `Allocated`. newtype Allocated a = Allocated a   deriving ( Eq            , Ord@@ -64,14 +66,16 @@            , MonadFix            , Monad            , MonadZip-+           , Comonad            )            via Identity +-- | An accessor function for something 'Allocated'. _theAllocated :: Allocated x -> x _theAllocated (Allocated !x) = x {-# INLINE _theAllocated #-} +-- | A lens for something 'Allocated'. theAllocated :: forall a b p f. (Profunctor p, Functor f) => p a (f b) -> p (Allocated a) (f (Allocated b)) theAllocated = dimap _theAllocated (fmap Allocated) {-# INLINE theAllocated #-}

@@ -0,0 +1,141 @@+-- | Indicate that something is `Available`.+module NewtypeZoo.Available+  ( Available(Available)+  , _theAvailable+  , theAvailable+  , AvailableIn(AvailableIn)+  , _theAvailableIn+  , theAvailableIn+  ) where++import           Control.Comonad (Comonad)+import           Control.DeepSeq (NFData)+import           Control.Monad.Fix (MonadFix)+import           Control.Monad.Zip (MonadZip)+import           Data.Bits       (Bits,FiniteBits)+import           Data.Copointed  (Copointed)+import           Data.Default    (Default)+import           Data.Functor.Classes (Eq1, Ord1, Read1, Show1)+import           Data.Functor.Identity+import           Data.Ix         (Ix)+import           Data.Profunctor (Profunctor, dimap)+import           Data.Pointed    (Pointed)+import           Data.String     (IsString)+import           Data.Typeable   (Typeable)+import           Foreign.Storable (Storable)+import           GHC.Generics    (Generic, Generic1)+import           System.Random   (Random)+import           Test.QuickCheck (Arbitrary)++-- | A wrapper for something that is `Available`.+newtype Available a = Available a+  deriving ( Eq+           , Ord+           , Read+           , Show+           , NFData+           , Foldable+           , Traversable+           , Functor+           , Default+           , Monoid+           , Semigroup+           , Typeable+           , Generic+           , Generic1+           , Random+           , Arbitrary+           , Bounded+           , Enum+           , Floating+           , Fractional+           , Integral+           , Num+           , Real+           , RealFloat+           , RealFrac+           , Ix+           , IsString+           , Bits+           , FiniteBits+           )+  deriving ( Eq1+           , Ord1+           , Read1+           , Show1+           , Pointed+           , Copointed+           , Applicative+           , MonadFix+           , Monad+           , MonadZip+           , Comonad+           )+           via Identity++-- | An accessor function for something 'Available'.+_theAvailable :: Available x -> x+_theAvailable (Available !x) = x+{-# INLINE _theAvailable #-}++-- | A lens for something 'Available'.+theAvailable :: forall a b p f. (Profunctor p, Functor f) => p a (f b) -> p (Available a) (f (Available b))+theAvailable = dimap _theAvailable (fmap Available)+{-# INLINE theAvailable #-}++-- | A wrapper for something that is `AvailableIn` with respect to some context+-- indicated by a (phantom-) type.+newtype AvailableIn ctx a = AvailableIn a+  deriving ( Eq+           , Ord+           , Read+           , Show+           , NFData+           , Foldable+           , Traversable+           , Functor+           , Default+           , Monoid+           , Semigroup+           , Typeable+           , Generic+           , Generic1+           , Random+           , Arbitrary+           , Bounded+           , Enum+           , Floating+           , Fractional+           , Integral+           , Num+           , Real+           , RealFloat+           , RealFrac+           , Ix+           , IsString+           , Bits+           , FiniteBits+           )+  deriving ( Eq1+           , Ord1+           , Read1+           , Show1+           , Pointed+           , Copointed+           , Applicative+           , MonadFix+           , Monad+           , MonadZip+           , Comonad+           )+           via Identity++-- | An accessor function for something 'AvailableIn'.+_theAvailableIn :: AvailableIn ctx x -> x+_theAvailableIn (AvailableIn !x) = x+{-# INLINE _theAvailableIn #-}++-- | A lens for something 'AvailableIn'.+theAvailableIn :: forall ctx a b p f. (Profunctor p, Functor f) => p a (f b) -> p (AvailableIn ctx a) (f (AvailableIn ctx b))+theAvailableIn = dimap _theAvailableIn (fmap AvailableIn)+{-# INLINE theAvailableIn #-}

@@ -5,6 +5,7 @@   , theBroken   ) where +import           Control.Comonad (Comonad) import           Control.DeepSeq (NFData) import           Control.Monad.Fix (MonadFix) import           Control.Monad.Zip (MonadZip)@@ -23,6 +24,7 @@ import           System.Random   (Random) import           Test.QuickCheck (Arbitrary) +-- | A wrapper for something that is `Broken`. newtype Broken a = Broken a   deriving ( Eq            , Ord@@ -64,14 +66,16 @@            , MonadFix            , Monad            , MonadZip-+           , Comonad            )            via Identity +-- | An accessor function for something 'Broken'. _theBroken :: Broken x -> x _theBroken (Broken !x) = x {-# INLINE _theBroken #-} +-- | A lens for something 'Broken'. theBroken :: forall a b p f. (Profunctor p, Functor f) => p a (f b) -> p (Broken a) (f (Broken b)) theBroken = dimap _theBroken (fmap Broken) {-# INLINE theBroken #-}

@@ -5,6 +5,7 @@   , theCached   ) where +import           Control.Comonad (Comonad) import           Control.DeepSeq (NFData) import           Control.Monad.Fix (MonadFix) import           Control.Monad.Zip (MonadZip)@@ -64,7 +65,7 @@            , MonadFix            , Monad            , MonadZip-+           , Comonad            )            via Identity 

@@ -5,6 +5,7 @@   , theComplete   ) where +import           Control.Comonad (Comonad) import           Control.DeepSeq (NFData) import           Control.Monad.Fix (MonadFix) import           Control.Monad.Zip (MonadZip)@@ -64,7 +65,7 @@            , MonadFix            , Monad            , MonadZip-+           , Comonad            )            via Identity 

@@ -3,8 +3,12 @@   ( Consistent(Consistent)   , _theConsistent   , theConsistent+  , ConsistentTo(ConsistentTo)+  , _theConsistentTo+  , theConsistentTo   ) where +import           Control.Comonad (Comonad) import           Control.DeepSeq (NFData) import           Control.Monad.Fix (MonadFix) import           Control.Monad.Zip (MonadZip)@@ -23,6 +27,7 @@ import           System.Random   (Random) import           Test.QuickCheck (Arbitrary) +-- | A wrapper for something that is `Consistent`. newtype Consistent a = Consistent a   deriving ( Eq            , Ord@@ -64,14 +69,74 @@            , MonadFix            , Monad            , MonadZip-+           , Comonad            )            via Identity +-- | An accessor function for something 'Consistent'. _theConsistent :: Consistent x -> x _theConsistent (Consistent !x) = x {-# INLINE _theConsistent #-} +-- | A lens for something 'Consistent'. theConsistent :: forall a b p f. (Profunctor p, Functor f) => p a (f b) -> p (Consistent a) (f (Consistent b)) theConsistent = dimap _theConsistent (fmap Consistent) {-# INLINE theConsistent #-}+++-- | A wrapper for something that is `ConsistentTo` some context+-- indicated by a (phantom-) type.+newtype ConsistentTo ctx a = ConsistentTo a+  deriving ( Eq+           , Ord+           , Read+           , Show+           , NFData+           , Foldable+           , Traversable+           , Functor+           , Default+           , Monoid+           , Semigroup+           , Typeable+           , Generic+           , Generic1+           , Random+           , Arbitrary+           , Bounded+           , Enum+           , Floating+           , Fractional+           , Integral+           , Num+           , Real+           , RealFloat+           , RealFrac+           , Ix+           , IsString+           , Bits+           , FiniteBits+           )+  deriving ( Eq1+           , Ord1+           , Read1+           , Show1+           , Pointed+           , Copointed+           , Applicative+           , MonadFix+           , Monad+           , MonadZip+           , Comonad+           )+           via Identity++-- | An accessor function for something 'ConsistentTo'.+_theConsistentTo :: ConsistentTo ctx x -> x+_theConsistentTo (ConsistentTo !x) = x+{-# INLINE _theConsistentTo #-}++-- | A lens for something 'ConsistentTo'.+theConsistentTo :: forall ctx a b p f. (Profunctor p, Functor f) => p a (f b) -> p (ConsistentTo ctx a) (f (ConsistentTo ctx b))+theConsistentTo = dimap _theConsistentTo (fmap ConsistentTo)+{-# INLINE theConsistentTo #-}