interface Control.Arrow where {
infixr 2 +++;
infixr 2 |||;
infixr 5 <+>;
infixr 1 ^<<;
infixr 1 <<^;
infixr 1 <<<;
infixr 1 >>^;
infixr 1 ^>>;
infixr 3 ***;
infixr 3 &&&;
infixr 1 >>>;
{-# NEED #-}
instance (Control.Monad.Fix.MonadFix a) => ArrowLoop (Kleisli a);
{-# NEED #-}
instance ArrowLoop (Prelude.->);
{-# NEED #-}
instance (Prelude.Monad a) => ArrowApply (Kleisli a);
{-# NEED #-}
instance ArrowApply (Prelude.->);
{-# NEED #-}
instance (Prelude.Monad a) => ArrowChoice (Kleisli a);
{-# NEED #-}
instance ArrowChoice (Prelude.->);
{-# NEED #-}
instance (Control.Monad.MonadPlus a) => ArrowPlus (Kleisli a);
{-# NEED #-}
instance (Control.Monad.MonadPlus a) => ArrowZero (Kleisli a);
{-# NEED #-}
instance (Prelude.Monad a) => Arrow (Kleisli a);
{-# NEED #-}
instance Arrow (Prelude.->);
{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Fractional (Ratio.Ratio a);
{-# NEED #-}
instance (Prelude.Integral a) => Prelude.RealFrac (Ratio.Ratio a);
{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Num (Ratio.Ratio a);
{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Real (Ratio.Ratio a);
{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Enum (Ratio.Ratio a);
{-# NEED #-}
instance (Prelude.Read a,Prelude.Integral a) => Prelude.Read (Ratio.Ratio a);
{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Ord (Ratio.Ratio a);
{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Eq (Ratio.Ratio a);
{-# NEED #-}
instance Prelude.Functor NHC.Internal.IO;
{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Show (Ratio.Ratio a);
{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (NHC.Internal.IO a);
{-# NEED #-}
instance Control.Monad.Fix.MonadFix Prelude.Maybe;
{-# NEED #-}
instance Control.Monad.Fix.MonadFix Prelude.[];
{-# NEED #-}
instance Control.Monad.Fix.MonadFix NHC.Internal.IO;
{-# NEED #-}
instance Control.Monad.Fix.MonadFix ( (->) a);
{-# NEED #-}
instance Control.Monad.MonadPlus Prelude.Maybe;
{-# NEED #-}
instance Control.Monad.MonadPlus Prelude.[];
{-# NEED #-}
instance (ArrowApply a) => Prelude.Monad (ArrowMonad a);
{-# NEED #-}
instance Prelude.Monad NHC.Internal.IO;
interface Control.Monad.Fix
{-# NEED MonadFix #-}
class (Prelude.Monad a) => MonadFix a;
interface Control.Monad
{-# NEED MonadPlus #-}
class (Prelude.Monad a) => MonadPlus a;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface NHC.Internal
{-# NEED IO #-}
newtype {-# #-} IO a;
{-# NEED World #-}
data World;
interface ! Control.Arrow
{-# NEED {ArrowLoop loop} #-}
class (Arrow a) => ArrowLoop a where {
loop{-# 1 #-}::(((a (b,c)) (d,c)) -> ((a b) d));
};
{-# NEED leftApp #-}
leftApp{-# 1 #-}::(ArrowApply a) => (((a b) c) -> ((a (Prelude.Either b d)) (Prelude.Either c d)));
{-# NEED {ArrowMonad ArrowMonad} #-}
newtype {-# #-} (ArrowApply a) => ArrowMonad a b
= ArrowMonad ((a ()) b);
{-# NEED {ArrowApply app} #-}
class (Arrow a) => ArrowApply a where {
app{-# 0 #-}::((a (((a b) c),b)) c);
};
{-# NEED {ArrowChoice right (+++) (|||) left} #-}
class (Arrow a) => ArrowChoice a where {
right{-# 1 #-}::(((a b) c) -> ((a (Prelude.Either d b)) (Prelude.Either d c)));
(+++){-# 2 #-}::(((a b) c) -> (((a d) e) -> ((a (Prelude.Either b d)) (Prelude.Either c e))));
(|||){-# 2 #-}::(((a b) c) -> (((a d) c) -> ((a (Prelude.Either b d)) c)));
left{-# 1 #-}::(((a b) c) -> ((a (Prelude.Either b d)) (Prelude.Either c d)));
};
{-# NEED {ArrowPlus (<+>)} #-}
class (ArrowZero a) => ArrowPlus a where {
(<+>){-# 2 #-}::(((a b) c) -> (((a b) c) -> ((a b) c)));
};
{-# NEED {ArrowZero zeroArrow} #-}
class (Arrow a) => ArrowZero a where {
zeroArrow{-# 0 #-}::((a b) c);
};
{-# NEED (^<<) #-}
(^<<){-# 2 #-}::(Arrow c) => ((a -> b) -> (((c d) a) -> ((c d) b)));
{-# NEED (<<^) #-}
(<<^){-# 2 #-}::(Arrow a) => (((a b) c) -> ((d -> b) -> ((a d) c)));
{-# NEED (<<<) #-}
(<<<){-# 2 #-}::(Arrow a) => (((a b) c) -> (((a d) b) -> ((a d) c)));
{-# NEED (>>^) #-}
(>>^){-# 2 #-}::(Arrow a) => (((a b) c) -> ((c -> d) -> ((a b) d)));
{-# NEED (^>>) #-}
(^>>){-# 2 #-}::(Arrow c) => ((a -> b) -> (((c b) d) -> ((c a) d)));
{-# NEED returnA #-}
returnA{-# 0 #-}::(Arrow a) => ((a b) b);
{-# NEED {Kleisli Kleisli runKleisli} #-}
newtype {-# #-} Kleisli a b c
= Kleisli {runKleisli :: (b -> (a c))};
{-# NEED {Arrow arr pure second (***) (&&&) (>>>) first} #-}
class Arrow a where {
arr{-# 1 #-}::((b -> c) -> ((a b) c));
pure{-# 1 #-}::((b -> c) -> ((a b) c));
second{-# 1 #-}::(((a b) c) -> ((a (d,b)) (d,c)));
(***){-# 2 #-}::(((a b) c) -> (((a d) e) -> ((a (b,d)) (c,e))));
(&&&){-# 2 #-}::(((a b) c) -> (((a b) d) -> ((a b) (c,d))));
(>>>){-# 2 #-}::(((a b) c) -> (((a c) d) -> ((a b) d)));
first{-# 1 #-}::(((a b) c) -> ((a (b,d)) (c,d)));
};
}
|