packages feed

category 0.2.0.1 → 0.2.1.0

raw patch · 5 files changed

+100/−2 lines, 5 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Control.Category.Const2: instance (Data.Semigroup.Semigroup a, Algebra.Group a) => Control.Category.Groupoid.Groupoid (Control.Category.Const2.Const2 a)
- Control.Category.Const2: instance (Data.Semigroup.Semigroup a, GHC.Base.Monoid a) => Control.Category.Category (Control.Category.Const2.Const2 a)
- Control.Category.Const2: instance forall a k1 (b :: k1) k2 (c :: k2). Data.Semigroup.Semigroup a => Data.Semigroup.Semigroup (Control.Category.Const2.Const2 a b c)
- Control.Category.Dual: instance forall k1 k2 (k3 :: k2 -> k1 -> *) (a :: k1) (b :: k2). Data.Semigroup.Semigroup (k3 b a) => Data.Semigroup.Semigroup (Control.Category.Dual.Dual k3 a b)
- Data.Morphism.Endo: instance forall k (s :: k -> k -> *) (a :: k). Control.Category.Category s => Data.Semigroup.Semigroup (Data.Morphism.Endo.Endo s a)
- Data.Morphism.Iso: instance forall k (s :: k -> k -> *) (a :: k) (b :: k). (Data.Semigroup.Semigroup (s a b), Data.Semigroup.Semigroup (s b a)) => Data.Semigroup.Semigroup (Data.Morphism.Iso.Iso s a b)
- Data.Morphism.Iso: instance forall k (s :: k -> k -> *) (a :: k) (b :: k). (Data.Semigroup.Semigroup (s a b), Data.Semigroup.Semigroup (s b a), Algebra.Group (s a b), Algebra.Group (s b a)) => Algebra.Group (Data.Morphism.Iso.Iso s a b)
- Data.Morphism.Iso: instance forall k (s :: k -> k -> *) (a :: k) (b :: k). (Data.Semigroup.Semigroup (s a b), Data.Semigroup.Semigroup (s b a), GHC.Base.Monoid (s a b), GHC.Base.Monoid (s b a)) => GHC.Base.Monoid (Data.Morphism.Iso.Iso s a b)
+ Control.Categorical.Monad: (<=<) :: Monad s m => (b `s` m c) -> (a `s` m b) -> a `s` m c
+ Control.Categorical.Monad: (=<=) :: Comonad s ɯ => (ɯ b `s` c) -> (ɯ a `s` b) -> ɯ a `s` c
+ Control.Categorical.Monad: (=>=) :: Comonad s ɯ => (ɯ a `s` b) -> (ɯ b `s` c) -> ɯ a `s` c
+ Control.Categorical.Monad: (>=>) :: Monad s m => (a `s` m b) -> (b `s` m c) -> a `s` m c
+ Control.Categorical.Monad: Cokleisli :: (ɯ a `s` b) -> Cokleisli s ɯ a b
+ Control.Categorical.Monad: Kleisli :: (a `s` m b) -> Kleisli s m a b
+ Control.Categorical.Monad: [cokleisli] :: Cokleisli s ɯ a b -> ɯ a `s` b
+ Control.Categorical.Monad: [kleisli] :: Kleisli s m a b -> a `s` m b
+ Control.Categorical.Monad: bind :: Monad s m => (a `s` m b) -> m a `s` m b
+ Control.Categorical.Monad: class Endofunctor s ɯ => Comonad s ɯ
+ Control.Categorical.Monad: class Endofunctor s m => Monad s m
+ Control.Categorical.Monad: cobind :: Comonad s ɯ => (ɯ a `s` b) -> ɯ a `s` ɯ b
+ Control.Categorical.Monad: counit :: Comonad s ɯ => ɯ a `s` a
+ Control.Categorical.Monad: cut :: Comonad s ɯ => ɯ a `s` ɯ (ɯ a)
+ Control.Categorical.Monad: infixr 1 =>=
+ Control.Categorical.Monad: instance Control.Categorical.Monad.Comonad (->) ((,) a)
+ Control.Categorical.Monad: instance Control.Categorical.Monad.Comonad (->) (Data.Semigroup.Arg a)
+ Control.Categorical.Monad: instance Control.Categorical.Monad.Comonad (->) Data.Functor.Identity.Identity
+ Control.Categorical.Monad: instance Control.Categorical.Monad.Comonad (->) GHC.Base.NonEmpty
+ Control.Categorical.Monad: instance GHC.Base.Monad m => Control.Categorical.Monad.Monad (->) m
+ Control.Categorical.Monad: instance GHC.Base.Monoid m => Control.Categorical.Monad.Comonad (->) ((->) m)
+ Control.Categorical.Monad: instance forall k (s :: k -> k -> *) (m :: k -> k). Control.Categorical.Monad.Monad s m => Control.Category.Category (Control.Categorical.Monad.Kleisli s m)
+ Control.Categorical.Monad: instance forall k (s :: k -> k -> *) (ɯ :: k -> k). Control.Categorical.Monad.Comonad s ɯ => Control.Category.Category (Control.Categorical.Monad.Cokleisli s ɯ)
+ Control.Categorical.Monad: join :: Monad s m => m (m a) `s` m a
+ Control.Categorical.Monad: newtype Cokleisli s ɯ a b
+ Control.Categorical.Monad: newtype Kleisli s m a b
+ Control.Categorical.Monad: unit :: Monad s m => a `s` m a
+ Control.Category.Const2: instance (GHC.Base.Semigroup a, Algebra.Group a) => Control.Category.Groupoid.Groupoid (Control.Category.Const2.Const2 a)
+ Control.Category.Const2: instance (GHC.Base.Semigroup a, GHC.Base.Monoid a) => Control.Category.Category (Control.Category.Const2.Const2 a)
+ Control.Category.Const2: instance forall a k1 (b :: k1) k2 (c :: k2). GHC.Base.Semigroup a => GHC.Base.Semigroup (Control.Category.Const2.Const2 a b c)
+ Control.Category.Dual: instance forall k1 k2 (k3 :: k2 -> k1 -> *) (a :: k1) (b :: k2). GHC.Base.Semigroup (k3 b a) => GHC.Base.Semigroup (Control.Category.Dual.Dual k3 a b)
+ Data.Morphism.Endo: instance forall k (s :: k -> k -> *) (a :: k). Control.Category.Category s => GHC.Base.Semigroup (Data.Morphism.Endo.Endo s a)
+ Data.Morphism.Iso: instance forall k (s :: k -> k -> *) (a :: k) (b :: k). (GHC.Base.Semigroup (s a b), GHC.Base.Semigroup (s b a)) => GHC.Base.Semigroup (Data.Morphism.Iso.Iso s a b)
+ Data.Morphism.Iso: instance forall k (s :: k -> k -> *) (a :: k) (b :: k). (GHC.Base.Semigroup (s a b), GHC.Base.Semigroup (s b a), Algebra.Group (s a b), Algebra.Group (s b a)) => Algebra.Group (Data.Morphism.Iso.Iso s a b)
+ Data.Morphism.Iso: instance forall k (s :: k -> k -> *) (a :: k) (b :: k). (GHC.Base.Semigroup (s a b), GHC.Base.Semigroup (s b a), GHC.Base.Monoid (s a b), GHC.Base.Monoid (s b a)) => GHC.Base.Monoid (Data.Morphism.Iso.Iso s a b)
- Data.Morphism.Iso: Iso :: (s a b) -> (s b a) -> Iso s a b
+ Data.Morphism.Iso: Iso :: s a b -> s b a -> Iso s a b

Files

Control/Categorical/Functor.hs view
@@ -12,6 +12,12 @@ import Data.Functor.Sum import Data.Proxy +-- | Laws:+--+-- @+-- 'map' 'id' = 'id'+-- 'map' (f '.' g) = 'map' f '.' 'map' g+-- @ class (Category s, Category t) => Functor (s :: α -> α -> *) (t :: β -> β -> *) (f :: α -> β) where     map :: s a b -> t (f a) (f b) 
+ Control/Categorical/Monad.hs view
@@ -0,0 +1,81 @@+module Control.Categorical.Monad where++import qualified Control.Monad as Base+import Data.Function (($), flip)+import Data.Functor.Identity+import Data.List.NonEmpty (NonEmpty (..))+import qualified Data.List.NonEmpty as NE+import Data.Semigroup (Arg (..))++import Control.Categorical.Functor++infixr 1 >=>, <=<, =>=, =<=++class Endofunctor s m => Monad s m where+    unit :: a `s` m a++    join :: m (m a) `s` m a+    join = bind id++    bind :: a `s` m b -> m a `s` m b+    bind f = join . map f++(<=<) :: Monad s m => b `s` m c -> a `s` m b -> a `s` m c+f <=< g = bind f . bind g . unit++(>=>) :: Monad s m => a `s` m b -> b `s` m c -> a `s` m c+(>=>) = flip (<=<)++newtype Kleisli s m a b = Kleisli { kleisli :: a `s` m b }++instance Monad s m => Category (Kleisli s m) where+    id = Kleisli unit+    Kleisli f . Kleisli g = Kleisli (f <=< g)++instance {-# INCOHERENT #-} Base.Monad m => Monad (->) m where+    unit = Base.return+    join = Base.join+    bind = (Base.=<<)++class Endofunctor s ɯ => Comonad s ɯ where+    counit :: ɯ a `s` a++    cut :: ɯ a `s` ɯ (ɯ a)+    cut = cobind id++    cobind :: ɯ a `s` b -> ɯ a `s` ɯ b+    cobind f = map f . cut++(=<=) :: Comonad s ɯ => ɯ b `s` c -> ɯ a `s` b -> ɯ a `s` c+f =<= g = counit . cobind f . cobind g++(=>=) :: Comonad s ɯ => ɯ a `s` b -> ɯ b `s` c -> ɯ a `s` c+(=>=) = flip (=<=)++newtype Cokleisli s ɯ a b = Cokleisli { cokleisli :: ɯ a `s` b }++instance Comonad s ɯ => Category (Cokleisli s ɯ) where+    id = Cokleisli counit+    Cokleisli f . Cokleisli g = Cokleisli (f =<= g)++instance Comonad (->) Identity where+    counit = runIdentity+    cut = map Identity++instance Comonad (->) NonEmpty where+    counit = NE.head+    cut (x:|xs) = (x:|xs) :| go xs+      where go [] = []+            go (x:xs) = (x:|xs) : go xs++instance Monoid m => Comonad (->) ((->) m) where+    counit = ($ mempty)+    cut f x y = f (x <> y)++instance Comonad (->) ((,) a) where+    counit (_, b) = b+    cut (a, b) = (a, (a, b))++instance Comonad (->) (Arg a) where+    counit (Arg _ b) = b+    cut (Arg a b) = Arg a (Arg a b)
Control/Category/Const2.hs view
@@ -3,6 +3,7 @@ import Algebra as A import Control.Category.Groupoid +-- | Notes: 'Const2' '()' is the indiscrete category. newtype Const2 a b c = Const2 a   deriving (Semigroup, Monoid, Group) 
Control/Category/Groupoid.hs view
@@ -1,4 +1,12 @@ module Control.Category.Groupoid where +-- | 'Category' where every morphism is iso+--+-- Laws:+--+-- @+-- 'id' = f '.' 'invert' f+-- 'id' = 'invert' f '.' f+-- @ class Category k => Groupoid k where     invert :: k a b -> k b a
category.cabal view
@@ -1,5 +1,5 @@ name:                category-version:             0.2.0.1+version:             0.2.1.0 synopsis:            Categorical types and classes -- description:          license:             BSD3@@ -15,6 +15,7 @@  library   exposed-modules:     Control.Categorical.Functor+                     , Control.Categorical.Monad                      , Control.Category.Const2                      , Control.Category.Dual                      , Control.Category.Groupoid@@ -26,13 +27,14 @@   default-language:    Haskell2010   default-extensions:  UnicodeSyntax                      , LambdaCase+                     , TypeOperators                      , PolyKinds                      , ConstraintKinds                      , MultiParamTypeClasses                      , FlexibleContexts                      , FlexibleInstances                      , GeneralizedNewtypeDeriving-  ghc-options:         -Wall+  ghc-options:         -Wall -Wno-name-shadowing  source-repository head   type: git