interface Text.XML.HaXml.Combinators where {
infixr  5 `oo`;
infixr  4 `guards`;
infixr  4 `when`;
infixl  5 </;
infixl  5 />;
infixl  6 `without`;
infixl  6 `with`;
infixl  5 |>|;
infixr  5 `andThen`;
infixr  5 `union`;
infixr  5 `o`;
infixr  3 ?>;
infixr  3 :>;

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

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Types.AttValue;

{-# NEED #-}
instance Prelude.Show Text.XML.HaXml.Types.Reference;

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

{-# NEED #-}
instance Prelude.Functor Text.XML.HaXml.Types.Content;

{-# NEED #-}
instance Prelude.Functor Text.XML.HaXml.Types.Element;

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

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.AttValue;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.Misc;

{-# NEED #-}
instance Prelude.Eq Text.XML.HaXml.Types.Reference;

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Text.XML.HaXml.Types.Content a);

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Text.XML.HaXml.Types.Element a);
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface ! Text.XML.HaXml.Combinators
{-# NEED extracted #-}
extracted{-# 2 #-}::(((Text.XML.HaXml.Types.Content a) -> b) -> ((CFilter a) -> (LabelFilter a b)));

{-# NEED textlabelled #-}
textlabelled{-# 1 #-}::((CFilter a) -> (LabelFilter a (Prelude.Maybe Prelude.String)));

{-# NEED attributed #-}
attributed{-# 2 #-}::(Prelude.String -> ((CFilter a) -> (LabelFilter a Prelude.String)));

{-# NEED tagged #-}
tagged{-# 1 #-}::((CFilter a) -> (LabelFilter a Prelude.String));

{-# NEED interspersed #-}
interspersed{-# 3 #-}::(Prelude.String -> ((CFilter a) -> (Prelude.String -> (LabelFilter a Prelude.String))));

{-# NEED numbered #-}
numbered{-# 1 #-}::((CFilter a) -> (LabelFilter a Prelude.Int));

{-# NEED x #-}
x{-# 2 #-}::(((CFilter a) -> (LabelFilter a b)) -> (((CFilter a) -> (LabelFilter a c)) -> ((CFilter a) -> (LabelFilter a (b,c)))));

{-# NEED oo #-}
oo{-# 2 #-}::((a -> (CFilter b)) -> ((LabelFilter b a) -> (CFilter b)));

{-# NEED LabelFilter #-}
type {-# 2 #-} LabelFilter a b = ((Text.XML.HaXml.Types.Content a) -> [(b,(Text.XML.HaXml.Types.Content a))]);

{-# NEED replaceAttrs #-}
replaceAttrs{-# 2 #-}::([(Prelude.String,Prelude.String)] -> (CFilter a));

{-# NEED replaceTag #-}
replaceTag{-# 2 #-}::(Prelude.String -> (CFilter a));

{-# NEED cdata #-}
cdata{-# 1 #-}::(Prelude.String -> (CFilter a));

{-# NEED literal #-}
literal{-# 1 #-}::(Prelude.String -> (CFilter a));

{-# NEED mkElemAttr #-}
mkElemAttr{-# 3 #-}::(Prelude.String -> ([(Prelude.String,(CFilter a))] -> ([(CFilter a)] -> (CFilter a))));

{-# NEED mkElem #-}
mkElem{-# 2 #-}::(Prelude.String -> ([(CFilter a)] -> (CFilter a)));

{-# NEED foldXml #-}
foldXml{-# 1 #-}::((CFilter a) -> (CFilter a));

{-# NEED inplace #-}
inplace{-# 2 #-}::((CFilter a) -> (CFilter a));

{-# NEED chip #-}
chip{-# 2 #-}::((CFilter a) -> (CFilter a));

{-# NEED guards #-}
guards{-# 2 #-}::((CFilter a) -> ((CFilter a) -> (CFilter a)));

{-# NEED when #-}
when{-# 2 #-}::((CFilter a) -> ((CFilter a) -> (CFilter a)));

{-# NEED multi #-}
multi{-# 1 #-}::((CFilter a) -> (CFilter a));

{-# NEED deepest #-}
deepest{-# 1 #-}::((CFilter a) -> (CFilter a));

{-# NEED deep #-}
deep{-# 1 #-}::((CFilter a) -> (CFilter a));

{-# NEED path #-}
path{-# 1 #-}::([(CFilter a)] -> (CFilter a));

{-# NEED et #-}
et{-# 2 #-}::((Prelude.String -> (CFilter a)) -> ((CFilter a) -> (CFilter a)));

{-# NEED (</) #-}
(</){-# 2 #-}::((CFilter a) -> ((CFilter a) -> (CFilter a)));

{-# NEED (/>) #-}
(/>){-# 2 #-}::((CFilter a) -> ((CFilter a) -> (CFilter a)));

{-# NEED without #-}
without{-# 2 #-}::((CFilter a) -> ((CFilter a) -> (CFilter a)));

{-# NEED with #-}
with{-# 2 #-}::((CFilter a) -> ((CFilter a) -> (CFilter a)));

{-# NEED (|>|) #-}
(|>|){-# 2 #-}::((a -> [b]) -> ((a -> [b]) -> (a -> [b])));

{-# NEED andThen #-}
andThen{-# 2 #-}::((a -> b) -> ((b -> (a -> c)) -> (a -> c)));

{-# NEED cat #-}
cat{-# 1 #-}::([(a -> [b])] -> (a -> [b]));

{-# NEED union #-}
union{-# 0 #-}::((a -> [b]) -> ((a -> [b]) -> (a -> [b])));

{-# NEED o #-}
o{-# 2 #-}::((CFilter a) -> ((CFilter a) -> (CFilter a)));

{-# NEED (?>) #-}
(?>){-# 2 #-}::((a -> [b]) -> ((ThenElse (a -> [b])) -> (a -> [b])));

{-# NEED {ThenElse (:>)} #-}
data ThenElse a
  = (:>) a a;

{-# NEED ifTxt #-}
ifTxt{-# 3 #-}::((Prelude.String -> (CFilter a)) -> ((CFilter a) -> (CFilter a)));

{-# NEED iffind #-}
iffind{-# 4 #-}::(Prelude.String -> ((Prelude.String -> (CFilter a)) -> ((CFilter a) -> (CFilter a))));

{-# NEED find #-}
find{-# 3 #-}::(Prelude.String -> ((Prelude.String -> (CFilter a)) -> (CFilter a)));

{-# NEED attrval #-}
attrval{-# 2 #-}::(Text.XML.HaXml.Types.Attribute -> (CFilter a));

{-# NEED attr #-}
attr{-# 2 #-}::(Text.XML.HaXml.Types.Name -> (CFilter a));

{-# NEED tagWith #-}
tagWith{-# 2 #-}::((Prelude.String -> Prelude.Bool) -> (CFilter a));

{-# NEED tag #-}
tag{-# 2 #-}::(Prelude.String -> (CFilter a));

{-# NEED txt #-}
txt{-# 1 #-}::(CFilter a);

{-# NEED elm #-}
elm{-# 1 #-}::(CFilter a);

{-# NEED position #-}
position{-# 2 #-}::(Prelude.Int -> ((CFilter a) -> (CFilter a)));

{-# NEED children #-}
children{-# 1 #-}::(CFilter a);

{-# NEED none #-}
none{-# 0 #-}::(a -> [b]);

{-# NEED keep #-}
keep{-# 0 #-}::(a -> [a]);

{-# NEED CFilter #-}
type {-# 1 #-} CFilter a = ((Text.XML.HaXml.Types.Content a) -> [(Text.XML.HaXml.Types.Content a)]);
interface Text.XML.HaXml.Types
{-# NEED Element Content #-}
data Element a;
data Content a;

{-# NEED Misc #-}
data Misc;

{-# NEED ProcessingInstruction #-}
type {-# 4 #-} ProcessingInstruction = (PITarget,Prelude.String);

{-# NEED PITarget #-}
type {-# 3 #-} PITarget = Prelude.String;

{-# NEED Comment #-}
type {-# 7 #-} Comment = Prelude.String;

{-# NEED CharData #-}
type {-# 20 #-} CharData = Prelude.String;

{-# NEED Attribute #-}
type {-# 9 #-} Attribute = (Name,AttValue);

{-# NEED AttValue #-}
data AttValue;

{-# NEED Reference #-}
data Reference;

{-# NEED CharRef #-}
type {-# 16 #-} CharRef = Prelude.Int;

{-# NEED EntityRef #-}
type {-# 15 #-} EntityRef = Name;

{-# NEED Name #-}
type {-# 8 #-} Name = Prelude.String;
}