constrained-categories 0.4.0.0 → 0.4.1.0

raw patch · 13 files changed

+31/−20 lines, 13 filesdep +faildep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: fail

Dependency ranges changed: base

API changes (from Hackage documentation)

- Control.Category.Constrained: instance (Control.Category.Constrained.Cartesian k, Control.Category.Constrained.Object k a, u Data.Type.Equality.~ Control.Category.Constrained.UnitObject k, Control.Category.Constrained.ObjectPair k a u, Control.Category.Constrained.ObjectPair k u a, Control.Category.Constrained.Object k (u, a), Control.Category.Constrained.Object k (a, u)) => Control.Category.Constrained.Isomorphic k (u, a) a

- Control.Category.Constrained: instance (Control.Category.Constrained.CoCartesian k, Control.Category.Constrained.Object k a, u Data.Type.Equality.~ Control.Category.Constrained.ZeroObject k, Control.Category.Constrained.ObjectSum k a u, Control.Category.Constrained.ObjectSum k u a, Control.Category.Constrained.Object k (u Control.Category.Constrained.+ a), Control.Category.Constrained.Object k (a Control.Category.Constrained.+ u)) => Control.Category.Constrained.Isomorphic k (u Control.Category.Constrained.+ a) a

- Control.Monad.Constrained: instance (GHC.Base.MonadPlus m, GHC.Base.Applicative m) => Control.Monad.Constrained.MonadFail m (->)

- Data.Foldable.Constrained: instance (Control.Applicative.Constrained.Monoidal f k k, Control.Arrow.Constrained.Function k, u Data.Type.Equality.~ Control.Category.Constrained.UnitObject k, GHC.Base.Semigroup u, GHC.Base.Monoid u, Control.Category.Constrained.ObjectPair k u u, Control.Category.Constrained.ObjectPair k (f u) (f u), Control.Category.Constrained.Object k (f u, f u)) => GHC.Base.Monoid (Data.Foldable.Constrained.Monoidal_ k k f u)

- Data.Foldable.Constrained: instance (Control.Applicative.Constrained.Monoidal f k k, Control.Arrow.Constrained.Function k, u Data.Type.Equality.~ Control.Category.Constrained.UnitObject k, GHC.Base.Semigroup u, GHC.Base.Monoid u, Control.Category.Constrained.ObjectPair k u u, Control.Category.Constrained.ObjectPair k (f u) (f u), Control.Category.Constrained.Object k (f u, f u)) => GHC.Base.Semigroup (Data.Foldable.Constrained.Monoidal_ k k f u)

+ Control.Category.Constrained: instance (Control.Category.Constrained.Cartesian k, Control.Category.Constrained.Object k a, u GHC.Types.~ Control.Category.Constrained.UnitObject k, Control.Category.Constrained.ObjectPair k a u, Control.Category.Constrained.ObjectPair k u a, Control.Category.Constrained.Object k (u, a), Control.Category.Constrained.Object k (a, u)) => Control.Category.Constrained.Isomorphic k (u, a) a

+ Control.Category.Constrained: instance (Control.Category.Constrained.CoCartesian k, Control.Category.Constrained.Object k a, u GHC.Types.~ Control.Category.Constrained.ZeroObject k, Control.Category.Constrained.ObjectSum k a u, Control.Category.Constrained.ObjectSum k u a, Control.Category.Constrained.Object k (u Control.Category.Constrained.+ a), Control.Category.Constrained.Object k (a Control.Category.Constrained.+ u)) => Control.Category.Constrained.Isomorphic k (u Control.Category.Constrained.+ a) a

+ Control.Category.Hask: class Monad m => MonadFail (m :: Type -> Type)

+ Control.Monad.Constrained: instance (GHC.Base.MonadPlus m, GHC.Base.Applicative m, Control.Monad.Fail.MonadFail m) => Control.Monad.Constrained.MonadFail m (->)

+ Data.Foldable.Constrained: instance (Control.Applicative.Constrained.Monoidal f k k, Control.Arrow.Constrained.Function k, u GHC.Types.~ Control.Category.Constrained.UnitObject k, GHC.Base.Semigroup u, GHC.Base.Monoid u, Control.Category.Constrained.ObjectPair k u u, Control.Category.Constrained.ObjectPair k (f u) (f u), Control.Category.Constrained.Object k (f u, f u)) => GHC.Base.Monoid (Data.Foldable.Constrained.Monoidal_ k k f u)

+ Data.Foldable.Constrained: instance (Control.Applicative.Constrained.Monoidal f k k, Control.Arrow.Constrained.Function k, u GHC.Types.~ Control.Category.Constrained.UnitObject k, GHC.Base.Semigroup u, GHC.Base.Monoid u, Control.Category.Constrained.ObjectPair k u u, Control.Category.Constrained.ObjectPair k (f u) (f u), Control.Category.Constrained.Object k (f u, f u)) => GHC.Base.Semigroup (Data.Foldable.Constrained.Monoidal_ k k f u)

- Control.Category.Constrained: ConstrainedMorphism :: k a b -> ConstrainedCategory

+ Control.Category.Constrained: ConstrainedMorphism :: k a b -> ConstrainedCategory (k :: * -> * -> *) (o :: * -> Constraint) (a :: *) (b :: *)

- Control.Category.Constrained: class Category k where {

+ Control.Category.Constrained: class Category (k :: κ -> κ -> Type) where {

- Control.Category.Constrained.Prelude: (!!) :: () => [a] -> Int -> a

+ Control.Category.Constrained.Prelude: (!!) :: [a] -> Int -> a

- Control.Category.Constrained.Prelude: ($!) :: () => (a -> b) -> a -> b

+ Control.Category.Constrained.Prelude: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b

- Control.Category.Constrained.Prelude: (++) :: () => [a] -> [a] -> [a]

+ Control.Category.Constrained.Prelude: (++) :: [a] -> [a] -> [a]

- Control.Category.Constrained.Prelude: -- | Defaults to '()', and should normally be left at that.

+ Control.Category.Constrained.Prelude: -- | Defaults to <tt>()</tt>, and should normally be left at that.

- Control.Category.Constrained.Prelude: ConstrainedMorphism :: k a b -> ConstrainedCategory

+ Control.Category.Constrained.Prelude: ConstrainedMorphism :: k a b -> ConstrainedCategory (k :: * -> * -> *) (o :: * -> Constraint) (a :: *) (b :: *)

- Control.Category.Constrained.Prelude: asTypeOf :: () => a -> a -> a

+ Control.Category.Constrained.Prelude: asTypeOf :: a -> a -> a

- Control.Category.Constrained.Prelude: break :: () => (a -> Bool) -> [a] -> ([a], [a])

+ Control.Category.Constrained.Prelude: break :: (a -> Bool) -> [a] -> ([a], [a])

- Control.Category.Constrained.Prelude: class Category k where {

+ Control.Category.Constrained.Prelude: class Category (k :: κ -> κ -> Type) where {

- Control.Category.Constrained.Prelude: cycle :: () => [a] -> [a]

+ Control.Category.Constrained.Prelude: cycle :: [a] -> [a]

- Control.Category.Constrained.Prelude: drop :: () => Int -> [a] -> [a]

+ Control.Category.Constrained.Prelude: drop :: Int -> [a] -> [a]

- Control.Category.Constrained.Prelude: dropWhile :: () => (a -> Bool) -> [a] -> [a]

+ Control.Category.Constrained.Prelude: dropWhile :: (a -> Bool) -> [a] -> [a]

- Control.Category.Constrained.Prelude: either :: () => (a -> c) -> (b -> c) -> Either a b -> c

+ Control.Category.Constrained.Prelude: either :: (a -> c) -> (b -> c) -> Either a b -> c

- Control.Category.Constrained.Prelude: error :: HasCallStack => [Char] -> a

+ Control.Category.Constrained.Prelude: error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a

- Control.Category.Constrained.Prelude: errorWithoutStackTrace :: () => [Char] -> a

+ Control.Category.Constrained.Prelude: errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a

- Control.Category.Constrained.Prelude: flip :: () => (a -> b -> c) -> b -> a -> c

+ Control.Category.Constrained.Prelude: flip :: (a -> b -> c) -> b -> a -> c

- Control.Category.Constrained.Prelude: head :: () => [a] -> a

+ Control.Category.Constrained.Prelude: head :: [a] -> a

- Control.Category.Constrained.Prelude: infixl 6 -

+ Control.Category.Constrained.Prelude: infixl 6 +

- Control.Category.Constrained.Prelude: init :: () => [a] -> [a]

+ Control.Category.Constrained.Prelude: init :: [a] -> [a]

- Control.Category.Constrained.Prelude: ioError :: () => IOError -> IO a

+ Control.Category.Constrained.Prelude: ioError :: IOError -> IO a

- Control.Category.Constrained.Prelude: iterate :: () => (a -> a) -> a -> [a]

+ Control.Category.Constrained.Prelude: iterate :: (a -> a) -> a -> [a]

- Control.Category.Constrained.Prelude: last :: () => [a] -> a

+ Control.Category.Constrained.Prelude: last :: [a] -> a

- Control.Category.Constrained.Prelude: map :: () => (a -> b) -> [a] -> [b]

+ Control.Category.Constrained.Prelude: map :: (a -> b) -> [a] -> [b]

- Control.Category.Constrained.Prelude: maybe :: () => b -> (a -> b) -> Maybe a -> b

+ Control.Category.Constrained.Prelude: maybe :: b -> (a -> b) -> Maybe a -> b

- Control.Category.Constrained.Prelude: readParen :: () => Bool -> ReadS a -> ReadS a

+ Control.Category.Constrained.Prelude: readParen :: Bool -> ReadS a -> ReadS a

- Control.Category.Constrained.Prelude: repeat :: () => a -> [a]

+ Control.Category.Constrained.Prelude: repeat :: a -> [a]

- Control.Category.Constrained.Prelude: replicate :: () => Int -> a -> [a]

+ Control.Category.Constrained.Prelude: replicate :: Int -> a -> [a]

- Control.Category.Constrained.Prelude: reverse :: () => [a] -> [a]

+ Control.Category.Constrained.Prelude: reverse :: [a] -> [a]

- Control.Category.Constrained.Prelude: scanl :: () => (b -> a -> b) -> b -> [a] -> [b]

+ Control.Category.Constrained.Prelude: scanl :: (b -> a -> b) -> b -> [a] -> [b]

- Control.Category.Constrained.Prelude: scanl1 :: () => (a -> a -> a) -> [a] -> [a]

+ Control.Category.Constrained.Prelude: scanl1 :: (a -> a -> a) -> [a] -> [a]

- Control.Category.Constrained.Prelude: scanr :: () => (a -> b -> b) -> b -> [a] -> [b]

+ Control.Category.Constrained.Prelude: scanr :: (a -> b -> b) -> b -> [a] -> [b]

- Control.Category.Constrained.Prelude: scanr1 :: () => (a -> a -> a) -> [a] -> [a]

+ Control.Category.Constrained.Prelude: scanr1 :: (a -> a -> a) -> [a] -> [a]

- Control.Category.Constrained.Prelude: seq :: () => a -> b -> b

+ Control.Category.Constrained.Prelude: seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b

- Control.Category.Constrained.Prelude: span :: () => (a -> Bool) -> [a] -> ([a], [a])

+ Control.Category.Constrained.Prelude: span :: (a -> Bool) -> [a] -> ([a], [a])

- Control.Category.Constrained.Prelude: splitAt :: () => Int -> [a] -> ([a], [a])

+ Control.Category.Constrained.Prelude: splitAt :: Int -> [a] -> ([a], [a])

- Control.Category.Constrained.Prelude: tail :: () => [a] -> [a]

+ Control.Category.Constrained.Prelude: tail :: [a] -> [a]

- Control.Category.Constrained.Prelude: take :: () => Int -> [a] -> [a]

+ Control.Category.Constrained.Prelude: take :: Int -> [a] -> [a]

- Control.Category.Constrained.Prelude: takeWhile :: () => (a -> Bool) -> [a] -> [a]

+ Control.Category.Constrained.Prelude: takeWhile :: (a -> Bool) -> [a] -> [a]

- Control.Category.Constrained.Prelude: type family Object k o :: Constraint;

+ Control.Category.Constrained.Prelude: type family Object k (o :: κ) :: Constraint;

- Control.Category.Constrained.Prelude: undefined :: HasCallStack => a

+ Control.Category.Constrained.Prelude: undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a

- Control.Category.Constrained.Prelude: until :: () => (a -> Bool) -> (a -> a) -> a -> a

+ Control.Category.Constrained.Prelude: until :: (a -> Bool) -> (a -> a) -> a -> a

- Control.Category.Constrained.Prelude: unzip :: () => [(a, b)] -> ([a], [b])

+ Control.Category.Constrained.Prelude: unzip :: [(a, b)] -> ([a], [b])

- Control.Category.Constrained.Prelude: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])

+ Control.Category.Constrained.Prelude: unzip3 :: [(a, b, c)] -> ([a], [b], [c])

- Control.Category.Constrained.Prelude: zip :: () => [a] -> [b] -> [(a, b)]

+ Control.Category.Constrained.Prelude: zip :: [a] -> [b] -> [(a, b)]

- Control.Category.Constrained.Prelude: zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]

+ Control.Category.Constrained.Prelude: zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]

- Control.Category.Constrained.Prelude: zipWith :: () => (a -> b -> c) -> [a] -> [b] -> [c]

+ Control.Category.Constrained.Prelude: zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

- Control.Category.Constrained.Prelude: zipWith3 :: () => (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]

+ Control.Category.Constrained.Prelude: zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]

- Control.Category.Constrained.Reified.PolyPattern: pattern Specific :: forall (k :: Type -> Type -> Type) α β. CRCategory k => () => SpecificCat k α β -> k α β

+ Control.Category.Constrained.Reified.PolyPattern: pattern Specific :: CRCategory k => SpecificCat k α β -> k α β

- Control.Category.Constrained.Reified.PolyPattern: pattern Terminal :: forall (k :: Type -> Type -> Type) α β. CRPreArrow k => (Object k α, UnitObject k ~ β) => k α β

+ Control.Category.Constrained.Reified.PolyPattern: pattern Terminal :: CRPreArrow k => (Object k α, UnitObject k ~ β) => k α β

- Control.Category.Constrained.Reified.PolyPattern: pattern Const :: forall (k :: Type -> Type -> Type) α β. CRWellPointed k => (Object k α, Object k β) => β -> k α β

+ Control.Category.Constrained.Reified.PolyPattern: pattern Const :: forall k α β. CRWellPointed k => (Object k α, Object k β) => β -> k α β

- Control.Category.Hask: (!!) :: () => [a] -> Int -> a

+ Control.Category.Hask: (!!) :: [a] -> Int -> a

- Control.Category.Hask: ($!) :: () => (a -> b) -> a -> b

+ Control.Category.Hask: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b

- Control.Category.Hask: ($) :: () => (a -> b) -> a -> b

+ Control.Category.Hask: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b

- Control.Category.Hask: (++) :: () => [a] -> [a] -> [a]

+ Control.Category.Hask: (++) :: [a] -> [a] -> [a]

- Control.Category.Hask: asTypeOf :: () => a -> a -> a

+ Control.Category.Hask: asTypeOf :: a -> a -> a

- Control.Category.Hask: break :: () => (a -> Bool) -> [a] -> ([a], [a])

+ Control.Category.Hask: break :: (a -> Bool) -> [a] -> ([a], [a])

- Control.Category.Hask: const :: () => a -> b -> a

+ Control.Category.Hask: const :: a -> b -> a

- Control.Category.Hask: curry :: () => ((a, b) -> c) -> a -> b -> c

+ Control.Category.Hask: curry :: ((a, b) -> c) -> a -> b -> c

- Control.Category.Hask: cycle :: () => [a] -> [a]

+ Control.Category.Hask: cycle :: [a] -> [a]

- Control.Category.Hask: drop :: () => Int -> [a] -> [a]

+ Control.Category.Hask: drop :: Int -> [a] -> [a]

- Control.Category.Hask: dropWhile :: () => (a -> Bool) -> [a] -> [a]

+ Control.Category.Hask: dropWhile :: (a -> Bool) -> [a] -> [a]

- Control.Category.Hask: either :: () => (a -> c) -> (b -> c) -> Either a b -> c

+ Control.Category.Hask: either :: (a -> c) -> (b -> c) -> Either a b -> c

- Control.Category.Hask: error :: HasCallStack => [Char] -> a

+ Control.Category.Hask: error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a

- Control.Category.Hask: errorWithoutStackTrace :: () => [Char] -> a

+ Control.Category.Hask: errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a

- Control.Category.Hask: fail :: Monad m => String -> m a

+ Control.Category.Hask: fail :: MonadFail m => String -> m a

- Control.Category.Hask: filter :: () => (a -> Bool) -> [a] -> [a]

+ Control.Category.Hask: filter :: (a -> Bool) -> [a] -> [a]

- Control.Category.Hask: flip :: () => (a -> b -> c) -> b -> a -> c

+ Control.Category.Hask: flip :: (a -> b -> c) -> b -> a -> c

- Control.Category.Hask: fst :: () => (a, b) -> a

+ Control.Category.Hask: fst :: (a, b) -> a

- Control.Category.Hask: head :: () => [a] -> a

+ Control.Category.Hask: head :: [a] -> a

- Control.Category.Hask: infixl 6 -

+ Control.Category.Hask: infixl 6 +

- Control.Category.Hask: init :: () => [a] -> [a]

+ Control.Category.Hask: init :: [a] -> [a]

- Control.Category.Hask: ioError :: () => IOError -> IO a

+ Control.Category.Hask: ioError :: IOError -> IO a

- Control.Category.Hask: iterate :: () => (a -> a) -> a -> [a]

+ Control.Category.Hask: iterate :: (a -> a) -> a -> [a]

- Control.Category.Hask: last :: () => [a] -> a

+ Control.Category.Hask: last :: [a] -> a

- Control.Category.Hask: map :: () => (a -> b) -> [a] -> [b]

+ Control.Category.Hask: map :: (a -> b) -> [a] -> [b]

- Control.Category.Hask: maybe :: () => b -> (a -> b) -> Maybe a -> b

+ Control.Category.Hask: maybe :: b -> (a -> b) -> Maybe a -> b

- Control.Category.Hask: readParen :: () => Bool -> ReadS a -> ReadS a

+ Control.Category.Hask: readParen :: Bool -> ReadS a -> ReadS a

- Control.Category.Hask: repeat :: () => a -> [a]

+ Control.Category.Hask: repeat :: a -> [a]

- Control.Category.Hask: replicate :: () => Int -> a -> [a]

+ Control.Category.Hask: replicate :: Int -> a -> [a]

- Control.Category.Hask: reverse :: () => [a] -> [a]

+ Control.Category.Hask: reverse :: [a] -> [a]

- Control.Category.Hask: scanl :: () => (b -> a -> b) -> b -> [a] -> [b]

+ Control.Category.Hask: scanl :: (b -> a -> b) -> b -> [a] -> [b]

- Control.Category.Hask: scanl1 :: () => (a -> a -> a) -> [a] -> [a]

+ Control.Category.Hask: scanl1 :: (a -> a -> a) -> [a] -> [a]

- Control.Category.Hask: scanr :: () => (a -> b -> b) -> b -> [a] -> [b]

+ Control.Category.Hask: scanr :: (a -> b -> b) -> b -> [a] -> [b]

- Control.Category.Hask: scanr1 :: () => (a -> a -> a) -> [a] -> [a]

+ Control.Category.Hask: scanr1 :: (a -> a -> a) -> [a] -> [a]

- Control.Category.Hask: seq :: () => a -> b -> b

+ Control.Category.Hask: seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b

- Control.Category.Hask: snd :: () => (a, b) -> b

+ Control.Category.Hask: snd :: (a, b) -> b

- Control.Category.Hask: span :: () => (a -> Bool) -> [a] -> ([a], [a])

+ Control.Category.Hask: span :: (a -> Bool) -> [a] -> ([a], [a])

- Control.Category.Hask: splitAt :: () => Int -> [a] -> ([a], [a])

+ Control.Category.Hask: splitAt :: Int -> [a] -> ([a], [a])

- Control.Category.Hask: tail :: () => [a] -> [a]

+ Control.Category.Hask: tail :: [a] -> [a]

- Control.Category.Hask: take :: () => Int -> [a] -> [a]

+ Control.Category.Hask: take :: Int -> [a] -> [a]

- Control.Category.Hask: takeWhile :: () => (a -> Bool) -> [a] -> [a]

+ Control.Category.Hask: takeWhile :: (a -> Bool) -> [a] -> [a]

- Control.Category.Hask: uncurry :: () => (a -> b -> c) -> (a, b) -> c

+ Control.Category.Hask: uncurry :: (a -> b -> c) -> (a, b) -> c

- Control.Category.Hask: undefined :: HasCallStack => a

+ Control.Category.Hask: undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a

- Control.Category.Hask: until :: () => (a -> Bool) -> (a -> a) -> a -> a

+ Control.Category.Hask: until :: (a -> Bool) -> (a -> a) -> a -> a

- Control.Category.Hask: unzip :: () => [(a, b)] -> ([a], [b])

+ Control.Category.Hask: unzip :: [(a, b)] -> ([a], [b])

- Control.Category.Hask: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])

+ Control.Category.Hask: unzip3 :: [(a, b, c)] -> ([a], [b], [c])

- Control.Category.Hask: zip :: () => [a] -> [b] -> [(a, b)]

+ Control.Category.Hask: zip :: [a] -> [b] -> [(a, b)]

- Control.Category.Hask: zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]

+ Control.Category.Hask: zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]

- Control.Category.Hask: zipWith :: () => (a -> b -> c) -> [a] -> [b] -> [c]

+ Control.Category.Hask: zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

- Control.Category.Hask: zipWith3 :: () => (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]

+ Control.Category.Hask: zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]

Files

Control/Applicative/Constrained.hs +1/−1
Control/Arrow/Constrained.hs +1/−1
Control/Category/Constrained.hs +11/−3
Control/Category/Constrained/Prelude.hs +2/−2
Control/Category/Constrained/Reified.hs +1/−1
Control/Category/Constrained/Reified/PolyPattern.hs +1/−1
Control/Category/Discrete.hs +1/−1
Control/Category/Hask.hs +1/−1
Control/Functor/Constrained.hs +1/−1
Control/Monad/Constrained.hs +5/−3
Data/Foldable/Constrained.hs +1/−1
Data/Traversable/Constrained.hs +1/−1
constrained-categories.cabal +4/−3

Control/Applicative/Constrained.hs view

@@ -2,7 +2,7 @@ -- Module      :  Control.Applicative.Constrained -- Copyright   :  (c) 2013 Justus Sagemüller -- License     :  GPL v3 (see COPYING)--- Maintainer  :  (@) sagemueller $ geo.uni-koeln.de+-- Maintainer  :  (@) jsag $ hvl.no --  {-# LANGUAGE ConstraintKinds              #-} {-# LANGUAGE TypeFamilies                 #-}

Control/Arrow/Constrained.hs view

@@ -2,7 +2,7 @@ -- Module      :  Control.Arrow.Constrained -- Copyright   :  (c) 2013 Justus Sagemüller -- License     :  GPL v3 (see COPYING)--- Maintainer  :  (@) sagemueller $ geo.uni-koeln.de+-- Maintainer  :  (@) jsag $ hvl.no --  -- Haskell's 'Arr.Arrow's, going back to [Hughes 2000], combine multiple ideas from -- category theory:

Control/Category/Constrained.hs view

@@ -2,13 +2,14 @@ -- Module      :  Control.Category.Constrained -- Copyright   :  (c) 2013-2016 Justus Sagemüller -- License     :  GPL v3 (see COPYING)--- Maintainer  :  (@) sagemueller $ geo.uni-koeln.de+-- Maintainer  :  (@) jsag $ hvl.no --  --  -- The most basic category theory tools are included partly in this -- module, partly in "Control.Arrow.Constrained".  {-# LANGUAGE ConstraintKinds              #-}+{-# LANGUAGE PolyKinds                    #-} {-# LANGUAGE TypeFamilies                 #-} {-# LANGUAGE MultiParamTypeClasses        #-} {-# LANGUAGE FlexibleContexts             #-}@@ -56,6 +57,9 @@ import Data.Tagged import Data.Monoid import Data.Void+#if MIN_VERSION_base(4,9,0)+import Data.Kind (Type)+#endif import Data.Type.Coercion import qualified Control.Category as Hask import qualified Data.Functor.Contravariant as Hask (Op(..))@@ -77,8 +81,12 @@ --   /morphism type constructor/. From a mathematician's point of view this may --   seem a bit strange way to define the category, but it just turns out to --   be quite convenient for practical purposes.-class Category k where-  type Object k o :: Constraint+#if MIN_VERSION_base(4,9,0)+class Category (k :: κ -> κ -> Type) where+#else+class Category (k :: κ -> κ -> *) where+#endif+  type Object k (o :: κ) :: Constraint   type Object k o = ()   id :: Object k a => k a a   (.) :: (Object k a, Object k b, Object k c)

Control/Category/Constrained/Prelude.hs view

@@ -2,7 +2,7 @@ -- Module      :  Control.Category.Constrained.Prelude -- Copyright   :  (c) 2013 Justus Sagemüller -- License     :  GPL v3 (see COPYING)--- Maintainer  :  (@) sagemueller $ geo.uni-koeln.de+-- Maintainer  :  (@) jsag $ hvl.no --   {-# LANGUAGE ConstraintKinds              #-}@@ -23,7 +23,7 @@                       , Functor(..), (<$>), Applicative(..), (<*>), Monad(..), (=<<), filter                       , mapM, mapM_, sequence, sequence_                       , Foldable, foldMap, fold, traverse_, concatMap-                      , Traversable, traverse )+                      , Traversable, traverse, MonadFail(..) )  import Control.Category.Constrained hiding (ConstrainedMorphism) import Control.Functor.Constrained

Control/Category/Constrained/Reified.hs view

@@ -2,7 +2,7 @@ -- Module      :  Control.Category.Constrained.Reified -- Copyright   :  (c) 2016 Justus Sagemüller -- License     :  GPL v3 (see COPYING)--- Maintainer  :  (@) sagemueller $ geo.uni-koeln.de+-- Maintainer  :  (@) jsag $ hvl.no --  --  -- GADTs that mirror the class hierarchy from 'Category' to (at the moment) 'Cartesian',

Control/Category/Constrained/Reified/PolyPattern.hs view

@@ -2,7 +2,7 @@ -- Module      :  Control.Category.Constrained.Reified.PolyPattern -- Copyright   :  (c) 2016 Justus Sagemüller -- License     :  GPL v3 (see COPYING)--- Maintainer  :  (@) sagemueller $ geo.uni-koeln.de+-- Maintainer  :  (@) jsag $ hvl.no --  --  -- Pattern synonyms which allow you to deconstruct the various types

Control/Category/Discrete.hs view

@@ -2,7 +2,7 @@ -- Module      :  Control.Category.Discrete -- Copyright   :  (c) 2018 Justus Sagemüller -- License     :  GPL v3 (see COPYING)--- Maintainer  :  (@) sagemueller $ geo.uni-koeln.de+-- Maintainer  :  (@) jsag $ hvl.no --  --  {-# LANGUAGE GADTs                #-}

Control/Category/Hask.hs view

@@ -2,7 +2,7 @@ -- Module      :  Control.Category.Hask -- Copyright   :  (c) 2013 Justus Sagemüller -- License     :  GPL v3 (see COPYING)--- Maintainer  :  (@) sagemueller $ geo.uni-koeln.de+-- Maintainer  :  (@) jsag $ hvl.no --  -- Re-exports of all the common category-theory inspired classes from the -- "base" package, i.e. basically endofunctors in the Hask category (with

Control/Functor/Constrained.hs view

@@ -2,7 +2,7 @@ -- Module      :  Control.Functor.Constrained -- Copyright   :  (c) 2014 Justus Sagemüller -- License     :  GPL v3 (see COPYING)--- Maintainer  :  (@) sagemueller $ geo.uni-koeln.de+-- Maintainer  :  (@) jsag $ hvl.no --   {-# LANGUAGE ConstraintKinds              #-}

Control/Monad/Constrained.hs view

@@ -2,7 +2,7 @@ -- Module      :  Control.Monad.Constrained -- Copyright   :  (c) 2013 Justus Sagemüller -- License     :  GPL v3 (see COPYING)--- Maintainer  :  (@) sagemueller $ geo.uni-koeln.de+-- Maintainer  :  (@) jsag $ hvl.no --  {-# LANGUAGE ConstraintKinds              #-} {-# LANGUAGE TypeFamilies                 #-}@@ -43,11 +43,12 @@  import Prelude hiding (      id, const, fst, snd, (.), ($)-   , Functor(..), Applicative(..), Monad(..), (=<<)+   , Functor(..), Applicative(..), Monad(..), MonadFail(..), (=<<)    , uncurry, curry, filter    , mapM, mapM_, sequence, sequence_    ) import qualified Control.Category.Hask as Hask+import qualified Control.Monad.Fail as HaskFail  import Control.Arrow.Constrained @@ -131,7 +132,8 @@ class (MonadPlus m k) => MonadFail m k where   fail :: (Object k (m a)) => k String (m a)  -instance (Hask.MonadPlus m, Hask.Applicative m) => MonadFail m (->) where+instance (Hask.MonadPlus m, Hask.Applicative m, HaskFail.MonadFail m) +          => MonadFail m (->) where   fail = Hask.fail

Data/Foldable/Constrained.hs view

@@ -2,7 +2,7 @@ -- Module      :  Data.Foldable.Constrained -- Copyright   :  (c) 2014 Justus Sagemüller -- License     :  GPL v3 (see COPYING)--- Maintainer  :  (@) sagemueller $ geo.uni-koeln.de+-- Maintainer  :  (@) jsag $ hvl.no --  {-# LANGUAGE ConstraintKinds              #-} {-# LANGUAGE TypeFamilies                 #-}

Data/Traversable/Constrained.hs view

@@ -2,7 +2,7 @@ -- Module      :  Data.Traversable.Constrained -- Copyright   :  (c) 2014 Justus Sagemüller -- License     :  GPL v3 (see COPYING)--- Maintainer  :  (@) sagemueller $ geo.uni-koeln.de+-- Maintainer  :  (@) jsag $ hvl.no --  {-# LANGUAGE ConstraintKinds              #-} {-# LANGUAGE TypeFamilies                 #-}

constrained-categories.cabal view

@@ -1,5 +1,5 @@ Name:                constrained-categories-Version:             0.4.0.0+Version:             0.4.1.0 Category:            control Synopsis:            Constrained clones of the category-theory type classes, using ConstraintKinds. Description:         Haskell has, and makes great use of, powerful facilities from category@@ -27,7 +27,7 @@ License:             GPL-3 License-file:        COPYING Author:              Justus Sagemüller-Maintainer:          (@) sagemueller $ geo.uni-koeln.de+Maintainer:          (@) jsag $ hvl.no Homepage:            https://github.com/leftaroundabout/constrained-categories Build-Type:          Simple Cabal-Version:       >=1.10@@ -40,11 +40,12 @@  Library   Default-Language:   Haskell2010-  Build-Depends:      base>=4.7 && <5+  Build-Depends:      base>=4.8 && <5                       , tagged                       , void                       , semigroups                       , contravariant+                      , fail                       , trivial-constraint >= 0.4 && < 0.5   Default-Extensions: ConstraintKinds                       TypeFamilies