Odt reader: remove dead code

The ODT reader contained a lot of general code useful for working with
arrows. However, many of these utils weren't used and are hence removed.

3 files changed, 0 insertions, 456 deletions

diff --git a/src/Text/Pandoc/Readers/Odt/Generic/Fallible.hs b/src/Text/Pandoc/Readers/Odt/Generic/Fallible.hs
index 877443543..4d6a67b8e 100644
--- a/src/Text/Pandoc/Readers/Odt/Generic/Fallible.hs
+++ b/src/Text/Pandoc/Readers/Odt/Generic/Fallible.hs
@@ -39,10 +39,6 @@ compatible instances of "ArrowChoice".
 -- We export everything
 module Text.Pandoc.Readers.Odt.Generic.Fallible where
 
-import           Control.Applicative
-import           Control.Monad
-
-import qualified Data.Foldable       as F
 import           Data.Monoid ((<>))
 
 -- | Default for now. Will probably become a class at some point.
@@ -51,16 +47,6 @@ type Failure = ()
 type Fallible a = Either Failure a
 
 
--- | False -> Left (), True -> Right ()
-boolToEither :: Bool -> Fallible ()
-boolToEither False = Left  ()
-boolToEither True  = Right ()
-
--- | False -> Left (), True -> Right ()
-boolToChoice :: Bool -> Fallible ()
-boolToChoice False = Left  ()
-boolToChoice True  = Right ()
-
 --
 maybeToEither :: Maybe a -> Fallible a
 maybeToEither (Just a) = Right a
@@ -71,21 +57,11 @@ eitherToMaybe :: Either _l a -> Maybe a
 eitherToMaybe (Left  _) = Nothing
 eitherToMaybe (Right a) = Just a
 
--- | > untagEither === either id id
-untagEither :: Either a a -> a
-untagEither (Left  a) = a
-untagEither (Right a) = a
-
 -- | > fromLeft f === either f id
 fromLeft :: (a -> b) -> Either a b -> b
 fromLeft f (Left  a) = f a
 fromLeft _ (Right b) = b
 
--- | > fromRight f === either id f
-fromRight :: (a -> b) -> Either b a -> b
-fromRight _ (Left  b) = b
-fromRight f (Right a) = f a
-
 -- | > recover a === fromLeft (const a) === either (const a) id
 recover :: a -> Either _f a -> a
 recover a (Left  _) = a
@@ -110,24 +86,6 @@ collapseEither (Left f         ) = Left f
 collapseEither (Right (Left  f)) = Left f
 collapseEither (Right (Right x)) = Right x
 
--- | If either of the values represents an error, the result is a
--- (possibly combined) error. If both values represent a success,
--- both are returned.
-chooseMin :: (Monoid a) => Either a b -> Either a b' -> Either a (b,b')
-chooseMin = chooseMinWith (,)
-
--- | If either of the values represents an error, the result is a
--- (possibly combined) error. If both values represent a success,
--- a combination is returned.
-chooseMinWith :: (Monoid a) => (b -> b' -> c)
-                            -> Either a b
-                            -> Either a b'
-                            -> Either a c
-chooseMinWith (><) (Right a) (Right b) = Right $ a >< b
-chooseMinWith  _   (Left  a) (Left  b) = Left  $ a <> b
-chooseMinWith  _   (Left  a)     _     = Left  a
-chooseMinWith  _       _     (Left  b) = Left  b
-
 -- | If either of the values represents a  non-error, the result is a
 -- (possibly combined) non-error. If both values represent an error, an error
 -- is returned.
@@ -152,87 +110,11 @@ chooseMaxWith  _       _     (Right b) = Right b
 class ChoiceVector v where
   spreadChoice :: v (Either f a) -> Either f (v a)
 
--- Let's do a few examples first
-
-instance ChoiceVector Maybe where
-  spreadChoice (Just (Left  f))  = Left  f
-  spreadChoice (Just (Right x))  = Right (Just x)
-  spreadChoice Nothing           = Right Nothing
-
-instance ChoiceVector (Either l) where
-  spreadChoice (Right (Left  f)) = Left  f
-  spreadChoice (Right (Right x)) = Right (Right x)
-  spreadChoice (Left   x       ) = Right (Left x)
-
 instance ChoiceVector ((,) a) where
   spreadChoice (_, Left  f) = Left  f
   spreadChoice (x, Right y) = Right (x,y)
   -- Wasn't there a newtype somewhere with the elements flipped?
 
---
--- More instances later, first some discussion.
---
--- I'll have to freshen up on type system details to see how (or if) to do
--- something like
---
--- > instance (ChoiceVector a, ChoiceVector b) => ChoiceVector (a b) where
--- >   :
---
--- But maybe it would be even better to use something like
---
--- > class ChoiceVector v v' f | v -> v' f where
--- >   spreadChoice :: v -> Either f v'
---
--- That way, more places in @v@ could spread the cheer, e.g.:
---
--- As before:
--- --                       ( a , Either f b)    (a , b)  f
--- > instance ChoiceVector ((,) a (Either f b)) ((,) a b) f where
--- >   spreadChoice (_, Left  f) = Left f
--- >   spreadChoice (a, Right b) = Right (a,b)
---
--- But also:
--- --                       ( Either f a , b)    (a , b)  f
--- > instance ChoiceVector ((,) (Either f a) b) ((,) a b) f where
--- >   spreadChoice (Right a,b) = Right (a,b)
--- >   spreadChoice (Left  f,_) = Left f
---
--- And maybe even:
--- --                        ( Either f a , Either f b)     (a , b)  f
--- > instance ChoiceVector ((,) (Either f a) (Either f b)) ((,) a b) f where
--- >   spreadChoice (Right a , Right b) = Right (a,b)
--- >   spreadChoice (Left  f , _      ) = Left f
--- >   spreadChoice ( _      , Left  f) = Left f
---
--- Of course that would lead to a lot of overlapping instances...
--- But I can't think of a different way. A selector function might help,
--- but not even a "Data.Traversable" is powerful enough for that.
--- But maybe someone has already solved all this with a lens library.
---
--- Well, it's an interesting academic question. But for practical purposes,
--- I have more than enough right now.
-
-instance ChoiceVector ((,,) a b) where
-  spreadChoice (_,_, Left  f) = Left  f
-  spreadChoice (a,b, Right x) = Right (a,b,x)
-
-instance ChoiceVector ((,,,) a b c) where
-  spreadChoice (_,_,_, Left  f) = Left  f
-  spreadChoice (a,b,c, Right x) = Right (a,b,c,x)
-
-instance ChoiceVector ((,,,,) a b c d) where
-  spreadChoice (_,_,_,_, Left  f) = Left  f
-  spreadChoice (a,b,c,d, Right x) = Right (a,b,c,d,x)
-
-instance ChoiceVector (Const a) where
-  spreadChoice (Const c) = Right (Const c) -- need to repackage because of implicit types
-
--- | Fails on the first error
-instance ChoiceVector [] where
-  spreadChoice = sequence -- using the monad instance of Either.
-  -- Could be generalized to "Data.Traversable" - but why play
-  -- with UndecidableInstances unless this is really needed.
-
 -- | Wrapper for a list. While the normal list instance of 'ChoiceVector'
 -- fails whenever it can, this type will never fail.
 newtype SuccessList a = SuccessList { collectNonFailing :: [a] }
@@ -247,14 +129,3 @@ instance ChoiceVector SuccessList  where
 collectRights :: [Either _l r] -> [r]
 collectRights = collectNonFailing . untag . spreadChoice . SuccessList
   where untag = fromLeft (error "Unexpected Left")
-
--- | A version of 'collectRights' generalized to other containers. The
--- container must be both "reducible" and "buildable". Most general containers
--- should fullfill these requirements, but there is no single typeclass
--- (that I know of) for that.
--- Therefore, they are split between 'Foldable' and 'MonadPlus'.
--- (Note that 'Data.Traversable.Traversable' alone would not be enough, either.)
-collectRightsF :: (F.Foldable c, MonadPlus c) => c (Either _l r) ->  c r
-collectRightsF = F.foldr unTagRight mzero
-  where unTagRight (Right x) = mplus $ return x
-        unTagRight _         = id
diff --git a/src/Text/Pandoc/Readers/Odt/Generic/Utils.hs b/src/Text/Pandoc/Readers/Odt/Generic/Utils.hs
index 6c10ed61d..4af4242b6 100644
--- a/src/Text/Pandoc/Readers/Odt/Generic/Utils.hs
+++ b/src/Text/Pandoc/Readers/Odt/Generic/Utils.hs
@@ -38,8 +38,6 @@ module Text.Pandoc.Readers.Odt.Generic.Utils
 , uncurry4
 , uncurry5
 , uncurry6
-, uncurry7
-, uncurry8
 , swap
 , reverseComposition
 , bool
@@ -148,15 +146,11 @@ uncurry3 :: (a->b->c                -> z) -> (a,b,c          ) -> z
 uncurry4 :: (a->b->c->d             -> z) -> (a,b,c,d        ) -> z
 uncurry5 :: (a->b->c->d->e          -> z) -> (a,b,c,d,e      ) -> z
 uncurry6 :: (a->b->c->d->e->f       -> z) -> (a,b,c,d,e,f    ) -> z
-uncurry7 :: (a->b->c->d->e->f->g    -> z) -> (a,b,c,d,e,f,g  ) -> z
-uncurry8 :: (a->b->c->d->e->f->g->h -> z) -> (a,b,c,d,e,f,g,h) -> z
 
 uncurry3 fun (a,b,c          ) = fun a b c
 uncurry4 fun (a,b,c,d        ) = fun a b c d
 uncurry5 fun (a,b,c,d,e      ) = fun a b c d e
 uncurry6 fun (a,b,c,d,e,f    ) = fun a b c d e f
-uncurry7 fun (a,b,c,d,e,f,g  ) = fun a b c d e f g
-uncurry8 fun (a,b,c,d,e,f,g,h) = fun a b c d e f g h
 
 swap :: (a,b) -> (b,a)
 swap (a,b) = (b,a)
@@ -168,4 +162,3 @@ findBy :: (a -> Maybe b) -> [a] -> Maybe b
 findBy _               []   = Nothing
 findBy f ((f -> Just x):_ ) = Just x
 findBy f (            _:xs) = findBy f xs
-
diff --git a/src/Text/Pandoc/Readers/Odt/Generic/XMLConverter.hs b/src/Text/Pandoc/Readers/Odt/Generic/XMLConverter.hs
index 8c03d1a09..1c3e08a7f 100644
--- a/src/Text/Pandoc/Readers/Odt/Generic/XMLConverter.hs
+++ b/src/Text/Pandoc/Readers/Odt/Generic/XMLConverter.hs
@@ -41,50 +41,17 @@ module Text.Pandoc.Readers.Odt.Generic.XMLConverter
 , XMLConverterState
 , XMLConverter
 , FallibleXMLConverter
-, swapPosition
-, runConverter
-, runConverter''
 , runConverter'
-, runConverterF'
-, runConverterF
-, getCurrentElement
 , getExtraState
 , setExtraState
 , modifyExtraState
-, convertingExtraState
 , producingExtraState
-, lookupNSiri
-, lookupNSprefix
-, readNSattributes
-, elemName
-, elemNameIs
-, strContent
-, elContent
-, currentElem
-, currentElemIs
-, expectElement
-, elChildren
-, findChildren
-, filterChildren
-, filterChildrenName
 , findChild'
-, findChild
-, filterChild'
-, filterChild
-, filterChildName'
-, filterChildName
-, isSet
 , isSet'
 , isSetWithDefault
-, hasAttrValueOf'
-, failIfNotAttrValueOf
-, isThatTheAttrValue
-, searchAttrIn
-, searchAttrWith
 , searchAttr
 , lookupAttr
 , lookupAttr'
-, lookupAttrWithDefault
 , lookupDefaultingAttr
 , findAttr'
 , findAttr
@@ -93,25 +60,9 @@ module Text.Pandoc.Readers.Odt.Generic.XMLConverter
 , readAttr'
 , readAttrWithDefault
 , getAttr
--- , (>/<)
--- , (?>/<)
 , executeIn
-, collectEvery
 , withEveryL
-, withEvery
 , tryAll
-, tryAll'
-, IdXMLConverter
-, MaybeEConverter
-, ElementMatchConverter
-, MaybeCConverter
-, ContentMatchConverter
-, makeMatcherE
-, makeMatcherC
-, prepareMatchersE
-, prepareMatchersC
-, matchChildren
-, matchContent''
 , matchContent'
 , matchContent
 ) where
@@ -121,7 +72,6 @@ import           Control.Monad               ( MonadPlus )
 import           Control.Arrow
 
 import qualified Data.Map             as M
-import qualified Data.Foldable        as F
 import           Data.Default
 import           Data.Maybe
 
@@ -210,17 +160,6 @@ currentElement state = head (parentElements state)
 
 -- | Replace the current position by another, modifying the extra state
 -- in the process
-swapPosition        :: (extraState -> extraState')
-                    -> [XML.Element]
-                    -> XMLConverterState nsID extraState
-                    -> XMLConverterState nsID extraState'
-swapPosition f stack state
-                     = state { parentElements = stack
-                             , moreState      = f (moreState state)
-                             }
-
--- | Replace the current position by another, modifying the extra state
--- in the process
 swapStack'          :: XMLConverterState nsID extraState
                     -> [XML.Element]
                     -> ( XMLConverterState nsID extraState , [XML.Element] )
@@ -264,14 +203,6 @@ runConverter     :: XMLConverter nsID extraState input output
                  -> output
 runConverter converter state input = snd $ runArrowState converter (state,input)
 
---
-runConverter''    :: (NameSpaceID nsID)
-                 => XMLConverter nsID extraState (Fallible ()) output
-                 -> extraState
-                 -> XML.Element
-                 -> output
-runConverter'' converter extraState element = runConverter (readNSattributes >>> converter) (createStartState element extraState) ()
-
 runConverter' :: (NameSpaceID nsID)
               => FallibleXMLConverter nsID extraState () success
               -> extraState
@@ -280,20 +211,6 @@ runConverter' :: (NameSpaceID nsID)
 runConverter' converter extraState element = runConverter (readNSattributes >>? converter) (createStartState element extraState) ()
 
 --
-runConverterF' :: FallibleXMLConverter nsID extraState x y
-              -> XMLConverterState nsID extraState
-              -> Fallible x -> Fallible y
-runConverterF' a s e = runConverter (returnV e >>? a) s e
-
---
-runConverterF :: (NameSpaceID nsID)
-              => FallibleXMLConverter nsID extraState XML.Element x
-              -> extraState
-              -> Fallible XML.Element -> Fallible x
-runConverterF a s = either failWith
-                           (\e -> runConverter a (createStartState e s) e)
-
---
 getCurrentElement :: XMLConverter nsID extraState x XML.Element
 getCurrentElement  = extractFromState currentElement
 
@@ -430,57 +347,15 @@ elemNameIs nsID name     = keepingTheValue (lookupNSiri nsID) >>% hasThatName
 --------------------------------------------------------------------------------
 
 --
-strContent               :: XMLConverter nsID extraState x String
-strContent               =     getCurrentElement
-                           >>^ XML.strContent
-
---
 elContent               :: XMLConverter nsID extraState x [XML.Content]
 elContent               =     getCurrentElement
                            >>^ XML.elContent
 
 --------------------------------------------------------------------------------
--- Current element
---------------------------------------------------------------------------------
-
---
-currentElem              :: XMLConverter nsID extraState x (XML.QName)
-currentElem              =     getCurrentElement
-                           >>^ XML.elName
-
-currentElemIs            :: (NameSpaceID nsID)
-                         => nsID -> ElementName
-                         -> XMLConverter nsID extraState x Bool
-currentElemIs nsID name  =     getCurrentElement
-                           >>> elemNameIs nsID name
-
-
-
-{-
-currentElemIs'' nsID name = ( (getCurrentElement >>^ XML.elName >>>
-                                (XML.qName >>^ (&&).(== name) )
-                                  ^&&&^
-                                (XML.qIRI  >>^ (==) )
-                              ) >>% (.)
-                            ) &&& lookupNSiri nsID >>% ($)
--}
-
---
-expectElement            :: (NameSpaceID nsID)
-                         => nsID -> ElementName
-                         -> FallibleXMLConverter nsID extraState x ()
-expectElement nsID name  =     currentElemIs nsID name
-                           >>^ boolToChoice
-
---------------------------------------------------------------------------------
 -- Chilren
 --------------------------------------------------------------------------------
 
 --
-elChildren               :: XMLConverter nsID extraState x [XML.Element]
-elChildren               =     getCurrentElement
-                           >>^ XML.elChildren
-
 --
 findChildren             :: (NameSpaceID nsID)
                          => nsID -> ElementName
@@ -490,18 +365,6 @@ findChildren nsID name   =         elemName nsID name
                            >>% XML.findChildren
 
 --
-filterChildren           :: (XML.Element -> Bool)
-                         -> XMLConverter nsID extraState x [XML.Element]
-filterChildren p         =     getCurrentElement
-                           >>^ XML.filterChildren p
-
---
-filterChildrenName       :: (XML.QName   -> Bool)
-                         -> XMLConverter nsID extraState x [XML.Element]
-filterChildrenName p     =     getCurrentElement
-                           >>^ XML.filterChildrenName p
-
---
 findChild'              :: (NameSpaceID nsID)
                         => nsID
                         -> ElementName
@@ -517,45 +380,12 @@ findChild              :: (NameSpaceID nsID)
 findChild nsID name    =     findChild' nsID name
                          >>> maybeToChoice
 
---
-filterChild'            :: (XML.Element -> Bool)
-                        -> XMLConverter nsID extraState x (Maybe XML.Element)
-filterChild' p          =     getCurrentElement
-                          >>^ XML.filterChild p
-
---
-filterChild            :: (XML.Element -> Bool)
-                       -> FallibleXMLConverter nsID extraState x XML.Element
-filterChild p          =     filterChild' p
-                         >>> maybeToChoice
-
---
-filterChildName'        :: (XML.QName   -> Bool)
-                        -> XMLConverter nsID extraState x (Maybe XML.Element)
-filterChildName' p      =     getCurrentElement
-                          >>^ XML.filterChildName p
-
---
-filterChildName        :: (XML.QName   -> Bool)
-                       -> FallibleXMLConverter nsID extraState x XML.Element
-filterChildName p      =     filterChildName' p
-                         >>> maybeToChoice
-
 
 --------------------------------------------------------------------------------
 -- Attributes
 --------------------------------------------------------------------------------
 
 --
-isSet                    :: (NameSpaceID nsID)
-                         => nsID -> AttributeName
-                         -> (Either Failure Bool)
-                         -> FallibleXMLConverter nsID extraState x Bool
-isSet nsID attrName deflt
-                         =      findAttr' nsID attrName
-                            >>^ maybe deflt stringToBool
-
---
 isSet'                   :: (NameSpaceID nsID)
                          => nsID -> AttributeName
                          -> XMLConverter nsID extraState x (Maybe Bool)
@@ -570,34 +400,6 @@ isSetWithDefault nsID attrName def'
                          =     isSet' nsID attrName
                            >>^ fromMaybe def'
 
---
-hasAttrValueOf'          :: (NameSpaceID nsID)
-                         => nsID -> AttributeName
-                         -> AttributeValue
-                         -> XMLConverter nsID extraState x Bool
-hasAttrValueOf' nsID attrName attrValue
-                         =     findAttr nsID attrName
-                           >>> ( const False ^|||^ (==attrValue))
-
---
-failIfNotAttrValueOf     :: (NameSpaceID nsID)
-                         => nsID -> AttributeName
-                         -> AttributeValue
-                         -> FallibleXMLConverter nsID extraState x ()
-failIfNotAttrValueOf nsID attrName attrValue
-                         =     hasAttrValueOf' nsID attrName attrValue
-                           >>^ boolToChoice
-
--- | Is the value that is currently transported in the arrow the value of
--- the specified attribute?
-isThatTheAttrValue       :: (NameSpaceID nsID)
-                         => nsID -> AttributeName
-                         -> FallibleXMLConverter nsID extraState AttributeValue Bool
-isThatTheAttrValue nsID attrName
-                         =     keepingTheValue
-                                 (findAttr nsID attrName)
-                           >>% right.(==)
-
 -- | Lookup value in a dictionary, fail if no attribute found or value
 -- not in dictionary
 searchAttrIn             :: (NameSpaceID nsID)
@@ -608,18 +410,6 @@ searchAttrIn nsID attrName dict
                          =       findAttr nsID attrName
                            >>?^? maybeToChoice.(`lookup` dict )
 
-
--- | Lookup value in a dictionary. Fail if no attribute found. If value not in
--- dictionary, return default value
-searchAttrWith           :: (NameSpaceID nsID)
-                         => nsID -> AttributeName
-                         -> a
-                         -> [(AttributeValue,a)]
-                         -> FallibleXMLConverter nsID extraState x a
-searchAttrWith nsID attrName defV dict
-                         =      findAttr nsID attrName
-                           >>?^ (fromMaybe defV).(`lookup` dict )
-
 -- | Lookup value in a dictionary. If attribute or value not found,
 -- return default value
 searchAttr               :: (NameSpaceID nsID)
@@ -789,16 +579,6 @@ prepareIteration nsID name =     keepingTheValue
                                    (findChildren nsID name)
                              >>% distributeValue
 
--- | Applies a converter to every child element of a specific type.
--- Collects results in a 'Monoid'.
--- Fails completely if any conversion fails.
-collectEvery           :: (NameSpaceID nsID, Monoid m)
-                       => nsID -> ElementName
-                       -> FallibleXMLConverter nsID extraState a m
-                       -> FallibleXMLConverter nsID extraState a m
-collectEvery nsID name a   =     prepareIteration nsID name
-                             >>> foldS' (switchingTheStack a)
-
 --
 withEveryL             :: (NameSpaceID nsID)
                        => nsID -> ElementName
@@ -826,16 +606,6 @@ tryAll nsID name a         =     prepareIteration nsID name
                              >>> iterateS (switchingTheStack a)
                              >>^ collectRights
 
--- | Applies a converter to every child element of a specific type.
--- Collects all successful results.
-tryAll'                 :: (NameSpaceID nsID, F.Foldable c, MonadPlus c)
-                        => nsID -> ElementName
-                        -> FallibleXMLConverter nsID extraState b   a
-                        ->         XMLConverter nsID extraState b (c a)
-tryAll' nsID name a         =     prepareIteration nsID name
-                              >>> iterateS (switchingTheStack a)
-                              >>^ collectRightsF
-
 --------------------------------------------------------------------------------
 -- Matching children
 --------------------------------------------------------------------------------
@@ -843,15 +613,6 @@ tryAll' nsID name a         =     prepareIteration nsID name
 type IdXMLConverter nsID moreState x
    = XMLConverter   nsID moreState x x
 
-type MaybeEConverter nsID moreState x
-   = Maybe (IdXMLConverter nsID moreState (x, XML.Element))
-
--- Chainable converter that helps deciding which converter to actually use.
-type ElementMatchConverter nsID extraState x
-   = IdXMLConverter  nsID
-                     extraState
-                     (MaybeEConverter nsID extraState x, XML.Element)
-
 type MaybeCConverter nsID moreState x
    = Maybe (IdXMLConverter nsID moreState (x, XML.Content))
 
@@ -862,26 +623,6 @@ type ContentMatchConverter nsID extraState x
                      (MaybeCConverter nsID extraState x, XML.Content)
 
 -- Helper function: The @c@ is actually a converter that is to be selected by
--- matching XML elements to the first two parameters.
--- The fold used to match elements however is very simple, so to use it,
--- this function wraps the converter in another converter that unifies
--- the accumulator. Think of a lot of converters with the resulting type
--- chained together. The accumulator not only transports the element
--- unchanged to the next matcher, it also does the actual selecting by
--- combining the intermediate results with '(<|>)'.
-makeMatcherE           :: (NameSpaceID nsID)
-                       => nsID -> ElementName
-                       -> FallibleXMLConverter  nsID extraState a a
-                       -> ElementMatchConverter nsID extraState a
-makeMatcherE nsID name c = (     second (
-                                              elemNameIs nsID name
-                                          >>^ bool Nothing (Just tryC)
-                                        )
-                             >>% (<|>)
-                           ) &&&^ snd
-  where tryC = (fst ^&&& executeThere c >>% recover) &&&^ snd
-
--- Helper function: The @c@ is actually a converter that is to be selected by
 -- matching XML content to the first two parameters.
 -- The fold used to match elements however is very simple, so to use it,
 -- this function wraps the converter in another converter that unifies
@@ -914,13 +655,6 @@ makeMatcherC nsID name c = (    second (    contentToElem
                                      _           -> failEmpty
 
 -- Creates and chains a bunch of matchers
-prepareMatchersE       :: (NameSpaceID nsID)
-                       => [(nsID, ElementName, FallibleXMLConverter nsID extraState x x)]
-                       -> ElementMatchConverter nsID extraState x
---prepareMatchersE       = foldSs . (map $ uncurry3  makeMatcherE)
-prepareMatchersE       = reverseComposition . (map $ uncurry3  makeMatcherE)
-
--- Creates and chains a bunch of matchers
 prepareMatchersC      :: (NameSpaceID nsID)
                        => [(nsID, ElementName, FallibleXMLConverter nsID extraState x x)]
                        -> ContentMatchConverter nsID extraState x
@@ -928,52 +662,6 @@ prepareMatchersC      :: (NameSpaceID nsID)
 prepareMatchersC      = reverseComposition . (map $ uncurry3  makeMatcherC)
 
 -- | Takes a list of element-data - converter groups and
--- * Finds all children of the current element
--- * Matches each group to each child in order (at most one group per child)
--- * Filters non-matched children
--- * Chains all found converters in child-order
--- * Applies the chain to the input element
-matchChildren          :: (NameSpaceID nsID)
-                       => [(nsID, ElementName, FallibleXMLConverter nsID extraState a a)]
-                       -> XMLConverter nsID extraState a a
-matchChildren lookups  = let matcher = prepareMatchersE lookups
-                         in  keepingTheValue (
-                                   elChildren
-                               >>> map (Nothing,)
-                               ^>> iterateSL matcher
-                               >>^ catMaybes.map (\(m,e) -> fmap (swallowElem e) m)
-                              -- >>> foldSs
-                               >>> reverseComposition
-                             )
-                         >>> swap
-                         ^>> app
-  where
-        -- let the converter swallow the element and drop the element
-        -- in the return value
-        swallowElem element converter = (,element) ^>> converter >>^ fst
-
---
-matchContent''         :: (NameSpaceID nsID)
-                       => [(nsID, ElementName, FallibleXMLConverter nsID extraState a a)]
-                       -> XMLConverter nsID extraState a a
-matchContent'' lookups  = let matcher = prepareMatchersC lookups
-                          in  keepingTheValue (
-                                   elContent
-                               >>> map (Nothing,)
-                               ^>> iterateSL matcher
-                               >>^ catMaybes.map (\(m,c) -> fmap (swallowContent c) m)
-                              -- >>> foldSs
-                               >>> reverseComposition
-                             )
-                         >>> swap
-                         ^>> app
-  where
-        -- let the converter swallow the content and drop the content
-        -- in the return value
-        swallowContent content converter = (,content) ^>> converter >>^ fst
-
-
--- | Takes a list of element-data - converter groups and
 -- * Finds all content of the current element
 -- * Matches each group to each piece of content in order
 --   (at most one group per piece of content)
@@ -1018,14 +706,6 @@ matchContent lookups fallback
 -- Internals
 --------------------------------------------------------------------------------
 
-stringToBool :: (Monoid failure) => String -> Either failure Bool
-stringToBool val  -- stringToBool' val >>> maybeToChoice
-                 | val `elem` trueValues  = succeedWith True
-                 | val `elem` falseValues = succeedWith False
-                 | otherwise              = failEmpty
-  where trueValues  = ["true" ,"on" ,"1"]
-        falseValues = ["false","off","0"]
-
 stringToBool' :: String -> Maybe Bool
 stringToBool' val | val `elem` trueValues  = Just True
                   | val `elem` falseValues = Just False