Text.XML.WraXML.Tree

data structures

newtype T i name str

Constructors

Cons

Fields

• unwrap :: T i (Branch name str) (Leaf name str)

Instances

Functor (T i name)

Defined in Text.XML.WraXML.Tree

Methods

fmap :: (a -> b) -> T i name a -> T i name b

(<$) :: a -> T i name b -> T i name a

Foldable (T i name)

Defined in Text.XML.WraXML.Tree

Methods

fold :: Monoid m => T i name m -> m

foldMap :: Monoid m => (a -> m) -> T i name a -> m

foldr :: (a -> b -> b) -> b -> T i name a -> b

foldr' :: (a -> b -> b) -> b -> T i name a -> b

foldl :: (b -> a -> b) -> b -> T i name a -> b

foldl' :: (b -> a -> b) -> b -> T i name a -> b

foldr1 :: (a -> a -> a) -> T i name a -> a

foldl1 :: (a -> a -> a) -> T i name a -> a

toList :: T i name a -> [a]

null :: T i name a -> Bool

length :: T i name a -> Int

elem :: Eq a => a -> T i name a -> Bool

maximum :: Ord a => T i name a -> a

minimum :: Ord a => T i name a -> a

sum :: Num a => T i name a -> a

product :: Num a => T i name a -> a

Traversable (T i name)

Defined in Text.XML.WraXML.Tree

Methods

traverse :: Applicative f => (a -> f b) -> T i name a -> f (T i name b)

sequenceA :: Applicative f => T i name (f a) -> f (T i name a)

mapM :: Monad m => (a -> m b) -> T i name a -> m (T i name b)

sequence :: Monad m => T i name (m a) -> m (T i name a)

(Attribute name, Show i, Show name, Show str) => Show (T i name str)

Defined in Text.XML.WraXML.Tree

Methods

showsPrec :: Int -> T i name str -> ShowS

show :: T i name str -> String

showList :: [T i name str] -> ShowS

(Tag name, Attribute name, C string) => C (T i name string)

Defined in Text.XML.WraXML.Tree

Methods

run :: T i name string -> ShowS

data Branch name str

Constructors

Tag

Fields

• getElement :: T name str

Instances

(Attribute name, Show name, Show str) => Show (Branch name str)

Defined in Text.XML.WraXML.Tree

Methods

showsPrec :: Int -> Branch name str -> ShowS

show :: Branch name str -> String

showList :: [Branch name str] -> ShowS

data Leaf name str

Constructors

Text Bool str

Comment String

CData String

PI (Name name) (T name str)

Warning String

Instances

Functor (Leaf name)

Defined in Text.XML.WraXML.Tree

Methods

fmap :: (a -> b) -> Leaf name a -> Leaf name b

(<$) :: a -> Leaf name b -> Leaf name a

Foldable (Leaf name)

Defined in Text.XML.WraXML.Tree

Methods

fold :: Monoid m => Leaf name m -> m

foldMap :: Monoid m => (a -> m) -> Leaf name a -> m

foldr :: (a -> b -> b) -> b -> Leaf name a -> b

foldr' :: (a -> b -> b) -> b -> Leaf name a -> b

foldl :: (b -> a -> b) -> b -> Leaf name a -> b

foldl' :: (b -> a -> b) -> b -> Leaf name a -> b

foldr1 :: (a -> a -> a) -> Leaf name a -> a

foldl1 :: (a -> a -> a) -> Leaf name a -> a

toList :: Leaf name a -> [a]

null :: Leaf name a -> Bool

length :: Leaf name a -> Int

elem :: Eq a => a -> Leaf name a -> Bool

maximum :: Ord a => Leaf name a -> a

minimum :: Ord a => Leaf name a -> a

sum :: Num a => Leaf name a -> a

product :: Num a => Leaf name a -> a

Traversable (Leaf name)

Defined in Text.XML.WraXML.Tree

Methods

traverse :: Applicative f => (a -> f b) -> Leaf name a -> f (Leaf name b)

sequenceA :: Applicative f => Leaf name (f a) -> f (Leaf name a)

mapM :: Monad m => (a -> m b) -> Leaf name a -> m (Leaf name b)

sequence :: Monad m => Leaf name (m a) -> m (Leaf name a)

(Attribute name, Show name, Show str) => Show (Leaf name str)

Defined in Text.XML.WraXML.Tree

Methods

showsPrec :: Int -> Leaf name str -> ShowS

show :: Leaf name str -> String

showList :: [Leaf name str] -> ShowS

(Tag name, Attribute name, C string) => C (Leaf name string)

Defined in Text.XML.WraXML.Tree

Methods

run :: Leaf name string -> ShowS

type AttributePlain = (String, String)

Deprecated: use Attribute type from xml-basic package instead

generators

wrap :: T i (Branch name str) (Leaf name str) -> T i name str

wrap2 :: i -> Elem i (Branch name str) (Leaf name str) -> T i name str

lift :: (T i (Branch name str0) (Leaf name str0) -> T j (Branch name str1) (Leaf name str1)) -> T i name str0 -> T j name str1

liftA :: Applicative m => (T i (Branch name str0) (Leaf name str0) -> m (T i (Branch name str1) (Leaf name str1))) -> T i name str0 -> m (T i name str1)

literal :: str -> T i name str

Build some textual content.

literalIndex :: i -> str -> T i name str

comment :: String -> T i name str

commentIndex :: i -> String -> T i name str

warning :: String -> T i name str

warningIndex :: i -> String -> T i name str

cdata :: String -> T i name str

cdataIndex :: i -> String -> T i name str

processing :: Name name -> T name str -> T i name str

processingIndex :: i -> Name name -> T name str -> T i name str

tag :: Name name -> [T i name str] -> T i name str

tagAttr :: Name name -> [T name str] -> [T i name str] -> T i name str

tagIndexAttr :: i -> Name name -> [T name str] -> [T i name str] -> T i name str

Conversions

liftTrans :: (a -> b) -> a -> [b]

liftText :: (String -> String) -> Leaf name String -> Leaf name String

liftTextA :: Applicative m => (String -> m String) -> Leaf name String -> m (Leaf name String)

liftElement :: (T name str0 -> T name str1) -> Branch name str0 -> Branch name str1

liftElementA :: Applicative m => (T name str0 -> m (T name str1)) -> Branch name str0 -> m (Branch name str1)

Tests

checkTag :: (T name str -> Bool) -> T i name str -> Bool

If the Tree is a Leaf, then return False. Otherwise return the result of the predicate.

maybeTag :: T i name str -> Maybe (T name str, [T i name str])

maybeText :: T i name str -> Maybe str

maybeTextLeaf :: Leaf name str -> Maybe str

maybeCommentLeaf :: Leaf name str -> Maybe String

maybeCDataLeaf :: Leaf name str -> Maybe String

maybeProcessingLeaf :: Leaf name str -> Maybe (Name name, T name str)

maybeWarningLeaf :: Leaf name str -> Maybe String

fold :: (i -> a -> b) -> (T name str -> [b] -> a) -> (Leaf name str -> a) -> T i name str -> b

switch :: (i -> a -> b) -> (T name str -> [T i name str] -> a) -> (Leaf name str -> a) -> T i name str -> b

types of processors

type Filter i name str = T i name str -> T i name str

type FilterA m i name str = T i name str -> m (T i name str)

tree processors

mapText :: (String -> String) -> T i name String -> T i name String

mapIndex :: (i -> j) -> T i name str -> T j name str

mapTag :: Filter name str -> Filter i name str

textFromCData :: T i name String -> T i name String

Convert all CData sections to plain text.

filterTag :: (T name str -> Bool) -> T i name str -> [T i name str]

You can e.g. filter text1 b text2 /b text3 to text1 text2 text3 by filterTag (checkTagName ("b"/=)).

mapCond :: (T name str -> Bool) -> Filter name str -> (Leaf name str -> Leaf name str) -> Filter i name str

filterTagsFlatten :: (T name str -> Bool) -> T i name str -> [(T name str, [T i name str])]

Find all branches where the predicate applies and return a list of matching sub-trees in depth-first order.

Example: filterTagsFlatten (checkTagName ("meta"==))

filterElementsFlatten :: (T name str -> Bool) -> T i name str -> [T name str]

allSubTrees :: T i name str -> [T i name str]

mergeStrings :: Monoid str => Filter i name str

merge subsequent string leafs

mergeTopStrings :: Monoid str => [T i name str] -> [T i name str]

processAllSubTrees :: ([T i name str] -> [T i name str]) -> Filter i name str

Process all sub-tree lists in bottom-up order.

processSubTrees :: (Name name -> Bool) -> ([T i name str] -> [T i name str]) -> Filter i name str

processSubTreesAttrs :: (Name name -> Bool) -> (([T name str], [T i name str]) -> ([T name str], [T i name str])) -> Filter i name str

applicative functor tree processors

mapTextA :: Applicative m => (String -> m String) -> FilterA m i name String

mapCondA :: Applicative m => (T name str -> Bool) -> (T name str -> m (T name str)) -> (Leaf name str -> m (Leaf name str)) -> FilterA m i name str

Character decoding

unescape :: T i name T -> T i name String

escape :: T i name String -> T i name T

Use ASCII characters, XML entity references and character references for representing strings. That's not human readable, but portable.

decodeSpecialChars :: (Tag name, Attribute name) => String -> T i name T -> [T i name String]

Deprecated: XmlChar.Unicode constructors must contain unicode characters and not encoded ones. Decode characters before parsing!

Decode characters like those from UTF-8 scheme.

maybeDecodeSpecialChars :: (Tag name, Attribute name) => String -> T i name T -> Maybe [T i name String]

Deprecated: XmlChar.Unicode constructors must contain unicode characters and not encoded ones. Decode characters before parsing!

decodeSpecialCharsDecoder :: (Tag name, Attribute name) => DecodingFctEmbedErrors -> T i name T -> [T i name String]

Deprecated: XmlChar.Unicode constructors must contain unicode characters and not encoded ones. Decode characters before parsing!

Conversion errors are appended as warnings to the tree.

decodeAttrs :: (Tag name, Attribute name) => (T -> EmbeddedExceptions) -> [T name T] -> Writer [String] [T name String]

Deprecated: XmlChar.Unicode constructors must contain unicode characters and not encoded ones. Decode characters before parsing!

decodeAttr :: (Tag name, Attribute name) => (T -> EmbeddedExceptions) -> Name name -> T -> Writer [String] String

Deprecated: XmlChar.Unicode constructors must contain unicode characters and not encoded ones. Decode characters before parsing!

maybeDecodeUTF8Chars :: String -> T i name T -> Maybe (T i name String)

Deprecated: XmlChar.Unicode constructors must contain unicode characters and not encoded ones. Decode characters before parsing!

Formatting

formatMany :: (Tag name, Attribute name, C string) => [T i name string] -> ShowS

format :: (Tag name, Attribute name, C string) => T i name string -> ShowS

formatBranch :: (Tag name, Attribute name, C string) => Branch name string -> [ShowS] -> ShowS

formatLeaf :: (Tag name, Attribute name, C string) => Leaf name string -> ShowS