constrained-categories 0.3.1.0 → 0.3.1.1
raw patch · 3 files changed
+21/−8 lines, 3 filesdep +semigroupsPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependencies added: semigroups
API changes (from Hackage documentation)
- Data.Foldable.Constrained: instance (Control.Applicative.Constrained.Monoidal f k k, Control.Arrow.Constrained.Function k, u ~ Control.Category.Constrained.UnitObject k, 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)
+ Control.Category.Constrained: type ConstrainedFunction isObj = ConstrainedCategory (->) isObj
+ Control.Category.Constrained.Prelude: (!!) :: () => [a] -> Int -> a
+ Control.Category.Constrained.Prelude: ($!) :: () => a -> b -> a -> b
+ Control.Category.Constrained.Prelude: ($) :: (Function f, Object f a, Object f b) => f a b -> a -> b
+ Control.Category.Constrained.Prelude: ($~) :: (HasAgent k, Object k a, Object k b, Object k c) => k b c -> AgentVal k a b -> AgentVal k a c
+ Control.Category.Constrained.Prelude: (&&) :: Bool -> Bool -> Bool
+ Control.Category.Constrained.Prelude: (*) :: Num a => a -> a -> a
+ Control.Category.Constrained.Prelude: (**) :: Floating a => a -> a -> a
+ Control.Category.Constrained.Prelude: (+) :: Num a => a -> a -> a
+ Control.Category.Constrained.Prelude: (++) :: () => [a] -> [a] -> [a]
+ Control.Category.Constrained.Prelude: (-) :: Num a => a -> a -> a
+ Control.Category.Constrained.Prelude: (.) :: (Category k, Object k a, Object k b, Object k c) => k b c -> k a b -> k a c
+ Control.Category.Constrained.Prelude: (/) :: Fractional a => a -> a -> a
+ Control.Category.Constrained.Prelude: (/=) :: Eq a => a -> a -> Bool
+ Control.Category.Constrained.Prelude: (<$>) :: (Functor f r (->), Object r a, Object r b) => r a b -> f a -> f b
+ Control.Category.Constrained.Prelude: (<) :: Ord a => a -> a -> Bool
+ Control.Category.Constrained.Prelude: (<**>) :: (Applicative f r (->), ObjectMorphism r a b, ObjectPair r (r a b) a) => f a -> f (r a b) -> f b
+ Control.Category.Constrained.Prelude: (<*>) :: (Applicative f r t, ObjectMorphism r a b, ObjectMorphism t (f a) (f b), Object t (t (f a) (f b)), ObjectPair r (r a b) a, ObjectPair t (f (r a b)) (f a), Object r a, Object r b) => f (r a b) `t` t (f a) (f b)
+ Control.Category.Constrained.Prelude: (<<) :: (Monad m k, WellPointed k, Object k a, Object k b, Object k (m a), ObjectPoint k (m b), Object k (m (m b))) => m b -> k (m a) (m b)
+ Control.Category.Constrained.Prelude: (<=) :: Ord a => a -> a -> Bool
+ Control.Category.Constrained.Prelude: (<>) :: Semigroup a => a -> a -> a
+ Control.Category.Constrained.Prelude: (=<<) :: (Monad m k, Object k a, Object k b, Object k (m a), Object k (m b), Object k (m (m b))) => k a (m b) -> k (m a) (m b)
+ Control.Category.Constrained.Prelude: (==) :: Eq a => a -> a -> Bool
+ Control.Category.Constrained.Prelude: (>) :: Ord a => a -> a -> Bool
+ Control.Category.Constrained.Prelude: (>=) :: Ord a => a -> a -> Bool
+ Control.Category.Constrained.Prelude: (>>) :: (WellPointed k, Monad m k, ObjectPair k b (UnitObject k), ObjectPair k (m b) (UnitObject k), ObjectPair k (UnitObject k) (m b), ObjectPair k b a, ObjectPair k a b, Object k (m (a, b)), ObjectPair k (m a) (m b), ObjectPoint k (m a)) => m a -> k (m b) (m b)
+ Control.Category.Constrained.Prelude: (>>=) :: (Function f, Monad m f, Object f a, Object f b, Object f (m a), Object f (m b), Object f (m (m b))) => m a -> f a (m b) -> m b
+ Control.Category.Constrained.Prelude: (^) :: (Num a, Integral b) => a -> b -> a
+ Control.Category.Constrained.Prelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Control.Category.Constrained.Prelude: (||) :: Bool -> Bool -> Bool
+ Control.Category.Constrained.Prelude: ConstrainedMorphism :: k a b -> ConstrainedCategory
+ Control.Category.Constrained.Prelude: EQ :: Ordering
+ Control.Category.Constrained.Prelude: False :: Bool
+ Control.Category.Constrained.Prelude: GT :: Ordering
+ Control.Category.Constrained.Prelude: GenericAgent :: k a v -> GenericAgent k a v
+ Control.Category.Constrained.Prelude: Just :: a -> Maybe a
+ Control.Category.Constrained.Prelude: Kleisli :: k a (m b) -> Kleisli m k a b
+ Control.Category.Constrained.Prelude: LT :: Ordering
+ Control.Category.Constrained.Prelude: Left :: a -> Either a b
+ Control.Category.Constrained.Prelude: Nothing :: Maybe a
+ Control.Category.Constrained.Prelude: Right :: b -> Either a b
+ Control.Category.Constrained.Prelude: True :: Bool
+ Control.Category.Constrained.Prelude: [runGenericAgent] :: GenericAgent k a v -> k a v
+ Control.Category.Constrained.Prelude: [runKleisli] :: Kleisli m k a b -> k a (m b)
+ Control.Category.Constrained.Prelude: abs :: Num a => a -> a
+ Control.Category.Constrained.Prelude: acos :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: acosh :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: alg :: (HasAgent k, Object k a, Object k b) => (forall q. Object k q => AgentVal k q a -> AgentVal k q b) -> k a b
+ Control.Category.Constrained.Prelude: all :: Foldable t => a -> Bool -> t a -> Bool
+ Control.Category.Constrained.Prelude: and :: Foldable t => t Bool -> Bool
+ Control.Category.Constrained.Prelude: any :: Foldable t => a -> Bool -> t a -> Bool
+ Control.Category.Constrained.Prelude: appendFile :: FilePath -> String -> IO ()
+ Control.Category.Constrained.Prelude: apply :: (Curry k, ObjectMorphism k a b, ObjectPair k (k a b) a) => k (k a b, a) b
+ Control.Category.Constrained.Prelude: asTypeOf :: () => a -> a -> a
+ Control.Category.Constrained.Prelude: asin :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: asinh :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: atan :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: atan2 :: RealFloat a => a -> a -> a
+ Control.Category.Constrained.Prelude: atanh :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: attachUnit :: (Cartesian k, u ~ UnitObject k, ObjectPair k a u) => k a (a, u)
+ Control.Category.Constrained.Prelude: attachZero :: (CoCartesian k, Object k a, z ~ ZeroObject k, ObjectSum k a z) => k a (a + z)
+ Control.Category.Constrained.Prelude: boolAsSum :: (CoCartesian k, ObjectSum k u u, u ~ UnitObject k, Object k Bool) => k Bool (u + u)
+ Control.Category.Constrained.Prelude: boolFromSum :: (CoCartesian k, ObjectSum k u u, u ~ UnitObject k, Object k Bool) => k (u + u) Bool
+ Control.Category.Constrained.Prelude: break :: () => a -> Bool -> [a] -> ([a], [a])
+ Control.Category.Constrained.Prelude: ceiling :: (RealFrac a, Integral b) => a -> b
+ Control.Category.Constrained.Prelude: class (Monoidal f r t, Curry r, Curry t) => Applicative f r t
+ Control.Category.Constrained.Prelude: class Bounded a
+ Control.Category.Constrained.Prelude: class (Category k, Monoid (UnitObject k), Object k (UnitObject k)) => Cartesian k where {
+ Control.Category.Constrained.Prelude: class Category k where {
+ Control.Category.Constrained.Prelude: class (Category k, Object k (ZeroObject k)) => CoCartesian k where {
+ Control.Category.Constrained.Prelude: class (Cartesian k) => Curry k where {
+ Control.Category.Constrained.Prelude: class Enum a
+ Control.Category.Constrained.Prelude: class Eq a
+ Control.Category.Constrained.Prelude: class Fractional a => Floating a
+ Control.Category.Constrained.Prelude: class Num a => Fractional a
+ Control.Category.Constrained.Prelude: class (Category r, Category t, Object t (f (UnitObject r))) => Functor f r t | f r -> t, f t -> r
+ Control.Category.Constrained.Prelude: class (Category k) => HasAgent k where {
+ Control.Category.Constrained.Prelude: class (Real a, Enum a) => Integral a
+ Control.Category.Constrained.Prelude: class (Category k) => Isomorphic k a b
+ Control.Category.Constrained.Prelude: class (Applicative m k k, Object k (m (UnitObject k)), Object k (m (m (UnitObject k)))) => Monad m k
+ Control.Category.Constrained.Prelude: class (MonadPlus m k) => MonadFail m k
+ Control.Category.Constrained.Prelude: class Semigroup a => Monoid a
+ Control.Category.Constrained.Prelude: class (Functor f r t, Cartesian r, Cartesian t) => Monoidal f r t
+ Control.Category.Constrained.Prelude: class Num a
+ Control.Category.Constrained.Prelude: class Eq a => Ord a
+ Control.Category.Constrained.Prelude: class Read a
+ Control.Category.Constrained.Prelude: class (Num a, Ord a) => Real a
+ Control.Category.Constrained.Prelude: class (RealFrac a, Floating a) => RealFloat a
+ Control.Category.Constrained.Prelude: class (Real a, Fractional a) => RealFrac a
+ Control.Category.Constrained.Prelude: class Semigroup a
+ Control.Category.Constrained.Prelude: class Show a
+ Control.Category.Constrained.Prelude: class (CoCartesian r, Cartesian t, Functor f r t, Object t (f (ZeroObject r))) => SumToProduct f r t
+ Control.Category.Constrained.Prelude: coRegroup :: (CoCartesian k, Object k a, Object k c, ObjectSum k a b, ObjectSum k b c, ObjectSum k a (b + c), ObjectSum k (a + b) c) => k (a + (b + c)) ((a + b) + c)
+ Control.Category.Constrained.Prelude: coRegroup' :: (CoCartesian k, Object k a, Object k c, ObjectSum k a b, ObjectSum k b c, ObjectSum k a (b + c), ObjectSum k (a + b) c) => k ((a + b) + c) (a + (b + c))
+ Control.Category.Constrained.Prelude: coSwap :: (CoCartesian k, ObjectSum k a b, ObjectSum k b a) => k (a + b) (b + a)
+ Control.Category.Constrained.Prelude: compare :: Ord a => a -> a -> Ordering
+ Control.Category.Constrained.Prelude: concat :: Foldable t => t [a] -> [a]
+ Control.Category.Constrained.Prelude: const :: (WellPointed a, Object a b, ObjectPoint a x) => x -> a b x
+ Control.Category.Constrained.Prelude: constPure :: (WellPointed r, Monoidal f r t, ObjectPoint r a, Object t (f a)) => a -> t (UnitObject t) (f a)
+ Control.Category.Constrained.Prelude: constrained :: (Category k, o a, o b) => k a b -> ConstrainedCategory k o a b
+ Control.Category.Constrained.Prelude: constrainedFZipWith :: (Category r, Category t, o a, o b, o (a, b), o c, o (f a, f b), o (f c)) => (r (a, b) c -> t (f a, f b) (f c)) -> ConstrainedCategory r o (a, b) c -> ConstrainedCategory t o (f a, f b) (f c)
+ Control.Category.Constrained.Prelude: constrainedFmap :: (Category r, Category t, o a, o b, o (f a), o (f b)) => (r a b -> t (f a) (f b)) -> ConstrainedCategory r o a b -> ConstrainedCategory t o (f a) (f b)
+ Control.Category.Constrained.Prelude: cos :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: cosh :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: curry :: (Curry k, ObjectPair k a b, ObjectMorphism k b c) => k (a, b) c -> k a (k b c)
+ Control.Category.Constrained.Prelude: cycle :: () => [a] -> [a]
+ Control.Category.Constrained.Prelude: data Bool
+ Control.Category.Constrained.Prelude: data Char
+ Control.Category.Constrained.Prelude: data ConstrainedCategory (k :: * -> * -> *) (o :: * -> Constraint) (a :: *) (b :: *)
+ Control.Category.Constrained.Prelude: data Double
+ Control.Category.Constrained.Prelude: data Either a b
+ Control.Category.Constrained.Prelude: data Float
+ Control.Category.Constrained.Prelude: data GenericAgent k a v
+ Control.Category.Constrained.Prelude: data IO a
+ Control.Category.Constrained.Prelude: data Int
+ Control.Category.Constrained.Prelude: data Integer
+ Control.Category.Constrained.Prelude: data Maybe a
+ Control.Category.Constrained.Prelude: data Ordering
+ Control.Category.Constrained.Prelude: data Word
+ Control.Category.Constrained.Prelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ Control.Category.Constrained.Prelude: detachUnit :: (Cartesian k, u ~ UnitObject k, ObjectPair k a u) => k (a, u) a
+ Control.Category.Constrained.Prelude: detachZero :: (CoCartesian k, Object k a, z ~ ZeroObject k, ObjectSum k a z) => k (a + z) a
+ Control.Category.Constrained.Prelude: div :: Integral a => a -> a -> a
+ Control.Category.Constrained.Prelude: divMod :: Integral a => a -> a -> (a, a)
+ Control.Category.Constrained.Prelude: drop :: () => Int -> [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: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Control.Category.Constrained.Prelude: encodeFloat :: RealFloat a => Integer -> Int -> a
+ Control.Category.Constrained.Prelude: enumFrom :: Enum a => a -> [a]
+ Control.Category.Constrained.Prelude: enumFromThen :: Enum a => a -> a -> [a]
+ Control.Category.Constrained.Prelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Control.Category.Constrained.Prelude: enumFromTo :: Enum a => a -> a -> [a]
+ Control.Category.Constrained.Prelude: error :: HasCallStack => [Char] -> a
+ Control.Category.Constrained.Prelude: errorWithoutStackTrace :: () => [Char] -> a
+ Control.Category.Constrained.Prelude: even :: Integral a => a -> Bool
+ Control.Category.Constrained.Prelude: exp :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: exponent :: RealFloat a => a -> Int
+ Control.Category.Constrained.Prelude: fail :: (MonadFail m k, (Object k (m a))) => k String (m a)
+ Control.Category.Constrained.Prelude: filter :: (SumToProduct f r t, Object r a, Object r Bool, Object t (f a)) => r a Bool -> t (f a) (f a)
+ Control.Category.Constrained.Prelude: filterM :: (PreArrow k, Monad m k, SumToProduct c k k, EndoTraversable c k, ObjectPair k Bool a, Object k (c a), Object k (m (c a)), ObjectPair k (Bool, a) (c (Bool, a)), ObjectPair k (m Bool) (m a), ObjectPair k (m (Bool, a)) (m (c (Bool, a))), TraversalObject k c (Bool, a)) => a `k` m Bool -> c a `k` m (c a)
+ Control.Category.Constrained.Prelude: flip :: () => a -> b -> c -> b -> a -> c
+ Control.Category.Constrained.Prelude: floatDigits :: RealFloat a => a -> Int
+ Control.Category.Constrained.Prelude: floatRadix :: RealFloat a => a -> Integer
+ Control.Category.Constrained.Prelude: floatRange :: RealFloat a => a -> (Int, Int)
+ Control.Category.Constrained.Prelude: floor :: (RealFrac a, Integral b) => a -> b
+ Control.Category.Constrained.Prelude: fmap :: (Functor f r t, Object r a, Object t (f a), Object r b, Object t (f b)) => r a b -> t (f a) (f b)
+ Control.Category.Constrained.Prelude: foldl :: Foldable t => b -> a -> b -> b -> t a -> b
+ Control.Category.Constrained.Prelude: foldl1 :: Foldable t => a -> a -> a -> t a -> a
+ Control.Category.Constrained.Prelude: foldr :: Foldable t => a -> b -> b -> b -> t a -> b
+ Control.Category.Constrained.Prelude: foldr1 :: Foldable t => a -> a -> a -> t a -> a
+ Control.Category.Constrained.Prelude: forM :: forall s t k m a b l. (Traversable s t k l, Monoidal m k l, Function l, Object k b, Object k (t b), ObjectPair k b (t b), Object l a, Object l (s a), ObjectPair l (m b) (m (t b)), TraversalObject k t b) => s a -> (a `l` m b) -> m (t b)
+ Control.Category.Constrained.Prelude: forM_ :: forall t k l f a b uk ul. (Foldable t k l, Monoidal f l l, Monoidal f k k, Function l, Arrow k (->), Arrow l (->), ul ~ UnitObject l, uk ~ UnitObject k, uk ~ ul, ObjectPair l ul ul, ObjectPair l (f ul) (f ul), ObjectPair l (f ul) (t a), ObjectPair l ul (t a), ObjectPair l (t a) ul, ObjectPair l (f ul) a, ObjectPair k b (f b), ObjectPair k b ul, ObjectPair k uk uk, ObjectPair k (f uk) a, ObjectPair k (f uk) (f uk)) => t a -> a `k` f b -> f uk
+ Control.Category.Constrained.Prelude: fromEnum :: Enum a => a -> Int
+ Control.Category.Constrained.Prelude: fromInteger :: Num a => Integer -> a
+ Control.Category.Constrained.Prelude: fromIntegral :: (Integral a, Num b) => a -> b
+ Control.Category.Constrained.Prelude: fromRational :: Fractional a => Rational -> a
+ Control.Category.Constrained.Prelude: fst :: (PreArrow a, (ObjectPair a x y)) => a (x, y) x
+ Control.Category.Constrained.Prelude: fzip :: (Monoidal f r t, ObjectPair r a b, ObjectPair t (f a) (f b), Object t (f (a, b))) => t (f a, f b) (f (a, b))
+ Control.Category.Constrained.Prelude: fzipWith :: (Monoidal f r t, ObjectPair r a b, Object r c, ObjectPair t (f a) (f b), Object t (f c)) => r (a, b) c -> t (f a, f b) (f c)
+ Control.Category.Constrained.Prelude: gcd :: Integral a => a -> a -> a
+ Control.Category.Constrained.Prelude: genericAgentMap :: (HasAgent k, Object k a, Object k b, Object k c) => k b c -> GenericAgent k a b -> GenericAgent k a c
+ Control.Category.Constrained.Prelude: genericAlg :: (HasAgent k, Object k a, Object k b) => (forall q. Object k q => GenericAgent k q a -> GenericAgent k q b) -> k a b
+ Control.Category.Constrained.Prelude: getChar :: IO Char
+ Control.Category.Constrained.Prelude: getContents :: IO String
+ Control.Category.Constrained.Prelude: getLine :: IO String
+ Control.Category.Constrained.Prelude: head :: () => [a] -> a
+ Control.Category.Constrained.Prelude: id :: (Category k, Object k a) => k a a
+ Control.Category.Constrained.Prelude: ifThenElse :: (EnhancedCat f (->), Function f, Object f Bool, Object f a, Object f (f a a), Object f (f a (f a a))) => Bool `f` (a `f` (a `f` a))
+ Control.Category.Constrained.Prelude: inCategoryOf :: (Category k) => k a b -> k c d -> k a b
+ Control.Category.Constrained.Prelude: infix 4 `notElem`
+ Control.Category.Constrained.Prelude: infixl 1 >>
+ Control.Category.Constrained.Prelude: infixl 4 <**>
+ Control.Category.Constrained.Prelude: infixl 9 !!
+ Control.Category.Constrained.Prelude: infixr 0 $!
+ Control.Category.Constrained.Prelude: infixr 1 <<
+ Control.Category.Constrained.Prelude: infixr 2 ||
+ Control.Category.Constrained.Prelude: infixr 3 &&
+ Control.Category.Constrained.Prelude: infixr 5 ++
+ Control.Category.Constrained.Prelude: infixr 8 ^
+ Control.Category.Constrained.Prelude: init :: () => [a] -> [a]
+ Control.Category.Constrained.Prelude: interact :: String -> String -> IO ()
+ Control.Category.Constrained.Prelude: ioError :: () => IOError -> IO a
+ Control.Category.Constrained.Prelude: isDenormalized :: RealFloat a => a -> Bool
+ Control.Category.Constrained.Prelude: isIEEE :: RealFloat a => a -> Bool
+ Control.Category.Constrained.Prelude: isInfinite :: RealFloat a => a -> Bool
+ Control.Category.Constrained.Prelude: isNaN :: RealFloat a => a -> Bool
+ Control.Category.Constrained.Prelude: isNegativeZero :: RealFloat a => a -> Bool
+ Control.Category.Constrained.Prelude: iso :: Isomorphic k a b => k a b
+ Control.Category.Constrained.Prelude: iterate :: () => a -> a -> a -> [a]
+ Control.Category.Constrained.Prelude: join :: (Monad m k, Object k a, Object k (m a), Object k (m (m a))) => m (m a) `k` m a
+ Control.Category.Constrained.Prelude: last :: () => [a] -> a
+ Control.Category.Constrained.Prelude: lcm :: Integral a => a -> a -> a
+ Control.Category.Constrained.Prelude: length :: Foldable t => t a -> Int
+ Control.Category.Constrained.Prelude: lex :: ReadS String
+ Control.Category.Constrained.Prelude: liftA :: (Applicative f r t, Object r a, Object r b, Object t (f a), Object t (f b)) => a `r` b -> f a `t` f b
+ Control.Category.Constrained.Prelude: liftA2 :: (Applicative f r t, Object r c, ObjectMorphism r b c, Object t (f c), ObjectMorphism t (f b) (f c), ObjectPair r a b, ObjectPair t (f a) (f b)) => a `r` (b `r` c) -> f a `t` (f b `t` f c)
+ Control.Category.Constrained.Prelude: liftA3 :: (Applicative f r t, Object r c, Object r d, ObjectMorphism r c d, ObjectMorphism r b (c `r` d), Object r (r c d), ObjectPair r a b, ObjectPair r (r c d) c, Object t (f c), Object t (f d), Object t (f a, f b), ObjectMorphism t (f c) (f d), ObjectMorphism t (f b) (t (f c) (f d)), Object t (t (f c) (f d)), ObjectPair t (f a) (f b), ObjectPair t (t (f c) (f d)) (f c), ObjectPair t (f (r c d)) (f c)) => a `r` (b `r` (c `r` d)) -> f a `t` (f b `t` (f c `t` f d))
+ Control.Category.Constrained.Prelude: lines :: String -> [String]
+ Control.Category.Constrained.Prelude: log :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: logBase :: Floating a => a -> a -> a
+ Control.Category.Constrained.Prelude: lookup :: Eq a => a -> [(a, b)] -> Maybe b
+ Control.Category.Constrained.Prelude: map :: () => a -> b -> [a] -> [b]
+ Control.Category.Constrained.Prelude: mapEither :: (SumToProduct f r t, Object r a, ObjectSum r b c, Object t (f a), ObjectPair t (f b) (f c)) => r a (b + c) -> t (f a) (f b, f c)
+ Control.Category.Constrained.Prelude: mapM :: (Traversable s t k l, k ~ l, s ~ t, Applicative m k k, Object k a, Object k (t a), ObjectPair k b (t b), ObjectPair k (m b) (m (t b)), TraversalObject k t b) => a `k` m b -> t a `k` m (t b)
+ Control.Category.Constrained.Prelude: mapM_ :: forall t k o f a b u. (Foldable t k k, WellPointed k, Monoidal f k k, u ~ UnitObject k, ObjectPair k (f u) (t a), ObjectPair k (f u) a, ObjectPair k u (t a), ObjectPair k (t a) u, ObjectPair k (f u) (f u), ObjectPair k u u, ObjectPair k b u, Object k (f b)) => a `k` f b -> t a `k` f u
+ Control.Category.Constrained.Prelude: mappend :: Monoid a => a -> a -> a
+ Control.Category.Constrained.Prelude: max :: Ord a => a -> a -> a
+ Control.Category.Constrained.Prelude: maxBound :: Bounded a => a
+ Control.Category.Constrained.Prelude: maximum :: (Foldable t, Ord a) => t a -> a
+ Control.Category.Constrained.Prelude: maybe :: () => b -> a -> b -> Maybe a -> b
+ Control.Category.Constrained.Prelude: maybeAsSum :: (CoCartesian k, ObjectSum k u a, u ~ UnitObject k, Object k (Maybe a)) => k (Maybe a) (u + a)
+ Control.Category.Constrained.Prelude: maybeFromSum :: (CoCartesian k, ObjectSum k u a, u ~ UnitObject k, Object k (Maybe a)) => k (u + a) (Maybe a)
+ Control.Category.Constrained.Prelude: mconcat :: Monoid a => [a] -> a
+ Control.Category.Constrained.Prelude: mempty :: Monoid a => a
+ Control.Category.Constrained.Prelude: min :: Ord a => a -> a -> a
+ Control.Category.Constrained.Prelude: minBound :: Bounded a => a
+ Control.Category.Constrained.Prelude: minimum :: (Foldable t, Ord a) => t a -> a
+ Control.Category.Constrained.Prelude: mod :: Integral a => a -> a -> a
+ Control.Category.Constrained.Prelude: mplus :: (MonadPlus m (->)) => m a -> m a -> m a
+ Control.Category.Constrained.Prelude: mzero :: (MonadZero m (->)) => m a
+ Control.Category.Constrained.Prelude: negate :: Num a => a -> a
+ Control.Category.Constrained.Prelude: newtype ConstrainedCategory (k :: * -> * -> *) (o :: * -> Constraint) (a :: *) (b :: *)
+ Control.Category.Constrained.Prelude: newtype Kleisli m k a b
+ Control.Category.Constrained.Prelude: not :: Bool -> Bool
+ Control.Category.Constrained.Prelude: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Control.Category.Constrained.Prelude: null :: Foldable t => t a -> Bool
+ Control.Category.Constrained.Prelude: odd :: Integral a => a -> Bool
+ Control.Category.Constrained.Prelude: or :: Foldable t => t Bool -> Bool
+ Control.Category.Constrained.Prelude: otherwise :: Bool
+ Control.Category.Constrained.Prelude: pi :: Floating a => a
+ Control.Category.Constrained.Prelude: pred :: Enum a => a -> a
+ Control.Category.Constrained.Prelude: print :: Show a => a -> IO ()
+ Control.Category.Constrained.Prelude: product :: (Foldable t, Num a) => t a -> a
+ Control.Category.Constrained.Prelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Control.Category.Constrained.Prelude: pure :: (Applicative f r t, Object r a, Object t (f a)) => a `t` f a
+ Control.Category.Constrained.Prelude: pureUnit :: Monoidal f r t => UnitObject t `t` f (UnitObject r)
+ Control.Category.Constrained.Prelude: putChar :: Char -> IO ()
+ Control.Category.Constrained.Prelude: putStr :: String -> IO ()
+ Control.Category.Constrained.Prelude: putStrLn :: String -> IO ()
+ Control.Category.Constrained.Prelude: quot :: Integral a => a -> a -> a
+ Control.Category.Constrained.Prelude: quotRem :: Integral a => a -> a -> (a, a)
+ Control.Category.Constrained.Prelude: read :: Read a => String -> a
+ Control.Category.Constrained.Prelude: readFile :: FilePath -> IO String
+ Control.Category.Constrained.Prelude: readIO :: Read a => String -> IO a
+ Control.Category.Constrained.Prelude: readList :: Read a => ReadS [a]
+ Control.Category.Constrained.Prelude: readLn :: Read a => IO a
+ Control.Category.Constrained.Prelude: readParen :: () => Bool -> ReadS a -> ReadS a
+ Control.Category.Constrained.Prelude: reads :: Read a => ReadS a
+ Control.Category.Constrained.Prelude: readsPrec :: Read a => Int -> ReadS a
+ Control.Category.Constrained.Prelude: realToFrac :: (Real a, Fractional b) => a -> b
+ Control.Category.Constrained.Prelude: recip :: Fractional a => a -> a
+ Control.Category.Constrained.Prelude: regroup :: (Cartesian k, ObjectPair k a b, ObjectPair k b c, ObjectPair k a (b, c), ObjectPair k (a, b) c) => k (a, (b, c)) ((a, b), c)
+ Control.Category.Constrained.Prelude: regroup' :: (Cartesian k, ObjectPair k a b, ObjectPair k b c, ObjectPair k a (b, c), ObjectPair k (a, b) c) => k ((a, b), c) (a, (b, c))
+ Control.Category.Constrained.Prelude: rem :: Integral a => a -> a -> a
+ Control.Category.Constrained.Prelude: repeat :: () => a -> [a]
+ Control.Category.Constrained.Prelude: replicate :: () => Int -> a -> [a]
+ Control.Category.Constrained.Prelude: return :: Monad m (->) => a -> m a
+ Control.Category.Constrained.Prelude: reverse :: () => [a] -> [a]
+ Control.Category.Constrained.Prelude: round :: (RealFrac a, Integral b) => a -> b
+ Control.Category.Constrained.Prelude: scaleFloat :: RealFloat a => Int -> a -> a
+ 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: scanr :: () => a -> b -> b -> b -> [a] -> [b]
+ Control.Category.Constrained.Prelude: scanr1 :: () => a -> a -> a -> [a] -> [a]
+ Control.Category.Constrained.Prelude: seq :: () => a -> b -> b
+ Control.Category.Constrained.Prelude: sequence :: (Traversable s t k l, k ~ l, s ~ t, Monoidal f k k, ObjectPair k a (t a), ObjectPair k (f a) (f (t a)), Object k (t (f a)), TraversalObject k t a) => t (f a) `k` f (t a)
+ Control.Category.Constrained.Prelude: sequenceA :: (Traversable t, Applicative f) => t f a -> f t a
+ Control.Category.Constrained.Prelude: sequence_ :: forall t k l m a b uk ul. (Foldable t k l, Arrow k (->), Arrow l (->), uk ~ UnitObject k, ul ~ UnitObject l, uk ~ ul, Monoidal m k k, Monoidal m l l, ObjectPair k a uk, ObjectPair k (t (m a)) uk, ObjectPair k uk uk, ObjectPair k (m uk) (m uk), ObjectPair k (t (m a)) ul, ObjectPair l (m ul) (t (m a)), ObjectPair l ul (t (m a)), ObjectPair l (m uk) (t (m a)), ObjectPair l (t (m a)) ul, ObjectPair k (m uk) (m a)) => t (m a) `l` m uk
+ Control.Category.Constrained.Prelude: show :: Show a => a -> String
+ Control.Category.Constrained.Prelude: showChar :: Char -> ShowS
+ Control.Category.Constrained.Prelude: showList :: Show a => [a] -> ShowS
+ Control.Category.Constrained.Prelude: showParen :: Bool -> ShowS -> ShowS
+ Control.Category.Constrained.Prelude: showString :: String -> ShowS
+ Control.Category.Constrained.Prelude: shows :: Show a => a -> ShowS
+ Control.Category.Constrained.Prelude: showsPrec :: Show a => Int -> a -> ShowS
+ Control.Category.Constrained.Prelude: significand :: RealFloat a => a -> a
+ Control.Category.Constrained.Prelude: signum :: Num a => a -> a
+ Control.Category.Constrained.Prelude: sin :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: sinh :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: snd :: (PreArrow a, (ObjectPair a x y)) => a (x, y) y
+ Control.Category.Constrained.Prelude: span :: () => a -> Bool -> [a] -> ([a], [a])
+ Control.Category.Constrained.Prelude: splitAt :: () => Int -> [a] -> ([a], [a])
+ Control.Category.Constrained.Prelude: sqrt :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: subtract :: Num a => a -> a -> a
+ Control.Category.Constrained.Prelude: succ :: Enum a => a -> a
+ Control.Category.Constrained.Prelude: sum :: (Foldable t, Num a) => t a -> a
+ Control.Category.Constrained.Prelude: sum2product :: (SumToProduct f r t, ObjectSum r a b, ObjectPair t (f a) (f b)) => t (f (a + b)) (f a, f b)
+ Control.Category.Constrained.Prelude: swap :: (Cartesian k, ObjectPair k a b, ObjectPair k b a) => k (a, b) (b, a)
+ Control.Category.Constrained.Prelude: tail :: () => [a] -> [a]
+ Control.Category.Constrained.Prelude: take :: () => Int -> [a] -> [a]
+ Control.Category.Constrained.Prelude: takeWhile :: () => a -> Bool -> [a] -> [a]
+ Control.Category.Constrained.Prelude: tan :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: tanh :: Floating a => a -> a
+ Control.Category.Constrained.Prelude: toEnum :: Enum a => Int -> a
+ Control.Category.Constrained.Prelude: toInteger :: Integral a => a -> Integer
+ Control.Category.Constrained.Prelude: toRational :: Real a => a -> Rational
+ Control.Category.Constrained.Prelude: truncate :: (RealFrac a, Integral b) => a -> b
+ Control.Category.Constrained.Prelude: type + = Either
+ Control.Category.Constrained.Prelude: type AgentVal k a v = GenericAgent k a v;
+ Control.Category.Constrained.Prelude: type CatTagged k x = Tagged (k (UnitObject k) (UnitObject k)) x
+ Control.Category.Constrained.Prelude: type ConstrainedFunction isObj = ConstrainedCategory (->) isObj
+ Control.Category.Constrained.Prelude: type FilePath = String
+ Control.Category.Constrained.Prelude: type Function f = EnhancedCat (->) f
+ Control.Category.Constrained.Prelude: type IOError = IOException
+ Control.Category.Constrained.Prelude: type MorphObjects k b c = ();
+ Control.Category.Constrained.Prelude: type Object k o = ();
+ Control.Category.Constrained.Prelude: type ObjectMorphism k b c = (Object k b, Object k c, MorphObjects k b c, Object k (k b c))
+ Control.Category.Constrained.Prelude: type ObjectPair k a b = (Category k, Object k a, Object k b, PairObjects k a b, Object k (a, b))
+ Control.Category.Constrained.Prelude: type ObjectSum k a b = (Category k, Object k a, Object k b, SumObjects k a b, Object k (a + b))
+ Control.Category.Constrained.Prelude: type PairObjects k a b = ();
+ Control.Category.Constrained.Prelude: type Rational = Ratio Integer
+ Control.Category.Constrained.Prelude: type ReadS a = String -> [(a, String)]
+ Control.Category.Constrained.Prelude: type ShowS = String -> String
+ Control.Category.Constrained.Prelude: type String = [Char]
+ Control.Category.Constrained.Prelude: type SumObjects k a b = ();
+ Control.Category.Constrained.Prelude: type UnitObject k = ();
+ Control.Category.Constrained.Prelude: type ZeroObject k = Void;
+ Control.Category.Constrained.Prelude: type family Object k o :: Constraint;
+ Control.Category.Constrained.Prelude: unconstrained :: (Category k) => ConstrainedCategory k o a b -> k a b
+ Control.Category.Constrained.Prelude: uncurry :: (Curry k, ObjectPair k a b, ObjectMorphism k b c) => k a (k b c) -> k (a, b) c
+ Control.Category.Constrained.Prelude: undefined :: HasCallStack => a
+ Control.Category.Constrained.Prelude: unless :: (Monad m k, PreArrow k, u ~ UnitObject k, ObjectPair k (m u) u) => Bool -> m u `k` m u
+ Control.Category.Constrained.Prelude: unlines :: [String] -> String
+ Control.Category.Constrained.Prelude: until :: () => a -> Bool -> a -> a -> a -> a
+ Control.Category.Constrained.Prelude: unwords :: [String] -> String
+ Control.Category.Constrained.Prelude: unzip :: () => [(a, b)] -> ([a], [b])
+ Control.Category.Constrained.Prelude: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])
+ Control.Category.Constrained.Prelude: userError :: String -> IOError
+ Control.Category.Constrained.Prelude: when :: (Monad m k, PreArrow k, u ~ UnitObject k, ObjectPair k (m u) u) => Bool -> m u `k` m u
+ Control.Category.Constrained.Prelude: words :: String -> [String]
+ Control.Category.Constrained.Prelude: writeFile :: FilePath -> String -> IO ()
+ Control.Category.Constrained.Prelude: zip :: () => [a] -> [b] -> [(a, b)]
+ 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: zipWith3 :: () => a -> b -> c -> d -> [a] -> [b] -> [c] -> [d]
+ Control.Category.Constrained.Prelude: }
+ Control.Category.Hask: (!!) :: () => [a] -> Int -> a
+ Control.Category.Hask: ($!) :: () => a -> b -> a -> b
+ Control.Category.Hask: ($) :: () => a -> b -> a -> b
+ Control.Category.Hask: (&&) :: Bool -> Bool -> Bool
+ Control.Category.Hask: (*) :: Num a => a -> a -> a
+ Control.Category.Hask: (**) :: Floating a => a -> a -> a
+ Control.Category.Hask: (*>) :: Applicative f => f a -> f b -> f b
+ Control.Category.Hask: (+) :: Num a => a -> a -> a
+ Control.Category.Hask: (++) :: () => [a] -> [a] -> [a]
+ Control.Category.Hask: (-) :: Num a => a -> a -> a
+ Control.Category.Hask: (/) :: Fractional a => a -> a -> a
+ Control.Category.Hask: (/=) :: Eq a => a -> a -> Bool
+ Control.Category.Hask: (<$) :: Functor f => a -> f b -> f a
+ Control.Category.Hask: (<$>) :: Functor f => a -> b -> f a -> f b
+ Control.Category.Hask: (<) :: Ord a => a -> a -> Bool
+ Control.Category.Hask: (<*) :: Applicative f => f a -> f b -> f a
+ Control.Category.Hask: (<*>) :: Applicative f => f a -> b -> f a -> f b
+ Control.Category.Hask: (<=) :: Ord a => a -> a -> Bool
+ Control.Category.Hask: (<>) :: Semigroup a => a -> a -> a
+ Control.Category.Hask: (=<<) :: Monad m => a -> m b -> m a -> m b
+ Control.Category.Hask: (==) :: Eq a => a -> a -> Bool
+ Control.Category.Hask: (>) :: Ord a => a -> a -> Bool
+ Control.Category.Hask: (>=) :: Ord a => a -> a -> Bool
+ Control.Category.Hask: (>>) :: Monad m => m a -> m b -> m b
+ Control.Category.Hask: (>>=) :: Monad m => m a -> a -> m b -> m b
+ Control.Category.Hask: (^) :: (Num a, Integral b) => a -> b -> a
+ Control.Category.Hask: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Control.Category.Hask: (||) :: Bool -> Bool -> Bool
+ Control.Category.Hask: EQ :: Ordering
+ Control.Category.Hask: False :: Bool
+ Control.Category.Hask: GT :: Ordering
+ Control.Category.Hask: Just :: a -> Maybe a
+ Control.Category.Hask: LT :: Ordering
+ Control.Category.Hask: Left :: a -> Either a b
+ Control.Category.Hask: Nothing :: Maybe a
+ Control.Category.Hask: Right :: b -> Either a b
+ Control.Category.Hask: True :: Bool
+ Control.Category.Hask: abs :: Num a => a -> a
+ Control.Category.Hask: acos :: Floating a => a -> a
+ Control.Category.Hask: acosh :: Floating a => a -> a
+ Control.Category.Hask: all :: Foldable t => a -> Bool -> t a -> Bool
+ Control.Category.Hask: and :: Foldable t => t Bool -> Bool
+ Control.Category.Hask: any :: Foldable t => a -> Bool -> t a -> Bool
+ Control.Category.Hask: appendFile :: FilePath -> String -> IO ()
+ Control.Category.Hask: asTypeOf :: () => a -> a -> a
+ Control.Category.Hask: asin :: Floating a => a -> a
+ Control.Category.Hask: asinh :: Floating a => a -> a
+ Control.Category.Hask: atan :: Floating a => a -> a
+ Control.Category.Hask: atan2 :: RealFloat a => a -> a -> a
+ Control.Category.Hask: atanh :: Floating a => a -> a
+ Control.Category.Hask: break :: () => a -> Bool -> [a] -> ([a], [a])
+ Control.Category.Hask: ceiling :: (RealFrac a, Integral b) => a -> b
+ Control.Category.Hask: class Functor f => Applicative (f :: * -> *)
+ Control.Category.Hask: class Bounded a
+ Control.Category.Hask: class Enum a
+ Control.Category.Hask: class Eq a
+ Control.Category.Hask: class Fractional a => Floating a
+ Control.Category.Hask: class Foldable (t :: * -> *)
+ Control.Category.Hask: class Num a => Fractional a
+ Control.Category.Hask: class Functor (f :: * -> *)
+ Control.Category.Hask: class (Real a, Enum a) => Integral a
+ Control.Category.Hask: class Applicative m => Monad (m :: * -> *)
+ Control.Category.Hask: class Semigroup a => Monoid a
+ Control.Category.Hask: class Num a
+ Control.Category.Hask: class Eq a => Ord a
+ Control.Category.Hask: class Read a
+ Control.Category.Hask: class (Num a, Ord a) => Real a
+ Control.Category.Hask: class (RealFrac a, Floating a) => RealFloat a
+ Control.Category.Hask: class (Real a, Fractional a) => RealFrac a
+ Control.Category.Hask: class Semigroup a
+ Control.Category.Hask: class Show a
+ Control.Category.Hask: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Control.Category.Hask: compare :: Ord a => a -> a -> Ordering
+ Control.Category.Hask: concat :: Foldable t => t [a] -> [a]
+ Control.Category.Hask: concatMap :: Foldable t => a -> [b] -> t a -> [b]
+ Control.Category.Hask: const :: () => a -> b -> a
+ Control.Category.Hask: cos :: Floating a => a -> a
+ Control.Category.Hask: cosh :: Floating a => a -> a
+ Control.Category.Hask: curry :: () => (a, b) -> c -> a -> b -> c
+ Control.Category.Hask: cycle :: () => [a] -> [a]
+ Control.Category.Hask: data Bool
+ Control.Category.Hask: data Char
+ Control.Category.Hask: data Double
+ Control.Category.Hask: data Either a b
+ Control.Category.Hask: data Float
+ Control.Category.Hask: data IO a
+ Control.Category.Hask: data Int
+ Control.Category.Hask: data Integer
+ Control.Category.Hask: data Maybe a
+ Control.Category.Hask: data Ordering
+ Control.Category.Hask: data Word
+ Control.Category.Hask: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ Control.Category.Hask: div :: Integral a => a -> a -> a
+ Control.Category.Hask: divMod :: Integral a => a -> a -> (a, a)
+ Control.Category.Hask: drop :: () => Int -> [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: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Control.Category.Hask: encodeFloat :: RealFloat a => Integer -> Int -> a
+ Control.Category.Hask: enumFrom :: Enum a => a -> [a]
+ Control.Category.Hask: enumFromThen :: Enum a => a -> a -> [a]
+ Control.Category.Hask: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Control.Category.Hask: enumFromTo :: Enum a => a -> a -> [a]
+ Control.Category.Hask: error :: HasCallStack => [Char] -> a
+ Control.Category.Hask: errorWithoutStackTrace :: () => [Char] -> a
+ Control.Category.Hask: even :: Integral a => a -> Bool
+ Control.Category.Hask: exp :: Floating a => a -> a
+ Control.Category.Hask: exponent :: RealFloat a => a -> Int
+ Control.Category.Hask: fail :: Monad m => String -> m a
+ Control.Category.Hask: filter :: () => a -> Bool -> [a] -> [a]
+ Control.Category.Hask: flip :: () => a -> b -> c -> b -> a -> c
+ Control.Category.Hask: floatDigits :: RealFloat a => a -> Int
+ Control.Category.Hask: floatRadix :: RealFloat a => a -> Integer
+ Control.Category.Hask: floatRange :: RealFloat a => a -> (Int, Int)
+ Control.Category.Hask: floor :: (RealFrac a, Integral b) => a -> b
+ Control.Category.Hask: fmap :: Functor f => a -> b -> f a -> f b
+ Control.Category.Hask: foldMap :: (Foldable t, Monoid m) => a -> m -> t a -> m
+ Control.Category.Hask: foldl :: Foldable t => b -> a -> b -> b -> t a -> b
+ Control.Category.Hask: foldl1 :: Foldable t => a -> a -> a -> t a -> a
+ Control.Category.Hask: foldr :: Foldable t => a -> b -> b -> b -> t a -> b
+ Control.Category.Hask: foldr1 :: Foldable t => a -> a -> a -> t a -> a
+ Control.Category.Hask: fromEnum :: Enum a => a -> Int
+ Control.Category.Hask: fromInteger :: Num a => Integer -> a
+ Control.Category.Hask: fromIntegral :: (Integral a, Num b) => a -> b
+ Control.Category.Hask: fromRational :: Fractional a => Rational -> a
+ Control.Category.Hask: fst :: () => (a, b) -> a
+ Control.Category.Hask: gcd :: Integral a => a -> a -> a
+ Control.Category.Hask: getChar :: IO Char
+ Control.Category.Hask: getContents :: IO String
+ Control.Category.Hask: getLine :: IO String
+ Control.Category.Hask: head :: () => [a] -> a
+ Control.Category.Hask: infix 4 `notElem`
+ Control.Category.Hask: infixl 4 <$>
+ Control.Category.Hask: infixl 9 !!
+ Control.Category.Hask: infixr 0 $!
+ Control.Category.Hask: infixr 1 =<<
+ Control.Category.Hask: infixr 2 ||
+ Control.Category.Hask: infixr 3 &&
+ Control.Category.Hask: infixr 5 ++
+ Control.Category.Hask: infixr 8 ^
+ Control.Category.Hask: init :: () => [a] -> [a]
+ Control.Category.Hask: interact :: String -> String -> IO ()
+ Control.Category.Hask: ioError :: () => IOError -> IO a
+ Control.Category.Hask: isDenormalized :: RealFloat a => a -> Bool
+ Control.Category.Hask: isIEEE :: RealFloat a => a -> Bool
+ Control.Category.Hask: isInfinite :: RealFloat a => a -> Bool
+ Control.Category.Hask: isNaN :: RealFloat a => a -> Bool
+ Control.Category.Hask: isNegativeZero :: RealFloat a => a -> Bool
+ Control.Category.Hask: iterate :: () => a -> a -> a -> [a]
+ Control.Category.Hask: last :: () => [a] -> a
+ Control.Category.Hask: lcm :: Integral a => a -> a -> a
+ Control.Category.Hask: length :: Foldable t => t a -> Int
+ Control.Category.Hask: lex :: ReadS String
+ Control.Category.Hask: lines :: String -> [String]
+ Control.Category.Hask: log :: Floating a => a -> a
+ Control.Category.Hask: logBase :: Floating a => a -> a -> a
+ Control.Category.Hask: lookup :: Eq a => a -> [(a, b)] -> Maybe b
+ Control.Category.Hask: map :: () => a -> b -> [a] -> [b]
+ Control.Category.Hask: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b
+ Control.Category.Hask: mapM_ :: (Foldable t, Monad m) => a -> m b -> t a -> m ()
+ Control.Category.Hask: mappend :: Monoid a => a -> a -> a
+ Control.Category.Hask: max :: Ord a => a -> a -> a
+ Control.Category.Hask: maxBound :: Bounded a => a
+ Control.Category.Hask: maximum :: (Foldable t, Ord a) => t a -> a
+ Control.Category.Hask: maybe :: () => b -> a -> b -> Maybe a -> b
+ Control.Category.Hask: mconcat :: Monoid a => [a] -> a
+ Control.Category.Hask: mempty :: Monoid a => a
+ Control.Category.Hask: min :: Ord a => a -> a -> a
+ Control.Category.Hask: minBound :: Bounded a => a
+ Control.Category.Hask: minimum :: (Foldable t, Ord a) => t a -> a
+ Control.Category.Hask: mod :: Integral a => a -> a -> a
+ Control.Category.Hask: negate :: Num a => a -> a
+ Control.Category.Hask: not :: Bool -> Bool
+ Control.Category.Hask: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Control.Category.Hask: null :: Foldable t => t a -> Bool
+ Control.Category.Hask: odd :: Integral a => a -> Bool
+ Control.Category.Hask: or :: Foldable t => t Bool -> Bool
+ Control.Category.Hask: otherwise :: Bool
+ Control.Category.Hask: pi :: Floating a => a
+ Control.Category.Hask: pred :: Enum a => a -> a
+ Control.Category.Hask: print :: Show a => a -> IO ()
+ Control.Category.Hask: product :: (Foldable t, Num a) => t a -> a
+ Control.Category.Hask: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Control.Category.Hask: pure :: Applicative f => a -> f a
+ Control.Category.Hask: putChar :: Char -> IO ()
+ Control.Category.Hask: putStr :: String -> IO ()
+ Control.Category.Hask: putStrLn :: String -> IO ()
+ Control.Category.Hask: quot :: Integral a => a -> a -> a
+ Control.Category.Hask: quotRem :: Integral a => a -> a -> (a, a)
+ Control.Category.Hask: read :: Read a => String -> a
+ Control.Category.Hask: readFile :: FilePath -> IO String
+ Control.Category.Hask: readIO :: Read a => String -> IO a
+ Control.Category.Hask: readList :: Read a => ReadS [a]
+ Control.Category.Hask: readLn :: Read a => IO a
+ Control.Category.Hask: readParen :: () => Bool -> ReadS a -> ReadS a
+ Control.Category.Hask: reads :: Read a => ReadS a
+ Control.Category.Hask: readsPrec :: Read a => Int -> ReadS a
+ Control.Category.Hask: realToFrac :: (Real a, Fractional b) => a -> b
+ Control.Category.Hask: recip :: Fractional a => a -> a
+ Control.Category.Hask: rem :: Integral a => a -> a -> a
+ Control.Category.Hask: repeat :: () => a -> [a]
+ Control.Category.Hask: replicate :: () => Int -> a -> [a]
+ Control.Category.Hask: return :: Monad m => a -> m a
+ Control.Category.Hask: reverse :: () => [a] -> [a]
+ Control.Category.Hask: round :: (RealFrac a, Integral b) => a -> b
+ Control.Category.Hask: scaleFloat :: RealFloat a => Int -> a -> a
+ Control.Category.Hask: scanl :: () => b -> a -> b -> b -> [a] -> [b]
+ Control.Category.Hask: scanl1 :: () => a -> a -> a -> [a] -> [a]
+ Control.Category.Hask: scanr :: () => a -> b -> b -> b -> [a] -> [b]
+ Control.Category.Hask: scanr1 :: () => a -> a -> a -> [a] -> [a]
+ Control.Category.Hask: seq :: () => a -> b -> b
+ Control.Category.Hask: sequence :: (Traversable t, Monad m) => t m a -> m t a
+ Control.Category.Hask: sequenceA :: (Traversable t, Applicative f) => t f a -> f t a
+ Control.Category.Hask: sequence_ :: (Foldable t, Monad m) => t m a -> m ()
+ Control.Category.Hask: show :: Show a => a -> String
+ Control.Category.Hask: showChar :: Char -> ShowS
+ Control.Category.Hask: showList :: Show a => [a] -> ShowS
+ Control.Category.Hask: showParen :: Bool -> ShowS -> ShowS
+ Control.Category.Hask: showString :: String -> ShowS
+ Control.Category.Hask: shows :: Show a => a -> ShowS
+ Control.Category.Hask: showsPrec :: Show a => Int -> a -> ShowS
+ Control.Category.Hask: significand :: RealFloat a => a -> a
+ Control.Category.Hask: signum :: Num a => a -> a
+ Control.Category.Hask: sin :: Floating a => a -> a
+ Control.Category.Hask: sinh :: Floating a => a -> a
+ Control.Category.Hask: snd :: () => (a, b) -> b
+ Control.Category.Hask: span :: () => a -> Bool -> [a] -> ([a], [a])
+ Control.Category.Hask: splitAt :: () => Int -> [a] -> ([a], [a])
+ Control.Category.Hask: sqrt :: Floating a => a -> a
+ Control.Category.Hask: subtract :: Num a => a -> a -> a
+ Control.Category.Hask: succ :: Enum a => a -> a
+ Control.Category.Hask: sum :: (Foldable t, Num a) => t a -> a
+ Control.Category.Hask: tail :: () => [a] -> [a]
+ Control.Category.Hask: take :: () => Int -> [a] -> [a]
+ Control.Category.Hask: takeWhile :: () => a -> Bool -> [a] -> [a]
+ Control.Category.Hask: tan :: Floating a => a -> a
+ Control.Category.Hask: tanh :: Floating a => a -> a
+ Control.Category.Hask: toEnum :: Enum a => Int -> a
+ Control.Category.Hask: toInteger :: Integral a => a -> Integer
+ Control.Category.Hask: toRational :: Real a => a -> Rational
+ Control.Category.Hask: traverse :: (Traversable t, Applicative f) => a -> f b -> t a -> f t b
+ Control.Category.Hask: truncate :: (RealFrac a, Integral b) => a -> b
+ Control.Category.Hask: type FilePath = String
+ Control.Category.Hask: type IOError = IOException
+ Control.Category.Hask: type Rational = Ratio Integer
+ Control.Category.Hask: type ReadS a = String -> [(a, String)]
+ Control.Category.Hask: type ShowS = String -> String
+ Control.Category.Hask: type String = [Char]
+ Control.Category.Hask: uncurry :: () => a -> b -> c -> (a, b) -> c
+ Control.Category.Hask: undefined :: HasCallStack => a
+ Control.Category.Hask: unlines :: [String] -> String
+ Control.Category.Hask: until :: () => a -> Bool -> a -> a -> a -> a
+ Control.Category.Hask: unwords :: [String] -> String
+ Control.Category.Hask: unzip :: () => [(a, b)] -> ([a], [b])
+ Control.Category.Hask: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])
+ Control.Category.Hask: userError :: String -> IOError
+ Control.Category.Hask: words :: String -> [String]
+ Control.Category.Hask: writeFile :: FilePath -> String -> IO ()
+ Control.Category.Hask: zip :: () => [a] -> [b] -> [(a, b)]
+ Control.Category.Hask: zip3 :: () => [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]
+ Data.Foldable.Constrained: instance (Control.Applicative.Constrained.Monoidal f k k, Control.Arrow.Constrained.Function k, u ~ 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 ~ 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)
+ Data.Foldable.Constrained: instance (Control.Category.Constrained.Category k, Control.Category.Constrained.Object k a) => GHC.Base.Semigroup (Data.Foldable.Constrained.Endo' k a)
- Data.Foldable.Constrained: fold :: (Foldable t k k, Monoid m, Object k m, Object k (t m)) => t m `k` m
+ Data.Foldable.Constrained: fold :: (Foldable t k k, Monoid m, Semigroup m, Object k m, Object k (t m)) => t m `k` m
- Data.Foldable.Constrained: foldMap :: (Foldable t k l, Object k a, Object l (t a), Monoid m, Object k m, Object l m) => (a `k` m) -> t a `l` m
+ Data.Foldable.Constrained: foldMap :: (Foldable t k l, Object k a, Object l (t a), Semigroup m, Monoid m, Object k m, Object l m) => (a `k` m) -> t a `l` m
Files
- Control/Category/Constrained.hs +3/−0
- Data/Foldable/Constrained.hs +15/−6
- constrained-categories.cabal +3/−2
Control/Category/Constrained.hs view
@@ -35,6 +35,7 @@ -- * Constraining a category , ConstrainedCategory (ConstrainedMorphism) , constrained, unconstrained+ , ConstrainedFunction -- * Global-element proxies , HasAgent (..) , genericAlg, genericAgentMap@@ -118,6 +119,8 @@ type Object (ConstrainedCategory k isObj) o = (Object k o, isObj o) id = ConstrainedMorphism id ConstrainedMorphism f . ConstrainedMorphism g = ConstrainedMorphism $ f . g++type ConstrainedFunction isObj = ConstrainedCategory (->) isObj -- | Apart from /the/ identity morphism, 'id', there are other morphisms that
Data/Foldable/Constrained.hs view
@@ -38,7 +38,9 @@ , mapM_, sequence_, concatMap , Foldable(..) )-import Data.Monoid++import Data.Semigroup+import Data.Monoid hiding ((<>)) import qualified Data.List as List import qualified Control.Category.Hask as Hask@@ -69,25 +71,32 @@ -- @ -- 'foldMap' ≡ 'Hask.foldMap' -- @- foldMap :: ( Object k a, Object l (t a), Monoid m, Object k m, Object l m )+ foldMap :: ( Object k a, Object l (t a), Semigroup m, Monoid m, Object k m, Object l m ) => (a `k` m) -> t a `l` m -fold :: (Foldable t k k, Monoid m, Object k m, Object k (t m)) => t m `k` m+fold :: (Foldable t k k, Monoid m, Semigroup m, Object k m, Object k (t m)) => t m `k` m fold = foldMap id newtype Endo' k a = Endo' { runEndo' :: k a a }+instance (Category k, Object k a) => Semigroup (Endo' k a) where+ (Endo' f) <> (Endo' g) = Endo' $ f . g instance (Category k, Object k a) => Monoid (Endo' k a) where mempty = Endo' id- mappend (Endo' f) (Endo' g) = Endo' $ f . g+ mappend = (<>) newtype Monoidal_ (r :: * -> * -> *) (s :: * -> * -> *) (f :: * -> *) (u :: *) = Monoidal { runMonoidal :: f u } instance ( Monoidal f k k, Function k- , u ~ UnitObject k, Monoid u + , u ~ UnitObject k, Semigroup u, Monoid u , ObjectPair k u u, ObjectPair k (f u) (f u), Object k (f u,f u)+ ) => Semigroup (Monoidal_ k k f u) where+ (<>) = mappendMdl+instance ( Monoidal f k k, Function k+ , u ~ UnitObject k, Semigroup u, Monoid u + , ObjectPair k u u, ObjectPair k (f u) (f u), Object k (f u,f u) ) => Monoid (Monoidal_ k k f u) where mempty = memptyMdl- mappend = mappendMdl+ mappend = (<>) memptyMdl :: forall r s f u v . ( Monoidal f r s, Function s , ObjectPair s u u, Monoid v
constrained-categories.cabal view
@@ -1,5 +1,5 @@ Name: constrained-categories-Version: 0.3.1.0+Version: 0.3.1.1 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@@ -31,7 +31,7 @@ Homepage: https://github.com/leftaroundabout/constrained-categories Build-Type: Simple Cabal-Version: >=1.10-Tested-With: GHC == 7.8.4, GHC == 7.10.2, GHC == 8.0.2+Tested-With: GHC == 7.8.4, GHC == 7.10.2, GHC == 8.0.2, GHC == 8.2.1 source-repository head@@ -43,6 +43,7 @@ Build-Depends: base>=4.7 && <5 , tagged , void+ , semigroups Default-Extensions: ConstraintKinds TypeFamilies FlexibleInstances