parameterized 0.3.0.0 → 0.4.0.0

raw patch · 8 files changed

+45/−26 lines, 8 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• README.md +3/−0
• parameterized.cabal +2/−2
• src/Parameterized/Control/Applicative.hs +17/−13
• src/Parameterized/Control/Monad.hs +6/−6
• src/Parameterized/Control/Monad/Trans/Reader.hs +7/−2
• src/Parameterized/Control/Monad/Trans/State/Strict.hs +4/−0
• src/Parameterized/Data/Monoid.hs +1/−1
• src/Parameterized/Data/Semigroup.hs +5/−2

@@ -7,6 +7,9 @@  # Changelog +* 0.4.0.0+  - Added PNullary and PUnary injective type families.+ * 0.3.0.0   - PMonoid is now a class with a single instance (courtesy of georgew).   - added fixities for backtick versions of pmappend, pappend, papply and pbind

@@ -1,6 +1,6 @@ name:                parameterized-version:             0.3.0.0-synopsis:            Extensible records and polymorphic variants.+version:             0.4.0.0+synopsis:            Parameterized/indexed monoids and monads using only a single parameter type variable. description:         Parameterized/indexed monoids and monads using only a single parameter type variable.  homepage:            https://github.com/louispan/parameterized#readme

@@ -3,9 +3,11 @@ {-# LANGUAGE KindSignatures #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE PolyKinds #-}+{-# LANGUAGE TypeFamilyDependencies #-}  module Parameterized.Control.Applicative-    ( PPointed(..)+    ( PUnary+    , PPointed(..)     , PApplicative(..)     , (&<*>)     , (&*>)@@ -20,6 +22,8 @@  import Data.Kind +type family PUnary (m :: k -> Type -> Type) (t :: k) = (r :: Type -> Type) | r -> m t+ -- | Parameterized version of 'pure' in 'Applicative' -- An instance of this should create a parameterized unary type -- where the parameter is an identity in respect to 'papply'@@ -29,38 +33,38 @@ -- Hint: use @ppure \@_ \@_ @id@ to specify the id type to avoid ambiguity. class PPointed (m :: k -> Type -> Type) (id :: k) where     -- | lift a value.-    ppure :: a -> m id a+    ppure :: a -> PUnary m id a  -- | Parameterized version of 'ap' in 'Applicative' -- NB. 'PPointed' cannot be made a superclass because type variable @id@ is not in scope.-class (Functor (m t), Functor (m u), Functor (m v)) =>+class (Functor (PUnary m t), Functor (PUnary m u), Functor (PUnary m v)) =>       PApplicative (m :: k -> Type -> Type) (t :: k) (u :: k) (v :: k) | t u -> v where     -- | Sequential application.-    papply :: m t (a -> b) -> m u a -> m v b+    papply :: PUnary m t (a -> b) -> PUnary m u a -> PUnary m v b   -- | Sequential application.-(&<*>) :: (PApplicative m t u v) => m t (a -> b) -> m u a -> m v b+(&<*>) :: (PApplicative m t u v) => PUnary m t (a -> b) -> PUnary m u a -> PUnary m v b (&<*>) = papply infixl 4 &<*> infixl 4 `papply`  -- | Sequence actions, discarding the value of the first argument.-(&*>) :: (PApplicative m t u v) => m t a -> m u b -> m v b+(&*>) :: (PApplicative m t u v) => PUnary m t a -> PUnary m u b -> PUnary m v b a1 &*> a2 = (id <$ a1) &<*> a2 infixl 4 &*>  -- | Sequence actions, discarding the value of the second argument.-(&<*) :: (PApplicative m t u v) => m t a -> m u b -> m v a+(&<*) :: (PApplicative m t u v) => PUnary m t a -> PUnary m u b -> PUnary m v a (&<*) = pliftA2 const infixl 4 &<*  -- | Lift a function to actions.-pliftA :: (Functor (m t)) => (a -> b) -> m t a -> m t b+pliftA :: (Functor (PUnary m t)) => (a -> b) -> PUnary m t a -> PUnary m t b pliftA f x = f <$> x  -- | Lift a binary function to actions.-pliftA2 :: (PApplicative m t u v) => (a -> b -> c) -> m t a -> m u b -> m v c+pliftA2 :: (PApplicative m t u v) => (a -> b -> c) -> PUnary m t a -> PUnary m u b -> PUnary m v c pliftA2 f x y = (f <$> x) `papply` y  -- | Lift a ternary function to actions.@@ -68,7 +72,7 @@     :: ( PApplicative m t u v        , PApplicative m v w x        )-    => (a -> b -> c -> d) -> m t a -> m u b -> m w c -> m x d+    => (a -> b -> c -> d) -> PUnary m t a -> PUnary m u b -> PUnary m w c -> PUnary m x d pliftA3 f a b c = pliftA2 f a b &<*> c  -- | Parameterized version of empty in 'Alternative'.@@ -76,7 +80,7 @@ -- where the parameter is an identity in respect to 'pappend' class PEmpty (m :: k -> Type -> Type) (id :: k) | m -> id where     -- | The identity of '&<|>'-    pempty :: m id a+    pempty :: PUnary m id a  -- | Parameterized version of 'Alternative' -- NB. 'PEmpty' cannot be made a superclass because type variable @id@ will be ambiguous.@@ -84,9 +88,9 @@ -- Some things can be made instances of 'PAlternative' but not 'PApplicative'. class PAlternative (m :: k -> Type -> Type) (t :: k) (u :: k) (v :: k) | t u -> v where     -- | An associative binary operation-    pappend :: m t a -> m u a -> m v a+    pappend :: PUnary m t a -> PUnary m u a -> PUnary m v a -(&<|>) :: (PAlternative m t u v) => m t a -> m u a -> m v a+(&<|>) :: (PAlternative m t u v) => PUnary m t a -> PUnary m u a -> PUnary m v a (&<|>) = pappend infixl 3 &<|> infixl 3 `pappend`

@@ -20,30 +20,30 @@ -- | Parameterized version of Monad. class PApplicative m t u v => PMonad (m :: k -> Type -> Type) (t :: k) (u :: k) (v :: k) where     -- | Sequentially compose two actions, passing any value produced by the first as an argument to the second.-    pbind :: m t a -> (a -> m u b) -> m v b+    pbind :: PUnary m t a -> (a -> PUnary m u b) -> PUnary m v b  -- | Sequentially compose two actions, passing any value produced by the first as an argument to the second.-(&>>=) :: PMonad m t u v => m t a -> (a -> m u b) -> m v b+(&>>=) :: PMonad m t u v => PUnary m t a -> (a -> PUnary m u b) -> PUnary m v b (&>>=) = pbind infixl 1 &>>= infixl 1 `pbind` -(&>>) :: PMonad m t u v => m t a -> m u b -> m v b+(&>>) :: PMonad m t u v => PUnary m t a -> PUnary m u b -> PUnary m v b m &>> k = m &>>= \_ -> k infixl 1 &>>  -- | Same as '&>>=', but with the arguments interchanged.-(&=<<) :: PMonad m t u v => (a -> m u b) -> m t a -> m v b+(&=<<) :: PMonad m t u v => (a -> PUnary m u b) -> PUnary m t a -> PUnary m v b f &=<< x = x &>>= f infixr 1 &=<<  -- | Left-to-right Kleisli composition of monads.-(&>=>) :: (PMonad m t u v) => (a -> m t b) -> (b -> m u c) -> (a -> m v c)+(&>=>) :: (PMonad m t u v) => (a -> PUnary m t b) -> (b -> PUnary m u c) -> (a -> PUnary m v c) f &>=> g = \x -> f x &>>= g infixr 1 &>=>  -- | Right-to-left Kleisli composition of monads. @('>=>')@, with the arguments flipped.-(&<=<) :: (PMonad m t u v) => (b -> m u c) -> (a -> m t b) -> (a -> m v c)+(&<=<) :: (PMonad m t u v) => (b -> PUnary m u c) -> (a -> PUnary m t b) -> (a -> PUnary m v c) (&<=<) = flip (&>=>) infixr 1 &<=< 

@@ -39,6 +39,8 @@                , MonadIO                ) +type instance PUnary (OverlappingWhichReader m) r = OverlappingWhichReader m r+ instance Applicative m => PPointed (OverlappingWhichReader m) (Which '[]) where     ppure = OverlappingWhichReader . pure @@ -81,6 +83,8 @@                , MonadIO                ) +type instance PUnary (DistinctWhichReader m) r = DistinctWhichReader m r+ instance Applicative m => PPointed (DistinctWhichReader m) (Which '[]) where     ppure = DistinctWhichReader . pure @@ -117,6 +121,8 @@                , MonadIO                ) +type instance PUnary (ManyReader m) r = ManyReader m r+ instance Applicative m => PPointed (ManyReader m) (Many '[]) where     ppure = ManyReader . pure @@ -133,8 +139,7 @@     papply (ManyReader (ReaderT f)) (ManyReader (ReaderT g)) =         ManyReader . ReaderT $ \c -> f (select c) <*> g (select c) -instance ( Functor (ManyReader m (Many c))-         , Alternative m+instance ( Alternative m          , Select a c          , Select b c          , c ~ AppendUnique a b

@@ -38,6 +38,8 @@                , MonadIO                ) +type instance PUnary (ManyState m) s = ManyState m s+ instance Monad m => PPointed (ManyState m) (Many '[]) where     ppure = ManyState . pure @@ -111,6 +113,8 @@ -- as it avoids ambiguous type variable @st@ changingState :: (s -> m (a, t)) -> ChangingState m (s, t) a changingState = ChangingState++type instance PUnary (ChangingState m) st = ChangingState m st  instance Functor m => Functor (ChangingState m st) where     fmap f m = ChangingState $ \s ->

@@ -17,7 +17,7 @@  -- | Parameterized version of mempty in Monoid. class PMEmpty (n :: k -> Type) (id :: k) | n -> id where-    pmempty :: n id+    pmempty :: PNullary n id  -- | Parameterized version of Monoid. class (PSemigroup n t u v, PMEmpty n id) => PMonoid n id t u v

@@ -2,11 +2,14 @@ {-# LANGUAGE KindSignatures #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE PolyKinds #-}+{-# LANGUAGE TypeFamilyDependencies #-}  module Parameterized.Data.Semigroup where  import Data.Kind +type family PNullary (n :: k -> Type) (t :: k) = (r :: Type) | r -> n t+ -- | Parameterized version of (<>) in Semigroup -- If used in conjunction with 'Parameterized.Data.Empty', ie as a parameterized Monoid, -- then the instance should follow the following laws:@@ -14,9 +17,9 @@ --  * @x `pmappend'` pempty' = x@ --  * @x `pmappend'` (y `pmappend'` z) = (x `pmappend'` y) `pmappend'` z@ class PSemigroup (n :: k -> Type) (t :: k) (u :: k) (v :: k) | t u -> v where-    pmappend :: n t -> n u -> n v+    pmappend :: PNullary n t -> PNullary n u -> PNullary n v -(&<>) :: (PSemigroup n t u v) => n t -> n u -> n v+(&<>) :: (PSemigroup n t u v) => PNullary n t -> PNullary n u -> PNullary n v (&<>) = pmappend infixr 6 &<> infixr 6 `pmappend`