interface Control.Monad where {
infixr 1 <=<;
infixr 1 >=>;
infixr 1 Prelude.=<<;
infixl 1 Prelude.>>;
infixl 1 Prelude.>>=;
{-# NEED #-}
instance MonadPlus Prelude.[];
{-# NEED #-}
instance MonadPlus Prelude.Maybe;
{-# 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.Monad NHC.Internal.IO;
{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Show (Ratio.Ratio a);
{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (NHC.Internal.IO a);
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface NHC.Internal
{-# NEED IO #-}
newtype {-# #-} IO a;
{-# NEED World #-}
data World;
interface ! Control.Monad
{-# NEED ap #-}
ap{-# 0 #-}::(Prelude.Monad a) => ((a (b -> c)) -> ((a b) -> (a c)));
{-# NEED liftM5 #-}
liftM5{-# 6 #-}::(Prelude.Monad g) => ((a -> (b -> (c -> (d -> (e -> f))))) -> ((g a) -> ((g b) -> ((g c) -> ((g d) -> ((g e) -> (g f)))))));
{-# NEED liftM4 #-}
liftM4{-# 5 #-}::(Prelude.Monad f) => ((a -> (b -> (c -> (d -> e)))) -> ((f a) -> ((f b) -> ((f c) -> ((f d) -> (f e))))));
{-# NEED liftM3 #-}
liftM3{-# 4 #-}::(Prelude.Monad e) => ((a -> (b -> (c -> d))) -> ((e a) -> ((e b) -> ((e c) -> (e d)))));
{-# NEED liftM2 #-}
liftM2{-# 3 #-}::(Prelude.Monad d) => ((a -> (b -> c)) -> ((d a) -> ((d b) -> (d c))));
{-# NEED liftM #-}
liftM{-# 2 #-}::(Prelude.Monad c) => ((a -> b) -> ((c a) -> (c b)));
{-# NEED unless #-}
unless{-# 2 #-}::(Prelude.Monad a) => (Prelude.Bool -> ((a ()) -> (a ())));
{-# NEED when #-}
when{-# 2 #-}::(Prelude.Monad a) => (Prelude.Bool -> ((a ()) -> (a ())));
{-# NEED replicateM_ #-}
replicateM_{-# 2 #-}::(Prelude.Monad a) => (Prelude.Int -> ((a b) -> (a ())));
{-# NEED replicateM #-}
replicateM{-# 2 #-}::(Prelude.Monad a) => (Prelude.Int -> ((a b) -> (a [b])));
{-# NEED foldM_ #-}
foldM_{-# 3 #-}::(Prelude.Monad c) => ((a -> (b -> (c a))) -> (a -> ([b] -> (c ()))));
{-# NEED foldM #-}
foldM{-# 3 #-}::(Prelude.Monad c) => ((a -> (b -> (c a))) -> (a -> ([b] -> (c a))));
{-# NEED zipWithM_ #-}
zipWithM_{-# 3 #-}::(Prelude.Monad c) => ((a -> (b -> (c d))) -> ([a] -> ([b] -> (c ()))));
{-# NEED zipWithM #-}
zipWithM{-# 3 #-}::(Prelude.Monad c) => ((a -> (b -> (c d))) -> ([a] -> ([b] -> (c [d]))));
{-# NEED mapAndUnzipM #-}
mapAndUnzipM{-# 2 #-}::(Prelude.Monad b) => ((a -> (b (c,d))) -> ([a] -> (b ([c],[d]))));
{-# NEED join #-}
join{-# 1 #-}::(Prelude.Monad a) => ((a (a b)) -> (a b));
{-# NEED forever #-}
forever{-# 1 #-}::(Prelude.Monad a) => ((a b) -> (a ()));
{-# NEED (<=<) #-}
(<=<){-# 0 #-}::(Prelude.Monad b) => ((a -> (b c)) -> ((d -> (b a)) -> (d -> (b c))));
{-# NEED (>=>) #-}
(>=>){-# 2 #-}::(Prelude.Monad b) => ((a -> (b c)) -> ((c -> (b d)) -> (a -> (b d))));
{-# NEED msum #-}
msum{-# 0 #-}::(MonadPlus a) => ([(a b)] -> (a b));
{-# NEED forM_ #-}
forM_{-# 0 #-}::(Prelude.Monad b) => ([a] -> ((a -> (b c)) -> (b ())));
{-# NEED forM #-}
forM{-# 0 #-}::(Prelude.Monad b) => ([a] -> ((a -> (b c)) -> (b [c])));
{-# NEED filterM #-}
filterM{-# 2 #-}::(Prelude.Monad b) => ((a -> (b Prelude.Bool)) -> ([a] -> (b [a])));
{-# NEED guard #-}
guard{-# 1 #-}::(MonadPlus a) => (Prelude.Bool -> (a ()));
{-# NEED {MonadPlus mzero mplus} #-}
class (Prelude.Monad a) => MonadPlus a where {
mzero{-# 0 #-}::(a b);
mplus{-# 2 #-}::((a b) -> ((a b) -> (a b)));
};
interface ! Prelude
{-# NEED mapM #-}
mapM{-# 2 #-}::(Prelude.Monad b) => ((a -> (b c)) -> ([a] -> (b [c])));
{-# NEED (=<<) #-}
(=<<){-# 2 #-}::(Prelude.Monad b) => ((a -> (b c)) -> ((b a) -> (b c)));
{-# NEED mapM_ #-}
mapM_{-# 2 #-}::(Prelude.Monad b) => ((a -> (b c)) -> ([a] -> (b ())));
{-# NEED sequence_ #-}
sequence_{-# 0 #-}::(Prelude.Monad a) => ([(a b)] -> (a ()));
{-# NEED sequence #-}
sequence{-# 0 #-}::(Prelude.Monad a) => ([(a b)] -> (a [b]));
{-# NEED {Functor fmap} #-}
class Functor a where {
fmap{-# 2 #-}::((b -> c) -> ((a b) -> (a c)));
};
{-# NEED {Monad (>>) fail (>>=) return} #-}
class Monad a where {
(>>){-# 2 #-}::((a b) -> ((a c) -> (a c)));
fail{-# 1 #-}::(Prelude.String -> (a b));
(>>=){-# 2 #-}::((a b) -> ((b -> (a c)) -> (a c)));
return{-# 1 #-}::(b -> (a b));
};
}
|