interface Control.Arrow where {
infixr  2 +++;
infixr  2 |||;
infixr  5 <+>;
infixr  1 ^<<;
infixr  1 <<^;
infixr  1 >>^;
infixr  1 ^>>;
infixr  3 ***;
infixr  3 &&&;
infixr  1 Control.Category.<<<;
infixr  1 Control.Category.>>>;

{-# NEED #-}
instance Data.Typeable.Typeable1 Ratio.Ratio;

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.Internal.IO;

{-# 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.Monad a) => Control.Category.Category (Kleisli a);

{-# NEED #-}
instance Control.Category.Category ( (->) a);

{-# 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.Enum NHC.DErrNo.ErrNo;

{-# 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.Eq NHC.DErrNo.ErrNo;

{-# NEED #-}
instance Prelude.Eq IO.Handle;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Eq (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Functor NHC.Internal.IO;

{-# NEED #-}
instance Prelude.Show NHC.DErrNo.ErrNo;

{-# NEED #-}
instance Prelude.Show IO.Handle;

{-# 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.[];

{-# NEED #-}
instance Control.Monad.Fix.MonadFix Prelude.Maybe;

{-# NEED #-}
instance Control.Monad.Fix.MonadFix NHC.Internal.IO;

{-# NEED #-}
instance Control.Monad.Fix.MonadFix ( (->) a);

{-# NEED #-}
instance Data.Typeable.Typeable IO.Handle;

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (Ratio.Ratio a);

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (NHC.Internal.IO a);

{-# NEED #-}
instance Control.Monad.MonadPlus Prelude.[];

{-# NEED #-}
instance Control.Monad.MonadPlus Prelude.Maybe;

{-# 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 Data.Typeable
{-# NEED Typeable #-}
class Typeable a;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;
interface NHC.DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface NHC.Internal
{-# 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) -> ((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 second (***) (&&&) arr first} #-}
class (Control.Category.Category a) => Arrow a where {
  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))));
  arr{-# 1 #-}::((b -> c) -> ((a b) c));
  first{-# 1 #-}::(((a b) c) -> ((a (b,d)) (c,d)));
};
interface ! Control.Category
{-# NEED (<<<) #-}
(<<<){-# 0 #-}::(Control.Category.Category a) => (((a b) c) -> (((a d) b) -> ((a d) c)));

{-# NEED (>>>) #-}
(>>>){-# 2 #-}::(Control.Category.Category a) => (((a b) c) -> (((a c) d) -> ((a b) d)));
interface Control.Category
{-# NEED Category #-}
class Category a;
}
