    -- ------------------------------------------------------------

    {- |
       Module     : Text.XML.HXT.Arrow.XmlState.TypeDefs
       Copyright  : Copyright (C) 2010 Uwe Schmidt
       License    : MIT

       Maintainer : Uwe Schmidt (uwe@fh-wedel.de)
       Stability  : stable
       Portability: portable

       the basic state arrows for XML processing

       A state is needed for global processing options,
       like encoding options, document base URI, trace levels
       and error message handling

       The state is separated into a user defined state
       and a system state. The system state contains variables
       for error message handling, for tracing, for the document base
       for accessing XML documents with relative references, e.g. DTDs,
       and a global key value store. This assoc list has strings as keys
       and lists of XmlTrees as values. It is used to store arbitrary
       XML and text values, e.g. user defined global options.

       The user defined part of the store is in the default case empty, defined as ().
       It can be extended with an arbitray data type

    -}

    -- ------------------------------------------------------------

    module Text.XML.HXT.Arrow.XmlState.TypeDefs
        ( module Text.XML.HXT.Arrow.XmlState.TypeDefs
        , Selector(..)
        , chgS
        , idS
        , (.&&&.)
        )
    where

    import           Control.Arrow
    import           Control.Arrow.ArrowList
    import           Control.Arrow.IOStateListArrow
    import           Control.DeepSeq

    import           Data.ByteString.Lazy           (ByteString)
    import           Data.Char                      (isDigit)
    import           Data.Function.Selector         (Selector (..), chgS, idS,
                                                     (.&&&.))
    import qualified Data.Map                       as M

    import           Text.XML.HXT.DOM.Interface

    -- ------------------------------------------------------------
    {- datatypes -}

    -- |
    -- state datatype consists of a system state and a user state
    -- the user state is not fixed

    data XIOState us        = XIOState { XIOState us -> XIOSysState
    xioSysState  :: ! XIOSysState
                                       , XIOState us -> us
    xioUserState :: ! us
                                       }

    instance (NFData us) => NFData (XIOState us) where
        rnf :: XIOState us -> ()
    rnf (XIOState sys :: XIOSysState
    sys usr :: us
    usr)      = XIOSysState -> ()
    forall a. NFData a => a -> ()
    rnf XIOSysState
    sys () -> () -> ()
    forall a b. a -> b -> b
    `seq` us -> ()
    forall a. NFData a => a -> ()
    rnf us
    usr

    -- |
    -- The arrow type for stateful arrows

    type IOStateArrow s b c = IOSLA (XIOState s) b c

    -- |
    -- The arrow for stateful arrows with no user defined state

    type IOSArrow b c       = IOStateArrow () b c

    -- ------------------------------------------------------------

    -- user state functions

    -- | read the user defined part of the state

    getUserState    :: IOStateArrow s b s
    getUserState :: IOStateArrow s b s
    getUserState
        = (XIOState s -> b -> IO (XIOState s, [s])) -> IOStateArrow s b s
    forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
    IOSLA ((XIOState s -> b -> IO (XIOState s, [s])) -> IOStateArrow s b s)
    -> (XIOState s -> b -> IO (XIOState s, [s])) -> IOStateArrow s b s
    forall a b. (a -> b) -> a -> b
    $ \ s :: XIOState s
    s _ ->
          (XIOState s, [s]) -> IO (XIOState s, [s])
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XIOState s
    s, [XIOState s -> s
    forall us. XIOState us -> us
    xioUserState XIOState s
    s])

    -- | change the user defined part of the state

    changeUserState         :: (b -> s -> s) -> IOStateArrow s b b
    changeUserState :: (b -> s -> s) -> IOStateArrow s b b
    changeUserState cf :: b -> s -> s
    cf
        = (XIOState s -> b -> IO (XIOState s, [b])) -> IOStateArrow s b b
    forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
    IOSLA ((XIOState s -> b -> IO (XIOState s, [b])) -> IOStateArrow s b b)
    -> (XIOState s -> b -> IO (XIOState s, [b])) -> IOStateArrow s b b
    forall a b. (a -> b) -> a -> b
    $ \ s :: XIOState s
    s v :: b
    v ->
          let s' :: XIOState s
    s' = XIOState s
    s { xioUserState :: s
    xioUserState = b -> s -> s
    cf b
    v (XIOState s -> s
    forall us. XIOState us -> us
    xioUserState XIOState s
    s) }
          in (XIOState s, [b]) -> IO (XIOState s, [b])
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XIOState s
    s', [b
    v])

    -- | set the user defined part of the state

    setUserState            :: IOStateArrow s s s
    setUserState :: IOStateArrow s s s
    setUserState
        = (s -> s -> s) -> IOStateArrow s s s
    forall b s. (b -> s -> s) -> IOStateArrow s b b
    changeUserState s -> s -> s
    forall a b. a -> b -> a
    const

    -- | extend user state
    --
    -- Run an arrow with an extended user state component, The old component
    -- is stored together with a new one in a pair, the arrow is executed with this
    -- extended state, and the augmented state component is removed form the state
    -- when the arrow has finished its execution

    withExtendedUserState   :: s1 -> IOStateArrow (s1, s0) b c -> IOStateArrow s0 b c
    withExtendedUserState :: s1 -> IOStateArrow (s1, s0) b c -> IOStateArrow s0 b c
    withExtendedUserState initS1 :: s1
    initS1 f :: IOStateArrow (s1, s0) b c
    f
        = (XIOState s0 -> b -> IO (XIOState s0, [c])) -> IOStateArrow s0 b c
    forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
    IOSLA ((XIOState s0 -> b -> IO (XIOState s0, [c]))
     -> IOStateArrow s0 b c)
    -> (XIOState s0 -> b -> IO (XIOState s0, [c]))
    -> IOStateArrow s0 b c
    forall a b. (a -> b) -> a -> b
    $ \ s0 :: XIOState s0
    s0 x :: b
    x ->
          do
          ~(finalS :: XIOState (s1, s0)
    finalS, res :: [c]
    res) <- IOStateArrow (s1, s0) b c
    -> XIOState (s1, s0) -> b -> IO (XIOState (s1, s0), [c])
    forall s a b. IOSLA s a b -> s -> a -> IO (s, [b])
    runIOSLA IOStateArrow (s1, s0) b c
    f ( $WXIOState :: forall us. XIOSysState -> us -> XIOState us
    XIOState { xioSysState :: XIOSysState
    xioSysState  =          XIOState s0 -> XIOSysState
    forall us. XIOState us -> XIOSysState
    xioSysState  XIOState s0
    s0
                                                  , xioUserState :: (s1, s0)
    xioUserState = (s1
    initS1, XIOState s0 -> s0
    forall us. XIOState us -> us
    xioUserState XIOState s0
    s0)
                                                  }
                                       ) b
    x
          (XIOState s0, [c]) -> IO (XIOState s0, [c])
    forall (m :: * -> *) a. Monad m => a -> m a
    return ( $WXIOState :: forall us. XIOSysState -> us -> XIOState us
    XIOState { xioSysState :: XIOSysState
    xioSysState  =      XIOState (s1, s0) -> XIOSysState
    forall us. XIOState us -> XIOSysState
    xioSysState  XIOState (s1, s0)
    finalS
                            , xioUserState :: s0
    xioUserState = (s1, s0) -> s0
    forall a b. (a, b) -> b
    snd (XIOState (s1, s0) -> (s1, s0)
    forall us. XIOState us -> us
    xioUserState XIOState (s1, s0)
    finalS)
                            }
                 , [c]
    res
                 )

    -- | change the type of user state
    --
    -- This conversion is useful, when running a state arrow with another
    -- structure of the user state, e.g. with () when executing some IO arrows

    withOtherUserState      :: s1 -> IOStateArrow s1 b c -> IOStateArrow s0 b c
    withOtherUserState :: s1 -> IOStateArrow s1 b c -> IOStateArrow s0 b c
    withOtherUserState s1 :: s1
    s1 f :: IOStateArrow s1 b c
    f
        = (XIOState s0 -> b -> IO (XIOState s0, [c])) -> IOStateArrow s0 b c
    forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
    IOSLA ((XIOState s0 -> b -> IO (XIOState s0, [c]))
     -> IOStateArrow s0 b c)
    -> (XIOState s0 -> b -> IO (XIOState s0, [c]))
    -> IOStateArrow s0 b c
    forall a b. (a -> b) -> a -> b
    $ \ s :: XIOState s0
    s x :: b
    x ->
          do
          (s' :: XIOState s1
    s', res :: [c]
    res) <- IOStateArrow s1 b c -> XIOState s1 -> b -> IO (XIOState s1, [c])
    forall s a b. IOSLA s a b -> s -> a -> IO (s, [b])
    runIOSLA IOStateArrow s1 b c
    f ( $WXIOState :: forall us. XIOSysState -> us -> XIOState us
    XIOState { xioSysState :: XIOSysState
    xioSysState  = XIOState s0 -> XIOSysState
    forall us. XIOState us -> XIOSysState
    xioSysState XIOState s0
    s
                                             , xioUserState :: s1
    xioUserState = s1
    s1
                                             }
                                  ) b
    x
          (XIOState s0, [c]) -> IO (XIOState s0, [c])
    forall (m :: * -> *) a. Monad m => a -> m a
    return ( $WXIOState :: forall us. XIOSysState -> us -> XIOState us
    XIOState { xioSysState :: XIOSysState
    xioSysState  = XIOState s1 -> XIOSysState
    forall us. XIOState us -> XIOSysState
    xioSysState  XIOState s1
    s'
                            , xioUserState :: s0
    xioUserState = XIOState s0 -> s0
    forall us. XIOState us -> us
    xioUserState XIOState s0
    s
                            }
                 , [c]
    res
                 )

    withoutUserState      :: IOSArrow b c -> IOStateArrow s0 b c
    withoutUserState :: IOSArrow b c -> IOStateArrow s0 b c
    withoutUserState      = () -> IOSArrow b c -> IOStateArrow s0 b c
    forall s1 b c s0. s1 -> IOStateArrow s1 b c -> IOStateArrow s0 b c
    withOtherUserState ()

    -- ------------------------------------------------------------

    -- system state structure and acces functions

    -- |
    -- predefined system state data type with all components for the
    -- system functions, like trace, error handling, ...

    data XIOSysState        = XIOSys  { XIOSysState -> XIOSysWriter
    xioSysWriter :: ! XIOSysWriter
                                      , XIOSysState -> XIOSysEnv
    xioSysEnv    :: ! XIOSysEnv
                                      }

    instance NFData XIOSysState where
        rnf :: XIOSysState -> ()
    rnf x :: XIOSysState
    x = XIOSysState -> () -> ()
    forall a b. a -> b -> b
    seq XIOSysState
    x ()    -- all fields of interest are strict

    data XIOSysWriter       = XIOwrt  { XIOSysWriter -> Int
    xioErrorStatus     :: ! Int
                                      , XIOSysWriter -> XmlTrees
    xioErrorMsgList    :: ! XmlTrees
                                      , XIOSysWriter -> IOSArrow XmlTree XmlTree
    xioExpatErrors     ::   IOSArrow XmlTree XmlTree
                                      , XIOSysWriter -> Int
    xioRelaxNoOfErrors :: ! Int
                                      , XIOSysWriter -> Int
    xioRelaxDefineId   :: ! Int
                                      , XIOSysWriter -> AssocList String XmlTrees
    xioRelaxAttrList   ::   AssocList String XmlTrees
                                      }

    data XIOSysEnv          = XIOEnv  { XIOSysEnv -> Int
    xioTraceLevel      :: ! Int
                                      , XIOSysEnv -> Int -> String -> IO ()
    xioTraceCmd        ::   Int -> String -> IO ()
                                      , XIOSysEnv -> String -> IO ()
    xioErrorMsgHandler ::   String -> IO ()
                                      , XIOSysEnv -> Bool
    xioErrorMsgCollect :: ! Bool
                                      , XIOSysEnv -> String
    xioBaseURI         :: ! String
                                      , XIOSysEnv -> String
    xioDefaultBaseURI  :: ! String
                                      , XIOSysEnv -> Attributes
    xioAttrList        :: ! Attributes
                                      , XIOSysEnv -> XIOInputConfig
    xioInputConfig     :: ! XIOInputConfig
                                      , XIOSysEnv -> XIOParseConfig
    xioParseConfig     :: ! XIOParseConfig
                                      , XIOSysEnv -> XIOOutputConfig
    xioOutputConfig    :: ! XIOOutputConfig
                                      , XIOSysEnv -> XIORelaxConfig
    xioRelaxConfig     :: ! XIORelaxConfig
                                      , XIOSysEnv -> XIOXmlSchemaConfig
    xioXmlSchemaConfig :: ! XIOXmlSchemaConfig
                                      , XIOSysEnv -> XIOCacheConfig
    xioCacheConfig     :: ! XIOCacheConfig
                                      }

    data XIOInputConfig     = XIOIcgf { XIOInputConfig -> Bool
    xioStrictInput    :: ! Bool
                                      , XIOInputConfig -> Bool
    xioEncodingErrors :: ! Bool
                                      , XIOInputConfig -> String
    xioInputEncoding  ::   String
                                      , XIOInputConfig -> IOSArrow XmlTree XmlTree
    xioHttpHandler    ::   IOSArrow XmlTree XmlTree
                                      , XIOInputConfig -> Attributes
    xioInputOptions   :: ! Attributes
                                      , XIOInputConfig -> Bool
    xioRedirect       :: ! Bool
                                      , XIOInputConfig -> String
    xioProxy          ::   String
                                      }

    data XIOParseConfig     = XIOPcfg { XIOParseConfig -> MimeTypeTable
    xioMimeTypes             ::   MimeTypeTable
                                      , XIOParseConfig -> MimeTypeHandlers
    xioMimeTypeHandlers      ::   MimeTypeHandlers
                                      , XIOParseConfig -> String
    xioMimeTypeFile          ::   String
                                      , XIOParseConfig -> [String]
    xioAcceptedMimeTypes     ::   [String]
                                      , XIOParseConfig -> String
    xioFileMimeType          ::   String
                                      , XIOParseConfig -> Bool
    xioWarnings              :: ! Bool
                                      , XIOParseConfig -> Bool
    xioRemoveWS              :: ! Bool
                                      , XIOParseConfig -> Bool
    xioParseByMimeType       :: ! Bool
                                      , XIOParseConfig -> Bool
    xioParseHTML             :: ! Bool
                                      , XIOParseConfig -> Bool
    xioLowerCaseNames        :: ! Bool
                                      , XIOParseConfig -> Bool
    xioPreserveComment       :: ! Bool
                                      , XIOParseConfig -> Bool
    xioValidate              :: ! Bool
                                      , XIOParseConfig -> Bool
    xioSubstDTDEntities      :: ! Bool
                                      , XIOParseConfig -> Bool
    xioSubstHTMLEntities     :: ! Bool
                                      , XIOParseConfig -> Bool
    xioCheckNamespaces       :: ! Bool
                                      , XIOParseConfig -> Bool
    xioCanonicalize          :: ! Bool
                                      , XIOParseConfig -> Bool
    xioIgnoreNoneXmlContents :: ! Bool
                                      , XIOParseConfig -> Bool
    xioTagSoup               :: ! Bool
                                      , XIOParseConfig -> IOSArrow XmlTree XmlTree
    xioTagSoupParser         ::   IOSArrow XmlTree XmlTree
                                      , XIOParseConfig -> Bool
    xioExpat                 :: ! Bool
                                      , XIOParseConfig -> IOSArrow XmlTree XmlTree
    xioExpatParser           ::   IOSArrow XmlTree XmlTree
                                      }

    data XIOOutputConfig    = XIOOcfg { XIOOutputConfig -> Bool
    xioIndent         :: ! Bool
                                      , XIOOutputConfig -> String
    xioOutputEncoding :: ! String
                                      , XIOOutputConfig -> XIOXoutConfig
    xioOutputFmt      :: ! XIOXoutConfig
                                      , XIOOutputConfig -> Bool
    xioXmlPi          :: ! Bool
                                      , XIOOutputConfig -> [String]
    xioNoEmptyElemFor :: ! [String]
                                      , XIOOutputConfig -> Bool
    xioAddDefaultDTD  :: ! Bool
                                      , XIOOutputConfig -> Bool
    xioTextMode       :: ! Bool
                                      , XIOOutputConfig -> Bool
    xioShowTree       :: ! Bool
                                      , XIOOutputConfig -> Bool
    xioShowHaskell    :: ! Bool
                                      }
    data XIOXoutConfig      = XMLoutput | XHTMLoutput | HTMLoutput | PLAINoutput
                              deriving (XIOXoutConfig -> XIOXoutConfig -> Bool
    (XIOXoutConfig -> XIOXoutConfig -> Bool)
    -> (XIOXoutConfig -> XIOXoutConfig -> Bool) -> Eq XIOXoutConfig
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: XIOXoutConfig -> XIOXoutConfig -> Bool
    $c/= :: XIOXoutConfig -> XIOXoutConfig -> Bool
    == :: XIOXoutConfig -> XIOXoutConfig -> Bool
    $c== :: XIOXoutConfig -> XIOXoutConfig -> Bool
    Eq)

    data XIORelaxConfig     = XIORxc  { XIORelaxConfig -> Bool
    xioRelaxValidate        :: ! Bool
                                      , XIORelaxConfig -> String
    xioRelaxSchema          ::   String
                                      , XIORelaxConfig -> Bool
    xioRelaxCheckRestr      :: ! Bool
                                      , XIORelaxConfig -> Bool
    xioRelaxValidateExtRef  :: ! Bool
                                      , XIORelaxConfig -> Bool
    xioRelaxValidateInclude :: ! Bool
                                      , XIORelaxConfig -> Bool
    xioRelaxCollectErrors   :: ! Bool
                                      , XIORelaxConfig -> IOSArrow XmlTree XmlTree
    xioRelaxValidator       ::   IOSArrow XmlTree XmlTree
                                      }

    data XIOXmlSchemaConfig = XIOScc  { XIOXmlSchemaConfig -> Bool
    xioXmlSchemaValidate  :: ! Bool
                                      , XIOXmlSchemaConfig -> String
    xioXmlSchemaSchema    ::   String
                                      , XIOXmlSchemaConfig -> IOSArrow XmlTree XmlTree
    xioXmlSchemaValidator ::   IOSArrow XmlTree XmlTree
                                      }

    data XIOCacheConfig     = XIOCch  { XIOCacheConfig -> CompressionFct
    xioBinaryCompression   ::   CompressionFct
                                      , XIOCacheConfig -> CompressionFct
    xioBinaryDeCompression ::   DeCompressionFct
                                      , XIOCacheConfig -> Bool
    xioWithCache           :: ! Bool
                                      , XIOCacheConfig -> String
    xioCacheDir            :: ! String
                                      , XIOCacheConfig -> Int
    xioDocumentAge         :: ! Int
                                      , XIOCacheConfig -> Bool
    xioCache404Err         :: ! Bool
                                      , XIOCacheConfig -> String -> IOSArrow XmlTree XmlTree
    xioCacheRead           ::   String -> IOSArrow XmlTree XmlTree
                                      , XIOCacheConfig -> Bool
    xioStrictDeserialize   :: ! Bool
                                      }

    type MimeTypeHandlers   = M.Map String (IOSArrow XmlTree XmlTree)

    type CompressionFct     = ByteString -> ByteString
    type DeCompressionFct   = ByteString -> ByteString

    type SysConfig          = XIOSysState -> XIOSysState
    type SysConfigList      = [SysConfig]

    -- ----------------------------------------

    theSysState                     :: Selector (XIOState us) XIOSysState
    theSysState :: Selector (XIOState us) XIOSysState
    theSysState                     = S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOState us -> XIOSysState
    getS = XIOState us -> XIOSysState
    forall us. XIOState us -> XIOSysState
    xioSysState
                                        , setS :: XIOSysState -> XIOState us -> XIOState us
    setS = \ x :: XIOSysState
    x s :: XIOState us
    s -> XIOState us
    s { xioSysState :: XIOSysState
    xioSysState = XIOSysState
    x}
                                        }

    theUserState                    :: Selector (XIOState us) us
    theUserState :: Selector (XIOState us) us
    theUserState                    = S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOState us -> us
    getS = XIOState us -> us
    forall us. XIOState us -> us
    xioUserState
                                        , setS :: us -> XIOState us -> XIOState us
    setS = \ x :: us
    x s :: XIOState us
    s -> XIOState us
    s { xioUserState :: us
    xioUserState = us
    x}
                                        }

    -- ----------------------------------------

    theSysWriter                    :: Selector XIOSysState XIOSysWriter
    theSysWriter :: Selector XIOSysState XIOSysWriter
    theSysWriter                    = S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysState -> XIOSysWriter
    getS = XIOSysState -> XIOSysWriter
    xioSysWriter
                                        , setS :: XIOSysWriter -> XIOSysState -> XIOSysState
    setS = \ x :: XIOSysWriter
    x s :: XIOSysState
    s -> XIOSysState
    s { xioSysWriter :: XIOSysWriter
    xioSysWriter = XIOSysWriter
    x}
                                        }

    theErrorStatus                  :: Selector XIOSysState Int
    theErrorStatus :: Selector XIOSysState Int
    theErrorStatus                  = Selector XIOSysState XIOSysWriter
    theSysWriter
                                      Selector XIOSysState XIOSysWriter
    -> Selector XIOSysWriter Int -> Selector XIOSysState Int
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysWriter -> Int
    getS = XIOSysWriter -> Int
    xioErrorStatus
                                        , setS :: Int -> XIOSysWriter -> XIOSysWriter
    setS = \ x :: Int
    x s :: XIOSysWriter
    s -> XIOSysWriter
    s { xioErrorStatus :: Int
    xioErrorStatus = Int
    x }
                                        }

    theErrorMsgList                 :: Selector XIOSysState XmlTrees
    theErrorMsgList :: Selector XIOSysState XmlTrees
    theErrorMsgList                 = Selector XIOSysState XIOSysWriter
    theSysWriter
                                      Selector XIOSysState XIOSysWriter
    -> Selector XIOSysWriter XmlTrees -> Selector XIOSysState XmlTrees
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysWriter -> XmlTrees
    getS = XIOSysWriter -> XmlTrees
    xioErrorMsgList
                                        , setS :: XmlTrees -> XIOSysWriter -> XIOSysWriter
    setS = \ x :: XmlTrees
    x s :: XIOSysWriter
    s -> XIOSysWriter
    s { xioErrorMsgList :: XmlTrees
    xioErrorMsgList = XmlTrees
    x }
                                        }

    theRelaxNoOfErrors              :: Selector XIOSysState Int
    theRelaxNoOfErrors :: Selector XIOSysState Int
    theRelaxNoOfErrors              = Selector XIOSysState XIOSysWriter
    theSysWriter
                                      Selector XIOSysState XIOSysWriter
    -> Selector XIOSysWriter Int -> Selector XIOSysState Int
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysWriter -> Int
    getS = XIOSysWriter -> Int
    xioRelaxNoOfErrors
                                        , setS :: Int -> XIOSysWriter -> XIOSysWriter
    setS = \ x :: Int
    x s :: XIOSysWriter
    s -> XIOSysWriter
    s { xioRelaxNoOfErrors :: Int
    xioRelaxNoOfErrors = Int
    x}
                                        }

    theRelaxDefineId                :: Selector XIOSysState Int
    theRelaxDefineId :: Selector XIOSysState Int
    theRelaxDefineId                = Selector XIOSysState XIOSysWriter
    theSysWriter
                                      Selector XIOSysState XIOSysWriter
    -> Selector XIOSysWriter Int -> Selector XIOSysState Int
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysWriter -> Int
    getS = XIOSysWriter -> Int
    xioRelaxDefineId
                                        , setS :: Int -> XIOSysWriter -> XIOSysWriter
    setS = \ x :: Int
    x s :: XIOSysWriter
    s -> XIOSysWriter
    s { xioRelaxDefineId :: Int
    xioRelaxDefineId = Int
    x}
                                        }

    theRelaxAttrList                :: Selector XIOSysState (AssocList String XmlTrees)
    theRelaxAttrList :: Selector XIOSysState (AssocList String XmlTrees)
    theRelaxAttrList                = Selector XIOSysState XIOSysWriter
    theSysWriter
                                      Selector XIOSysState XIOSysWriter
    -> Selector XIOSysWriter (AssocList String XmlTrees)
    -> Selector XIOSysState (AssocList String XmlTrees)
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysWriter -> AssocList String XmlTrees
    getS = XIOSysWriter -> AssocList String XmlTrees
    xioRelaxAttrList
                                        , setS :: AssocList String XmlTrees -> XIOSysWriter -> XIOSysWriter
    setS = \ x :: AssocList String XmlTrees
    x s :: XIOSysWriter
    s -> XIOSysWriter
    s { xioRelaxAttrList :: AssocList String XmlTrees
    xioRelaxAttrList = AssocList String XmlTrees
    x}
                                        }

    -- ----------------------------------------

    theSysEnv                       :: Selector XIOSysState XIOSysEnv
    theSysEnv :: Selector XIOSysState XIOSysEnv
    theSysEnv                       = S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysState -> XIOSysEnv
    getS = XIOSysState -> XIOSysEnv
    xioSysEnv
                                        , setS :: XIOSysEnv -> XIOSysState -> XIOSysState
    setS = \ x :: XIOSysEnv
    x s :: XIOSysState
    s -> XIOSysState
    s { xioSysEnv :: XIOSysEnv
    xioSysEnv = XIOSysEnv
    x}
                                        }

    theInputConfig                  :: Selector XIOSysState XIOInputConfig
    theInputConfig :: Selector XIOSysState XIOInputConfig
    theInputConfig                  = Selector XIOSysState XIOSysEnv
    theSysEnv
                                      Selector XIOSysState XIOSysEnv
    -> Selector XIOSysEnv XIOInputConfig
    -> Selector XIOSysState XIOInputConfig
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysEnv -> XIOInputConfig
    getS = XIOSysEnv -> XIOInputConfig
    xioInputConfig
                                        , setS :: XIOInputConfig -> XIOSysEnv -> XIOSysEnv
    setS = \ x :: XIOInputConfig
    x s :: XIOSysEnv
    s -> XIOSysEnv
    s { xioInputConfig :: XIOInputConfig
    xioInputConfig = XIOInputConfig
    x}
                                        }

    theStrictInput                  :: Selector XIOSysState Bool
    theStrictInput :: Selector XIOSysState Bool
    theStrictInput                  = Selector XIOSysState XIOInputConfig
    theInputConfig
                                      Selector XIOSysState XIOInputConfig
    -> Selector XIOInputConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOInputConfig -> Bool
    getS = XIOInputConfig -> Bool
    xioStrictInput
                                        , setS :: Bool -> XIOInputConfig -> XIOInputConfig
    setS = \ x :: Bool
    x s :: XIOInputConfig
    s -> XIOInputConfig
    s { xioStrictInput :: Bool
    xioStrictInput = Bool
    x}
                                        }

    theEncodingErrors               :: Selector XIOSysState Bool
    theEncodingErrors :: Selector XIOSysState Bool
    theEncodingErrors               = Selector XIOSysState XIOInputConfig
    theInputConfig
                                      Selector XIOSysState XIOInputConfig
    -> Selector XIOInputConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOInputConfig -> Bool
    getS = XIOInputConfig -> Bool
    xioEncodingErrors
                                        , setS :: Bool -> XIOInputConfig -> XIOInputConfig
    setS = \ x :: Bool
    x s :: XIOInputConfig
    s -> XIOInputConfig
    s { xioEncodingErrors :: Bool
    xioEncodingErrors = Bool
    x}
                                        }

    theInputEncoding                :: Selector XIOSysState String
    theInputEncoding :: Selector XIOSysState String
    theInputEncoding                = Selector XIOSysState XIOInputConfig
    theInputConfig
                                      Selector XIOSysState XIOInputConfig
    -> Selector XIOInputConfig String -> Selector XIOSysState String
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOInputConfig -> String
    getS = XIOInputConfig -> String
    xioInputEncoding
                                        , setS :: String -> XIOInputConfig -> XIOInputConfig
    setS = \ x :: String
    x s :: XIOInputConfig
    s -> XIOInputConfig
    s { xioInputEncoding :: String
    xioInputEncoding = String
    x}
                                        }

    theHttpHandler                  :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
    theHttpHandler :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
    theHttpHandler                  = Selector XIOSysState XIOInputConfig
    theInputConfig
                                      Selector XIOSysState XIOInputConfig
    -> Selector XIOInputConfig (IOSArrow XmlTree XmlTree)
    -> Selector XIOSysState (IOSArrow XmlTree XmlTree)
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOInputConfig -> IOSArrow XmlTree XmlTree
    getS = XIOInputConfig -> IOSArrow XmlTree XmlTree
    xioHttpHandler
                                        , setS :: IOSArrow XmlTree XmlTree -> XIOInputConfig -> XIOInputConfig
    setS = \ x :: IOSArrow XmlTree XmlTree
    x s :: XIOInputConfig
    s -> XIOInputConfig
    s { xioHttpHandler :: IOSArrow XmlTree XmlTree
    xioHttpHandler = IOSArrow XmlTree XmlTree
    x}
                                        }

    theInputOptions                 :: Selector XIOSysState Attributes
    theInputOptions :: Selector XIOSysState Attributes
    theInputOptions                 = Selector XIOSysState XIOInputConfig
    theInputConfig
                                      Selector XIOSysState XIOInputConfig
    -> Selector XIOInputConfig Attributes
    -> Selector XIOSysState Attributes
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOInputConfig -> Attributes
    getS = XIOInputConfig -> Attributes
    xioInputOptions
                                        , setS :: Attributes -> XIOInputConfig -> XIOInputConfig
    setS = \ x :: Attributes
    x s :: XIOInputConfig
    s -> XIOInputConfig
    s { xioInputOptions :: Attributes
    xioInputOptions = Attributes
    x}
                                        }

    theRedirect                     :: Selector XIOSysState Bool
    theRedirect :: Selector XIOSysState Bool
    theRedirect                     = Selector XIOSysState XIOInputConfig
    theInputConfig
                                      Selector XIOSysState XIOInputConfig
    -> Selector XIOInputConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOInputConfig -> Bool
    getS = XIOInputConfig -> Bool
    xioRedirect
                                        , setS :: Bool -> XIOInputConfig -> XIOInputConfig
    setS = \ x :: Bool
    x s :: XIOInputConfig
    s -> XIOInputConfig
    s { xioRedirect :: Bool
    xioRedirect = Bool
    x}
                                        }

    theProxy                        :: Selector XIOSysState String
    theProxy :: Selector XIOSysState String
    theProxy                        = Selector XIOSysState XIOInputConfig
    theInputConfig
                                      Selector XIOSysState XIOInputConfig
    -> Selector XIOInputConfig String -> Selector XIOSysState String
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOInputConfig -> String
    getS = XIOInputConfig -> String
    xioProxy
                                        , setS :: String -> XIOInputConfig -> XIOInputConfig
    setS = \ x :: String
    x s :: XIOInputConfig
    s -> XIOInputConfig
    s { xioProxy :: String
    xioProxy = String
    x}
                                        }

    -- ----------------------------------------

    theOutputConfig                 :: Selector XIOSysState XIOOutputConfig
    theOutputConfig :: Selector XIOSysState XIOOutputConfig
    theOutputConfig                 = Selector XIOSysState XIOSysEnv
    theSysEnv
                                      Selector XIOSysState XIOSysEnv
    -> Selector XIOSysEnv XIOOutputConfig
    -> Selector XIOSysState XIOOutputConfig
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysEnv -> XIOOutputConfig
    getS = XIOSysEnv -> XIOOutputConfig
    xioOutputConfig
                                        , setS :: XIOOutputConfig -> XIOSysEnv -> XIOSysEnv
    setS = \ x :: XIOOutputConfig
    x s :: XIOSysEnv
    s -> XIOSysEnv
    s { xioOutputConfig :: XIOOutputConfig
    xioOutputConfig = XIOOutputConfig
    x}
                                        }

    theIndent                       :: Selector XIOSysState Bool
    theIndent :: Selector XIOSysState Bool
    theIndent                       = Selector XIOSysState XIOOutputConfig
    theOutputConfig
                                      Selector XIOSysState XIOOutputConfig
    -> Selector XIOOutputConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOOutputConfig -> Bool
    getS = XIOOutputConfig -> Bool
    xioIndent
                                        , setS :: Bool -> XIOOutputConfig -> XIOOutputConfig
    setS = \ x :: Bool
    x s :: XIOOutputConfig
    s -> XIOOutputConfig
    s { xioIndent :: Bool
    xioIndent = Bool
    x}
                                        }

    theOutputEncoding               :: Selector XIOSysState String
    theOutputEncoding :: Selector XIOSysState String
    theOutputEncoding               = Selector XIOSysState XIOOutputConfig
    theOutputConfig
                                      Selector XIOSysState XIOOutputConfig
    -> Selector XIOOutputConfig String -> Selector XIOSysState String
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOOutputConfig -> String
    getS = XIOOutputConfig -> String
    xioOutputEncoding
                                        , setS :: String -> XIOOutputConfig -> XIOOutputConfig
    setS = \ x :: String
    x s :: XIOOutputConfig
    s -> XIOOutputConfig
    s { xioOutputEncoding :: String
    xioOutputEncoding = String
    x}
                                        }

    theOutputFmt                    :: Selector XIOSysState XIOXoutConfig
    theOutputFmt :: Selector XIOSysState XIOXoutConfig
    theOutputFmt                    = Selector XIOSysState XIOOutputConfig
    theOutputConfig
                                      Selector XIOSysState XIOOutputConfig
    -> Selector XIOOutputConfig XIOXoutConfig
    -> Selector XIOSysState XIOXoutConfig
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOOutputConfig -> XIOXoutConfig
    getS = XIOOutputConfig -> XIOXoutConfig
    xioOutputFmt
                                        , setS :: XIOXoutConfig -> XIOOutputConfig -> XIOOutputConfig
    setS = \ x :: XIOXoutConfig
    x s :: XIOOutputConfig
    s -> XIOOutputConfig
    s { xioOutputFmt :: XIOXoutConfig
    xioOutputFmt = XIOXoutConfig
    x}
                                        }

    theXmlPi                        :: Selector XIOSysState Bool
    theXmlPi :: Selector XIOSysState Bool
    theXmlPi                        = Selector XIOSysState XIOOutputConfig
    theOutputConfig
                                      Selector XIOSysState XIOOutputConfig
    -> Selector XIOOutputConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOOutputConfig -> Bool
    getS = XIOOutputConfig -> Bool
    xioXmlPi
                                        , setS :: Bool -> XIOOutputConfig -> XIOOutputConfig
    setS = \ x :: Bool
    x s :: XIOOutputConfig
    s -> XIOOutputConfig
    s { xioXmlPi :: Bool
    xioXmlPi = Bool
    x}
                                        }

    theNoEmptyElemFor               :: Selector XIOSysState [String]
    theNoEmptyElemFor :: Selector XIOSysState [String]
    theNoEmptyElemFor               = Selector XIOSysState XIOOutputConfig
    theOutputConfig
                                      Selector XIOSysState XIOOutputConfig
    -> Selector XIOOutputConfig [String]
    -> Selector XIOSysState [String]
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOOutputConfig -> [String]
    getS = XIOOutputConfig -> [String]
    xioNoEmptyElemFor
                                        , setS :: [String] -> XIOOutputConfig -> XIOOutputConfig
    setS = \ x :: [String]
    x s :: XIOOutputConfig
    s -> XIOOutputConfig
    s { xioNoEmptyElemFor :: [String]
    xioNoEmptyElemFor = [String]
    x}
                                        }

    theAddDefaultDTD                :: Selector XIOSysState Bool
    theAddDefaultDTD :: Selector XIOSysState Bool
    theAddDefaultDTD                = Selector XIOSysState XIOOutputConfig
    theOutputConfig
                                      Selector XIOSysState XIOOutputConfig
    -> Selector XIOOutputConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOOutputConfig -> Bool
    getS = XIOOutputConfig -> Bool
    xioAddDefaultDTD
                                        , setS :: Bool -> XIOOutputConfig -> XIOOutputConfig
    setS = \ x :: Bool
    x s :: XIOOutputConfig
    s -> XIOOutputConfig
    s { xioAddDefaultDTD :: Bool
    xioAddDefaultDTD = Bool
    x}
                                        }

    theTextMode                     :: Selector XIOSysState Bool
    theTextMode :: Selector XIOSysState Bool
    theTextMode                     = Selector XIOSysState XIOOutputConfig
    theOutputConfig
                                      Selector XIOSysState XIOOutputConfig
    -> Selector XIOOutputConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOOutputConfig -> Bool
    getS = XIOOutputConfig -> Bool
    xioTextMode
                                        , setS :: Bool -> XIOOutputConfig -> XIOOutputConfig
    setS = \ x :: Bool
    x s :: XIOOutputConfig
    s -> XIOOutputConfig
    s { xioTextMode :: Bool
    xioTextMode = Bool
    x}
                                        }

    theShowTree                     :: Selector XIOSysState Bool
    theShowTree :: Selector XIOSysState Bool
    theShowTree                     = Selector XIOSysState XIOOutputConfig
    theOutputConfig
                                      Selector XIOSysState XIOOutputConfig
    -> Selector XIOOutputConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOOutputConfig -> Bool
    getS = XIOOutputConfig -> Bool
    xioShowTree
                                        , setS :: Bool -> XIOOutputConfig -> XIOOutputConfig
    setS = \ x :: Bool
    x s :: XIOOutputConfig
    s -> XIOOutputConfig
    s { xioShowTree :: Bool
    xioShowTree = Bool
    x}
                                        }

    theShowHaskell                  :: Selector XIOSysState Bool
    theShowHaskell :: Selector XIOSysState Bool
    theShowHaskell                  = Selector XIOSysState XIOOutputConfig
    theOutputConfig
                                      Selector XIOSysState XIOOutputConfig
    -> Selector XIOOutputConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOOutputConfig -> Bool
    getS = XIOOutputConfig -> Bool
    xioShowHaskell
                                        , setS :: Bool -> XIOOutputConfig -> XIOOutputConfig
    setS = \ x :: Bool
    x s :: XIOOutputConfig
    s -> XIOOutputConfig
    s { xioShowHaskell :: Bool
    xioShowHaskell = Bool
    x}
                                        }

    -- ----------------------------------------

    theRelaxConfig                  :: Selector XIOSysState XIORelaxConfig
    theRelaxConfig :: Selector XIOSysState XIORelaxConfig
    theRelaxConfig                  = Selector XIOSysState XIOSysEnv
    theSysEnv
                                      Selector XIOSysState XIOSysEnv
    -> Selector XIOSysEnv XIORelaxConfig
    -> Selector XIOSysState XIORelaxConfig
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysEnv -> XIORelaxConfig
    getS = XIOSysEnv -> XIORelaxConfig
    xioRelaxConfig
                                        , setS :: XIORelaxConfig -> XIOSysEnv -> XIOSysEnv
    setS = \ x :: XIORelaxConfig
    x s :: XIOSysEnv
    s -> XIOSysEnv
    s { xioRelaxConfig :: XIORelaxConfig
    xioRelaxConfig = XIORelaxConfig
    x}
                                        }

    theRelaxValidate                :: Selector XIOSysState Bool
    theRelaxValidate :: Selector XIOSysState Bool
    theRelaxValidate                = Selector XIOSysState XIORelaxConfig
    theRelaxConfig
                                      Selector XIOSysState XIORelaxConfig
    -> Selector XIORelaxConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIORelaxConfig -> Bool
    getS = XIORelaxConfig -> Bool
    xioRelaxValidate
                                        , setS :: Bool -> XIORelaxConfig -> XIORelaxConfig
    setS = \ x :: Bool
    x s :: XIORelaxConfig
    s -> XIORelaxConfig
    s { xioRelaxValidate :: Bool
    xioRelaxValidate = Bool
    x}
                                        }

    theRelaxSchema                  :: Selector XIOSysState String
    theRelaxSchema :: Selector XIOSysState String
    theRelaxSchema                  = Selector XIOSysState XIORelaxConfig
    theRelaxConfig
                                      Selector XIOSysState XIORelaxConfig
    -> Selector XIORelaxConfig String -> Selector XIOSysState String
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIORelaxConfig -> String
    getS = XIORelaxConfig -> String
    xioRelaxSchema
                                        , setS :: String -> XIORelaxConfig -> XIORelaxConfig
    setS = \ x :: String
    x s :: XIORelaxConfig
    s -> XIORelaxConfig
    s { xioRelaxSchema :: String
    xioRelaxSchema = String
    x}
                                        }

    theRelaxCheckRestr              :: Selector XIOSysState Bool
    theRelaxCheckRestr :: Selector XIOSysState Bool
    theRelaxCheckRestr              = Selector XIOSysState XIORelaxConfig
    theRelaxConfig
                                      Selector XIOSysState XIORelaxConfig
    -> Selector XIORelaxConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIORelaxConfig -> Bool
    getS = XIORelaxConfig -> Bool
    xioRelaxCheckRestr
                                        , setS :: Bool -> XIORelaxConfig -> XIORelaxConfig
    setS = \ x :: Bool
    x s :: XIORelaxConfig
    s -> XIORelaxConfig
    s { xioRelaxCheckRestr :: Bool
    xioRelaxCheckRestr = Bool
    x}
                                        }

    theRelaxValidateExtRef          :: Selector XIOSysState Bool
    theRelaxValidateExtRef :: Selector XIOSysState Bool
    theRelaxValidateExtRef          = Selector XIOSysState XIORelaxConfig
    theRelaxConfig
                                      Selector XIOSysState XIORelaxConfig
    -> Selector XIORelaxConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIORelaxConfig -> Bool
    getS = XIORelaxConfig -> Bool
    xioRelaxValidateExtRef
                                        , setS :: Bool -> XIORelaxConfig -> XIORelaxConfig
    setS = \ x :: Bool
    x s :: XIORelaxConfig
    s -> XIORelaxConfig
    s { xioRelaxValidateExtRef :: Bool
    xioRelaxValidateExtRef = Bool
    x}
                                        }

    theRelaxValidateInclude         :: Selector XIOSysState Bool
    theRelaxValidateInclude :: Selector XIOSysState Bool
    theRelaxValidateInclude         = Selector XIOSysState XIORelaxConfig
    theRelaxConfig
                                      Selector XIOSysState XIORelaxConfig
    -> Selector XIORelaxConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIORelaxConfig -> Bool
    getS = XIORelaxConfig -> Bool
    xioRelaxValidateInclude
                                        , setS :: Bool -> XIORelaxConfig -> XIORelaxConfig
    setS = \ x :: Bool
    x s :: XIORelaxConfig
    s -> XIORelaxConfig
    s { xioRelaxValidateInclude :: Bool
    xioRelaxValidateInclude = Bool
    x}
                                        }

    theRelaxCollectErrors           :: Selector XIOSysState Bool
    theRelaxCollectErrors :: Selector XIOSysState Bool
    theRelaxCollectErrors           = Selector XIOSysState XIORelaxConfig
    theRelaxConfig
                                      Selector XIOSysState XIORelaxConfig
    -> Selector XIORelaxConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIORelaxConfig -> Bool
    getS = XIORelaxConfig -> Bool
    xioRelaxCollectErrors
                                        , setS :: Bool -> XIORelaxConfig -> XIORelaxConfig
    setS = \ x :: Bool
    x s :: XIORelaxConfig
    s -> XIORelaxConfig
    s { xioRelaxCollectErrors :: Bool
    xioRelaxCollectErrors = Bool
    x}
                                        }

    theRelaxValidator               :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
    theRelaxValidator :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
    theRelaxValidator               = Selector XIOSysState XIORelaxConfig
    theRelaxConfig
                                      Selector XIOSysState XIORelaxConfig
    -> Selector XIORelaxConfig (IOSArrow XmlTree XmlTree)
    -> Selector XIOSysState (IOSArrow XmlTree XmlTree)
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIORelaxConfig -> IOSArrow XmlTree XmlTree
    getS = XIORelaxConfig -> IOSArrow XmlTree XmlTree
    xioRelaxValidator
                                        , setS :: IOSArrow XmlTree XmlTree -> XIORelaxConfig -> XIORelaxConfig
    setS = \ x :: IOSArrow XmlTree XmlTree
    x s :: XIORelaxConfig
    s -> XIORelaxConfig
    s { xioRelaxValidator :: IOSArrow XmlTree XmlTree
    xioRelaxValidator = IOSArrow XmlTree XmlTree
    x}
                                        }

    -- ----------------------------------------

    theXmlSchemaConfig              :: Selector XIOSysState XIOXmlSchemaConfig
    theXmlSchemaConfig :: Selector XIOSysState XIOXmlSchemaConfig
    theXmlSchemaConfig              = Selector XIOSysState XIOSysEnv
    theSysEnv
                                      Selector XIOSysState XIOSysEnv
    -> Selector XIOSysEnv XIOXmlSchemaConfig
    -> Selector XIOSysState XIOXmlSchemaConfig
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysEnv -> XIOXmlSchemaConfig
    getS = XIOSysEnv -> XIOXmlSchemaConfig
    xioXmlSchemaConfig
                                        , setS :: XIOXmlSchemaConfig -> XIOSysEnv -> XIOSysEnv
    setS = \ x :: XIOXmlSchemaConfig
    x s :: XIOSysEnv
    s -> XIOSysEnv
    s { xioXmlSchemaConfig :: XIOXmlSchemaConfig
    xioXmlSchemaConfig = XIOXmlSchemaConfig
    x}
                                        }

    theXmlSchemaValidate            :: Selector XIOSysState Bool
    theXmlSchemaValidate :: Selector XIOSysState Bool
    theXmlSchemaValidate            = Selector XIOSysState XIOXmlSchemaConfig
    theXmlSchemaConfig
                                      Selector XIOSysState XIOXmlSchemaConfig
    -> Selector XIOXmlSchemaConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOXmlSchemaConfig -> Bool
    getS = XIOXmlSchemaConfig -> Bool
    xioXmlSchemaValidate
                                        , setS :: Bool -> XIOXmlSchemaConfig -> XIOXmlSchemaConfig
    setS = \ x :: Bool
    x s :: XIOXmlSchemaConfig
    s -> XIOXmlSchemaConfig
    s { xioXmlSchemaValidate :: Bool
    xioXmlSchemaValidate = Bool
    x}
                                        }

    theXmlSchemaSchema              :: Selector XIOSysState String
    theXmlSchemaSchema :: Selector XIOSysState String
    theXmlSchemaSchema              = Selector XIOSysState XIOXmlSchemaConfig
    theXmlSchemaConfig
                                      Selector XIOSysState XIOXmlSchemaConfig
    -> Selector XIOXmlSchemaConfig String
    -> Selector XIOSysState String
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOXmlSchemaConfig -> String
    getS = XIOXmlSchemaConfig -> String
    xioXmlSchemaSchema
                                        , setS :: String -> XIOXmlSchemaConfig -> XIOXmlSchemaConfig
    setS = \ x :: String
    x s :: XIOXmlSchemaConfig
    s -> XIOXmlSchemaConfig
    s { xioXmlSchemaSchema :: String
    xioXmlSchemaSchema = String
    x}
                                        }

    theXmlSchemaValidator           :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
    theXmlSchemaValidator :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
    theXmlSchemaValidator           = Selector XIOSysState XIOXmlSchemaConfig
    theXmlSchemaConfig
                                      Selector XIOSysState XIOXmlSchemaConfig
    -> Selector XIOXmlSchemaConfig (IOSArrow XmlTree XmlTree)
    -> Selector XIOSysState (IOSArrow XmlTree XmlTree)
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOXmlSchemaConfig -> IOSArrow XmlTree XmlTree
    getS = XIOXmlSchemaConfig -> IOSArrow XmlTree XmlTree
    xioXmlSchemaValidator
                                        , setS :: IOSArrow XmlTree XmlTree
    -> XIOXmlSchemaConfig -> XIOXmlSchemaConfig
    setS = \ x :: IOSArrow XmlTree XmlTree
    x s :: XIOXmlSchemaConfig
    s -> XIOXmlSchemaConfig
    s { xioXmlSchemaValidator :: IOSArrow XmlTree XmlTree
    xioXmlSchemaValidator = IOSArrow XmlTree XmlTree
    x}
                                        }

    -- ----------------------------------------

    theParseConfig                  :: Selector XIOSysState XIOParseConfig
    theParseConfig :: Selector XIOSysState XIOParseConfig
    theParseConfig                  = Selector XIOSysState XIOSysEnv
    theSysEnv
                                      Selector XIOSysState XIOSysEnv
    -> Selector XIOSysEnv XIOParseConfig
    -> Selector XIOSysState XIOParseConfig
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysEnv -> XIOParseConfig
    getS = XIOSysEnv -> XIOParseConfig
    xioParseConfig
                                        , setS :: XIOParseConfig -> XIOSysEnv -> XIOSysEnv
    setS = \ x :: XIOParseConfig
    x s :: XIOSysEnv
    s -> XIOSysEnv
    s { xioParseConfig :: XIOParseConfig
    xioParseConfig = XIOParseConfig
    x}
                                        }

    theErrorMsgHandler              :: Selector XIOSysState (String -> IO ())
    theErrorMsgHandler :: Selector XIOSysState (String -> IO ())
    theErrorMsgHandler              = Selector XIOSysState XIOSysEnv
    theSysEnv
                                      Selector XIOSysState XIOSysEnv
    -> Selector XIOSysEnv (String -> IO ())
    -> Selector XIOSysState (String -> IO ())
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysEnv -> String -> IO ()
    getS = XIOSysEnv -> String -> IO ()
    xioErrorMsgHandler
                                        , setS :: (String -> IO ()) -> XIOSysEnv -> XIOSysEnv
    setS = \ x :: String -> IO ()
    x s :: XIOSysEnv
    s -> XIOSysEnv
    s { xioErrorMsgHandler :: String -> IO ()
    xioErrorMsgHandler = String -> IO ()
    x }
                                        }

    theErrorMsgCollect              :: Selector XIOSysState Bool
    theErrorMsgCollect :: Selector XIOSysState Bool
    theErrorMsgCollect              = Selector XIOSysState XIOSysEnv
    theSysEnv
                                      Selector XIOSysState XIOSysEnv
    -> Selector XIOSysEnv Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysEnv -> Bool
    getS = XIOSysEnv -> Bool
    xioErrorMsgCollect
                                        , setS :: Bool -> XIOSysEnv -> XIOSysEnv
    setS = \ x :: Bool
    x s :: XIOSysEnv
    s -> XIOSysEnv
    s { xioErrorMsgCollect :: Bool
    xioErrorMsgCollect = Bool
    x }
                                        }

    theBaseURI                      :: Selector XIOSysState String
    theBaseURI :: Selector XIOSysState String
    theBaseURI                      = Selector XIOSysState XIOSysEnv
    theSysEnv
                                      Selector XIOSysState XIOSysEnv
    -> Selector XIOSysEnv String -> Selector XIOSysState String
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysEnv -> String
    getS = XIOSysEnv -> String
    xioBaseURI
                                        , setS :: String -> XIOSysEnv -> XIOSysEnv
    setS = \ x :: String
    x s :: XIOSysEnv
    s -> XIOSysEnv
    s { xioBaseURI :: String
    xioBaseURI = String
    x }
                                        }

    theDefaultBaseURI               :: Selector XIOSysState String
    theDefaultBaseURI :: Selector XIOSysState String
    theDefaultBaseURI               = Selector XIOSysState XIOSysEnv
    theSysEnv
                                      Selector XIOSysState XIOSysEnv
    -> Selector XIOSysEnv String -> Selector XIOSysState String
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysEnv -> String
    getS = XIOSysEnv -> String
    xioDefaultBaseURI
                                        , setS :: String -> XIOSysEnv -> XIOSysEnv
    setS = \ x :: String
    x s :: XIOSysEnv
    s -> XIOSysEnv
    s { xioDefaultBaseURI :: String
    xioDefaultBaseURI = String
    x }
                                        }

    theTraceLevel                   :: Selector XIOSysState Int
    theTraceLevel :: Selector XIOSysState Int
    theTraceLevel                   = Selector XIOSysState XIOSysEnv
    theSysEnv
                                      Selector XIOSysState XIOSysEnv
    -> Selector XIOSysEnv Int -> Selector XIOSysState Int
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysEnv -> Int
    getS = XIOSysEnv -> Int
    xioTraceLevel
                                        , setS :: Int -> XIOSysEnv -> XIOSysEnv
    setS = \ x :: Int
    x s :: XIOSysEnv
    s -> XIOSysEnv
    s { xioTraceLevel :: Int
    xioTraceLevel = Int
    x }
                                        }

    theTraceCmd                     :: Selector XIOSysState (Int -> String -> IO ())
    theTraceCmd :: Selector XIOSysState (Int -> String -> IO ())
    theTraceCmd                     = Selector XIOSysState XIOSysEnv
    theSysEnv
                                      Selector XIOSysState XIOSysEnv
    -> Selector XIOSysEnv (Int -> String -> IO ())
    -> Selector XIOSysState (Int -> String -> IO ())
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysEnv -> Int -> String -> IO ()
    getS = XIOSysEnv -> Int -> String -> IO ()
    xioTraceCmd
                                        , setS :: (Int -> String -> IO ()) -> XIOSysEnv -> XIOSysEnv
    setS = \ x :: Int -> String -> IO ()
    x s :: XIOSysEnv
    s -> XIOSysEnv
    s { xioTraceCmd :: Int -> String -> IO ()
    xioTraceCmd = Int -> String -> IO ()
    x }
                                        }

    theTrace                        :: Selector XIOSysState (Int, Int -> String -> IO ())
    theTrace :: Selector XIOSysState (Int, Int -> String -> IO ())
    theTrace                        = Selector XIOSysState Int
    theTraceLevel Selector XIOSysState Int
    -> Selector XIOSysState (Int -> String -> IO ())
    -> Selector XIOSysState (Int, Int -> String -> IO ())
    forall s a b. Selector s a -> Selector s b -> Selector s (a, b)
    .&&&. Selector XIOSysState (Int -> String -> IO ())
    theTraceCmd

    theAttrList                     :: Selector XIOSysState Attributes
    theAttrList :: Selector XIOSysState Attributes
    theAttrList                     = Selector XIOSysState XIOSysEnv
    theSysEnv
                                      Selector XIOSysState XIOSysEnv
    -> Selector XIOSysEnv Attributes -> Selector XIOSysState Attributes
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysEnv -> Attributes
    getS = XIOSysEnv -> Attributes
    xioAttrList
                                        , setS :: Attributes -> XIOSysEnv -> XIOSysEnv
    setS = \ x :: Attributes
    x s :: XIOSysEnv
    s -> XIOSysEnv
    s { xioAttrList :: Attributes
    xioAttrList = Attributes
    x }
                                        }

    theMimeTypes                    :: Selector XIOSysState MimeTypeTable
    theMimeTypes :: Selector XIOSysState MimeTypeTable
    theMimeTypes                    = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig MimeTypeTable
    -> Selector XIOSysState MimeTypeTable
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> MimeTypeTable
    getS = XIOParseConfig -> MimeTypeTable
    xioMimeTypes
                                        , setS :: MimeTypeTable -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: MimeTypeTable
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioMimeTypes :: MimeTypeTable
    xioMimeTypes = MimeTypeTable
    x }
                                        }

    theMimeTypeHandlers             :: Selector XIOSysState MimeTypeHandlers
    theMimeTypeHandlers :: Selector XIOSysState MimeTypeHandlers
    theMimeTypeHandlers             = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig MimeTypeHandlers
    -> Selector XIOSysState MimeTypeHandlers
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> MimeTypeHandlers
    getS = XIOParseConfig -> MimeTypeHandlers
    xioMimeTypeHandlers
                                        , setS :: MimeTypeHandlers -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: MimeTypeHandlers
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioMimeTypeHandlers :: MimeTypeHandlers
    xioMimeTypeHandlers = MimeTypeHandlers
    x }
                                        }

    theMimeTypeFile                 :: Selector XIOSysState String
    theMimeTypeFile :: Selector XIOSysState String
    theMimeTypeFile                 = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig String -> Selector XIOSysState String
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> String
    getS = XIOParseConfig -> String
    xioMimeTypeFile
                                        , setS :: String -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: String
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioMimeTypeFile :: String
    xioMimeTypeFile = String
    x }
                                        }

    theAcceptedMimeTypes            :: Selector XIOSysState [String]
    theAcceptedMimeTypes :: Selector XIOSysState [String]
    theAcceptedMimeTypes            = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig [String]
    -> Selector XIOSysState [String]
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> [String]
    getS = XIOParseConfig -> [String]
    xioAcceptedMimeTypes
                                        , setS :: [String] -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: [String]
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioAcceptedMimeTypes :: [String]
    xioAcceptedMimeTypes = [String]
    x }
                                        }

    theFileMimeType                 :: Selector XIOSysState String
    theFileMimeType :: Selector XIOSysState String
    theFileMimeType                 = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig String -> Selector XIOSysState String
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> String
    getS = XIOParseConfig -> String
    xioFileMimeType
                                        , setS :: String -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: String
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioFileMimeType :: String
    xioFileMimeType = String
    x }
                                        }

    theWarnings                     :: Selector XIOSysState Bool
    theWarnings :: Selector XIOSysState Bool
    theWarnings                     = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioWarnings
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioWarnings :: Bool
    xioWarnings = Bool
    x }
                                        }

    theRemoveWS                     :: Selector XIOSysState Bool
    theRemoveWS :: Selector XIOSysState Bool
    theRemoveWS                     = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioRemoveWS
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioRemoveWS :: Bool
    xioRemoveWS = Bool
    x }
                                        }

    thePreserveComment              :: Selector XIOSysState Bool
    thePreserveComment :: Selector XIOSysState Bool
    thePreserveComment              = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioPreserveComment
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioPreserveComment :: Bool
    xioPreserveComment = Bool
    x }
                                        }

    theParseByMimeType              :: Selector XIOSysState Bool
    theParseByMimeType :: Selector XIOSysState Bool
    theParseByMimeType              = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioParseByMimeType
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioParseByMimeType :: Bool
    xioParseByMimeType = Bool
    x }
                                        }

    theParseHTML                    :: Selector XIOSysState Bool
    theParseHTML :: Selector XIOSysState Bool
    theParseHTML                    = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioParseHTML
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioParseHTML :: Bool
    xioParseHTML = Bool
    x }
                                        }

    theLowerCaseNames               :: Selector XIOSysState Bool
    theLowerCaseNames :: Selector XIOSysState Bool
    theLowerCaseNames               = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioLowerCaseNames
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioLowerCaseNames :: Bool
    xioLowerCaseNames = Bool
    x }
                                        }

    theValidate                     :: Selector XIOSysState Bool
    theValidate :: Selector XIOSysState Bool
    theValidate                     = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioValidate
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioValidate :: Bool
    xioValidate = Bool
    x }
                                        }

    theSubstDTDEntities            :: Selector XIOSysState Bool
    theSubstDTDEntities :: Selector XIOSysState Bool
    theSubstDTDEntities            = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioSubstDTDEntities
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioSubstDTDEntities :: Bool
    xioSubstDTDEntities = Bool
    x }
                                        }

    theSubstHTMLEntities            :: Selector XIOSysState Bool
    theSubstHTMLEntities :: Selector XIOSysState Bool
    theSubstHTMLEntities            = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioSubstHTMLEntities
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioSubstHTMLEntities :: Bool
    xioSubstHTMLEntities = Bool
    x }
                                        }

    theCheckNamespaces              :: Selector XIOSysState Bool
    theCheckNamespaces :: Selector XIOSysState Bool
    theCheckNamespaces              = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioCheckNamespaces
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioCheckNamespaces :: Bool
    xioCheckNamespaces = Bool
    x }
                                        }

    theCanonicalize                 :: Selector XIOSysState Bool
    theCanonicalize :: Selector XIOSysState Bool
    theCanonicalize                 = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioCanonicalize
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioCanonicalize :: Bool
    xioCanonicalize = Bool
    x }
                                        }

    theIgnoreNoneXmlContents        :: Selector XIOSysState Bool
    theIgnoreNoneXmlContents :: Selector XIOSysState Bool
    theIgnoreNoneXmlContents        = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioIgnoreNoneXmlContents
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioIgnoreNoneXmlContents :: Bool
    xioIgnoreNoneXmlContents = Bool
    x }
                                        }

    theTagSoup                      :: Selector XIOSysState Bool
    theTagSoup :: Selector XIOSysState Bool
    theTagSoup                      = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioTagSoup
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioTagSoup :: Bool
    xioTagSoup = Bool
    x }
                                        }

    theTagSoupParser                :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
    theTagSoupParser :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
    theTagSoupParser                = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig (IOSArrow XmlTree XmlTree)
    -> Selector XIOSysState (IOSArrow XmlTree XmlTree)
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> IOSArrow XmlTree XmlTree
    getS = XIOParseConfig -> IOSArrow XmlTree XmlTree
    xioTagSoupParser
                                        , setS :: IOSArrow XmlTree XmlTree -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: IOSArrow XmlTree XmlTree
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioTagSoupParser :: IOSArrow XmlTree XmlTree
    xioTagSoupParser = IOSArrow XmlTree XmlTree
    x }
                                        }

    theExpat                        :: Selector XIOSysState Bool
    theExpat :: Selector XIOSysState Bool
    theExpat                        = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> Bool
    getS = XIOParseConfig -> Bool
    xioExpat
                                        , setS :: Bool -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: Bool
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioExpat :: Bool
    xioExpat = Bool
    x }
                                        }

    theExpatParser                  :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
    theExpatParser :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
    theExpatParser                  = Selector XIOSysState XIOParseConfig
    theParseConfig
                                      Selector XIOSysState XIOParseConfig
    -> Selector XIOParseConfig (IOSArrow XmlTree XmlTree)
    -> Selector XIOSysState (IOSArrow XmlTree XmlTree)
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOParseConfig -> IOSArrow XmlTree XmlTree
    getS = XIOParseConfig -> IOSArrow XmlTree XmlTree
    xioExpatParser
                                        , setS :: IOSArrow XmlTree XmlTree -> XIOParseConfig -> XIOParseConfig
    setS = \ x :: IOSArrow XmlTree XmlTree
    x s :: XIOParseConfig
    s -> XIOParseConfig
    s { xioExpatParser :: IOSArrow XmlTree XmlTree
    xioExpatParser = IOSArrow XmlTree XmlTree
    x }
                                        }

    theExpatErrors                  :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
    theExpatErrors :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
    theExpatErrors                  = Selector XIOSysState XIOSysWriter
    theSysWriter
                                      Selector XIOSysState XIOSysWriter
    -> Selector XIOSysWriter (IOSArrow XmlTree XmlTree)
    -> Selector XIOSysState (IOSArrow XmlTree XmlTree)
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysWriter -> IOSArrow XmlTree XmlTree
    getS = XIOSysWriter -> IOSArrow XmlTree XmlTree
    xioExpatErrors
                                        , setS :: IOSArrow XmlTree XmlTree -> XIOSysWriter -> XIOSysWriter
    setS = \ x :: IOSArrow XmlTree XmlTree
    x s :: XIOSysWriter
    s -> XIOSysWriter
    s { xioExpatErrors :: IOSArrow XmlTree XmlTree
    xioExpatErrors = IOSArrow XmlTree XmlTree
    x }
                                        }

    -- ----------------------------------------

    theCacheConfig                  :: Selector XIOSysState XIOCacheConfig
    theCacheConfig :: Selector XIOSysState XIOCacheConfig
    theCacheConfig                  = Selector XIOSysState XIOSysEnv
    theSysEnv
                                      Selector XIOSysState XIOSysEnv
    -> Selector XIOSysEnv XIOCacheConfig
    -> Selector XIOSysState XIOCacheConfig
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOSysEnv -> XIOCacheConfig
    getS = XIOSysEnv -> XIOCacheConfig
    xioCacheConfig
                                        , setS :: XIOCacheConfig -> XIOSysEnv -> XIOSysEnv
    setS = \ x :: XIOCacheConfig
    x s :: XIOSysEnv
    s -> XIOSysEnv
    s { xioCacheConfig :: XIOCacheConfig
    xioCacheConfig = XIOCacheConfig
    x}
                                        }

    theBinaryCompression            :: Selector XIOSysState (ByteString -> ByteString)
    theBinaryCompression :: Selector XIOSysState CompressionFct
    theBinaryCompression            = Selector XIOSysState XIOCacheConfig
    theCacheConfig
                                      Selector XIOSysState XIOCacheConfig
    -> Selector XIOCacheConfig CompressionFct
    -> Selector XIOSysState CompressionFct
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOCacheConfig -> CompressionFct
    getS = XIOCacheConfig -> CompressionFct
    xioBinaryCompression
                                        , setS :: CompressionFct -> XIOCacheConfig -> XIOCacheConfig
    setS = \ x :: CompressionFct
    x s :: XIOCacheConfig
    s -> XIOCacheConfig
    s { xioBinaryCompression :: CompressionFct
    xioBinaryCompression = CompressionFct
    x}
                                        }

    theBinaryDeCompression          :: Selector XIOSysState (ByteString -> ByteString)
    theBinaryDeCompression :: Selector XIOSysState CompressionFct
    theBinaryDeCompression          = Selector XIOSysState XIOCacheConfig
    theCacheConfig
                                      Selector XIOSysState XIOCacheConfig
    -> Selector XIOCacheConfig CompressionFct
    -> Selector XIOSysState CompressionFct
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOCacheConfig -> CompressionFct
    getS = XIOCacheConfig -> CompressionFct
    xioBinaryDeCompression
                                        , setS :: CompressionFct -> XIOCacheConfig -> XIOCacheConfig
    setS = \ x :: CompressionFct
    x s :: XIOCacheConfig
    s -> XIOCacheConfig
    s { xioBinaryDeCompression :: CompressionFct
    xioBinaryDeCompression = CompressionFct
    x}
                                        }

    theWithCache                    :: Selector XIOSysState Bool
    theWithCache :: Selector XIOSysState Bool
    theWithCache                    = Selector XIOSysState XIOCacheConfig
    theCacheConfig
                                      Selector XIOSysState XIOCacheConfig
    -> Selector XIOCacheConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOCacheConfig -> Bool
    getS = XIOCacheConfig -> Bool
    xioWithCache
                                        , setS :: Bool -> XIOCacheConfig -> XIOCacheConfig
    setS = \ x :: Bool
    x s :: XIOCacheConfig
    s -> XIOCacheConfig
    s { xioWithCache :: Bool
    xioWithCache = Bool
    x}
                                        }

    theCacheDir                     :: Selector XIOSysState String
    theCacheDir :: Selector XIOSysState String
    theCacheDir                     = Selector XIOSysState XIOCacheConfig
    theCacheConfig
                                      Selector XIOSysState XIOCacheConfig
    -> Selector XIOCacheConfig String -> Selector XIOSysState String
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOCacheConfig -> String
    getS = XIOCacheConfig -> String
    xioCacheDir
                                        , setS :: String -> XIOCacheConfig -> XIOCacheConfig
    setS = \ x :: String
    x s :: XIOCacheConfig
    s -> XIOCacheConfig
    s { xioCacheDir :: String
    xioCacheDir = String
    x}
                                        }

    theDocumentAge                  :: Selector XIOSysState Int
    theDocumentAge :: Selector XIOSysState Int
    theDocumentAge                  = Selector XIOSysState XIOCacheConfig
    theCacheConfig
                                      Selector XIOSysState XIOCacheConfig
    -> Selector XIOCacheConfig Int -> Selector XIOSysState Int
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOCacheConfig -> Int
    getS = XIOCacheConfig -> Int
    xioDocumentAge
                                        , setS :: Int -> XIOCacheConfig -> XIOCacheConfig
    setS = \ x :: Int
    x s :: XIOCacheConfig
    s -> XIOCacheConfig
    s { xioDocumentAge :: Int
    xioDocumentAge = Int
    x}
                                        }

    theCache404Err                  :: Selector XIOSysState Bool
    theCache404Err :: Selector XIOSysState Bool
    theCache404Err                  = Selector XIOSysState XIOCacheConfig
    theCacheConfig
                                      Selector XIOSysState XIOCacheConfig
    -> Selector XIOCacheConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOCacheConfig -> Bool
    getS = XIOCacheConfig -> Bool
    xioCache404Err
                                        , setS :: Bool -> XIOCacheConfig -> XIOCacheConfig
    setS = \ x :: Bool
    x s :: XIOCacheConfig
    s -> XIOCacheConfig
    s { xioCache404Err :: Bool
    xioCache404Err = Bool
    x}
                                        }

    theCacheRead                    :: Selector XIOSysState (String -> IOSArrow XmlTree XmlTree)
    theCacheRead :: Selector XIOSysState (String -> IOSArrow XmlTree XmlTree)
    theCacheRead                    = Selector XIOSysState XIOCacheConfig
    theCacheConfig
                                      Selector XIOSysState XIOCacheConfig
    -> Selector XIOCacheConfig (String -> IOSArrow XmlTree XmlTree)
    -> Selector XIOSysState (String -> IOSArrow XmlTree XmlTree)
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOCacheConfig -> String -> IOSArrow XmlTree XmlTree
    getS = XIOCacheConfig -> String -> IOSArrow XmlTree XmlTree
    xioCacheRead
                                        , setS :: (String -> IOSArrow XmlTree XmlTree)
    -> XIOCacheConfig -> XIOCacheConfig
    setS = \ x :: String -> IOSArrow XmlTree XmlTree
    x s :: XIOCacheConfig
    s -> XIOCacheConfig
    s { xioCacheRead :: String -> IOSArrow XmlTree XmlTree
    xioCacheRead = String -> IOSArrow XmlTree XmlTree
    x}
                                        }

    theStrictDeserialize            :: Selector XIOSysState Bool
    theStrictDeserialize :: Selector XIOSysState Bool
    theStrictDeserialize            = Selector XIOSysState XIOCacheConfig
    theCacheConfig
                                      Selector XIOSysState XIOCacheConfig
    -> Selector XIOCacheConfig Bool -> Selector XIOSysState Bool
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
    S { getS :: XIOCacheConfig -> Bool
    getS = XIOCacheConfig -> Bool
    xioStrictDeserialize
                                        , setS :: Bool -> XIOCacheConfig -> XIOCacheConfig
    setS = \ x :: Bool
    x s :: XIOCacheConfig
    s -> XIOCacheConfig
    s { xioStrictDeserialize :: Bool
    xioStrictDeserialize = Bool
    x}
                                        }

    -- ------------------------------------------------------------

    getSysVar                       :: Selector XIOSysState c -> IOStateArrow s b c
    getSysVar :: Selector XIOSysState c -> IOStateArrow s b c
    getSysVar sel :: Selector XIOSysState c
    sel                   = (XIOState s -> b -> IO (XIOState s, [c])) -> IOStateArrow s b c
    forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
    IOSLA ((XIOState s -> b -> IO (XIOState s, [c])) -> IOStateArrow s b c)
    -> (XIOState s -> b -> IO (XIOState s, [c])) -> IOStateArrow s b c
    forall a b. (a -> b) -> a -> b
    $ \ s :: XIOState s
    s _x :: b
    _x ->
                                      (XIOState s, [c]) -> IO (XIOState s, [c])
    forall (m :: * -> *) a. Monad m => a -> m a
    return (XIOState s
    s, (c -> [c] -> [c]
    forall a. a -> [a] -> [a]
    :[]) (c -> [c]) -> (XIOState s -> c) -> XIOState s -> [c]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Selector (XIOState s) c -> XIOState s -> c
    forall s a. Selector s a -> s -> a
    getS (Selector (XIOState s) XIOSysState
    forall us. Selector (XIOState us) XIOSysState
    theSysState Selector (XIOState s) XIOSysState
    -> Selector XIOSysState c -> Selector (XIOState s) c
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> Selector XIOSysState c
    sel) (XIOState s -> [c]) -> XIOState s -> [c]
    forall a b. (a -> b) -> a -> b
    $ XIOState s
    s)

    setSysVar                       :: Selector XIOSysState c -> IOStateArrow s c c
    setSysVar :: Selector XIOSysState c -> IOStateArrow s c c
    setSysVar sel :: Selector XIOSysState c
    sel                   = (\ v :: c
    v -> (XIOSysState -> XIOSysState) -> IOStateArrow s c c
    forall s c. (XIOSysState -> XIOSysState) -> IOStateArrow s c c
    configSysVar ((XIOSysState -> XIOSysState) -> IOStateArrow s c c)
    -> (XIOSysState -> XIOSysState) -> IOStateArrow s c c
    forall a b. (a -> b) -> a -> b
    $ Selector XIOSysState c -> c -> XIOSysState -> XIOSysState
    forall s a. Selector s a -> a -> s -> s
    setS Selector XIOSysState c
    sel c
    v) (c -> IOStateArrow s c c)
    -> IOStateArrow s c c -> IOStateArrow s c c
    forall (a :: * -> * -> *) c b d.
    ArrowList a =>
    (c -> a b d) -> a b c -> a b d
    $< IOStateArrow s c c
    forall (a :: * -> * -> *) b. ArrowList a => a b b
    this

    chgSysVar                       :: Selector XIOSysState c -> (b -> c -> c) -> IOStateArrow s b b
    chgSysVar :: Selector XIOSysState c -> (b -> c -> c) -> IOStateArrow s b b
    chgSysVar sel :: Selector XIOSysState c
    sel op :: b -> c -> c
    op                = (\ v :: b
    v -> (XIOSysState -> XIOSysState) -> IOStateArrow s b b
    forall s c. (XIOSysState -> XIOSysState) -> IOStateArrow s c c
    configSysVar ((XIOSysState -> XIOSysState) -> IOStateArrow s b b)
    -> (XIOSysState -> XIOSysState) -> IOStateArrow s b b
    forall a b. (a -> b) -> a -> b
    $ Selector XIOSysState c -> (c -> c) -> XIOSysState -> XIOSysState
    forall s a. Selector s a -> (a -> a) -> s -> s
    chgS Selector XIOSysState c
    sel (b -> c -> c
    op b
    v)) (b -> IOStateArrow s b b)
    -> IOStateArrow s b b -> IOStateArrow s b b
    forall (a :: * -> * -> *) c b d.
    ArrowList a =>
    (c -> a b d) -> a b c -> a b d
    $< IOStateArrow s b b
    forall (a :: * -> * -> *) b. ArrowList a => a b b
    this

    configSysVar                    :: SysConfig -> IOStateArrow s c c
    configSysVar :: (XIOSysState -> XIOSysState) -> IOStateArrow s c c
    configSysVar cf :: XIOSysState -> XIOSysState
    cf                 = (XIOState s -> c -> IO (XIOState s, [c])) -> IOStateArrow s c c
    forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
    IOSLA ((XIOState s -> c -> IO (XIOState s, [c])) -> IOStateArrow s c c)
    -> (XIOState s -> c -> IO (XIOState s, [c])) -> IOStateArrow s c c
    forall a b. (a -> b) -> a -> b
    $ \ s :: XIOState s
    s v :: c
    v ->
                                      (XIOState s, [c]) -> IO (XIOState s, [c])
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Selector (XIOState s) XIOSysState
    -> (XIOSysState -> XIOSysState) -> XIOState s -> XIOState s
    forall s a. Selector s a -> (a -> a) -> s -> s
    chgS Selector (XIOState s) XIOSysState
    forall us. Selector (XIOState us) XIOSysState
    theSysState XIOSysState -> XIOSysState
    cf XIOState s
    s, [c
    v])

    configSysVars                   :: SysConfigList -> IOStateArrow s c c
    configSysVars :: SysConfigList -> IOStateArrow s c c
    configSysVars cfs :: SysConfigList
    cfs               = (XIOSysState -> XIOSysState) -> IOStateArrow s c c
    forall s c. (XIOSysState -> XIOSysState) -> IOStateArrow s c c
    configSysVar ((XIOSysState -> XIOSysState) -> IOStateArrow s c c)
    -> (XIOSysState -> XIOSysState) -> IOStateArrow s c c
    forall a b. (a -> b) -> a -> b
    $ ((XIOSysState -> XIOSysState)
     -> (XIOSysState -> XIOSysState) -> XIOSysState -> XIOSysState)
    -> (XIOSysState -> XIOSysState)
    -> SysConfigList
    -> XIOSysState
    -> XIOSysState
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (XIOSysState -> XIOSysState)
    -> (XIOSysState -> XIOSysState) -> XIOSysState -> XIOSysState
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    (>>>) XIOSysState -> XIOSysState
    forall a. a -> a
    id (SysConfigList -> XIOSysState -> XIOSysState)
    -> SysConfigList -> XIOSysState -> XIOSysState
    forall a b. (a -> b) -> a -> b
    $ SysConfigList
    cfs

    localSysVar                     :: Selector XIOSysState c -> IOStateArrow s a b -> IOStateArrow s a b
    localSysVar :: Selector XIOSysState c -> IOStateArrow s a b -> IOStateArrow s a b
    localSysVar sel :: Selector XIOSysState c
    sel f :: IOStateArrow s a b
    f               = (XIOState s -> a -> IO (XIOState s, [b])) -> IOStateArrow s a b
    forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
    IOSLA ((XIOState s -> a -> IO (XIOState s, [b])) -> IOStateArrow s a b)
    -> (XIOState s -> a -> IO (XIOState s, [b])) -> IOStateArrow s a b
    forall a b. (a -> b) -> a -> b
    $ \ s0 :: XIOState s
    s0 v :: a
    v ->
                                      let sel' :: Selector (XIOState us) c
    sel' = Selector (XIOState us) XIOSysState
    forall us. Selector (XIOState us) XIOSysState
    theSysState Selector (XIOState us) XIOSysState
    -> Selector XIOSysState c -> Selector (XIOState us) c
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> Selector XIOSysState c
    sel in
                                      let c0 :: c
    c0   = Selector (XIOState s) c -> XIOState s -> c
    forall s a. Selector s a -> s -> a
    getS Selector (XIOState s) c
    forall us. Selector (XIOState us) c
    sel' XIOState s
    s0 in
                                      do
                                      (s1 :: XIOState s
    s1, res :: [b]
    res) <- IOStateArrow s a b -> XIOState s -> a -> IO (XIOState s, [b])
    forall s a b. IOSLA s a b -> s -> a -> IO (s, [b])
    runIOSLA IOStateArrow s a b
    f XIOState s
    s0 a
    v
                                      (XIOState s, [b]) -> IO (XIOState s, [b])
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Selector (XIOState s) c -> c -> XIOState s -> XIOState s
    forall s a. Selector s a -> a -> s -> s
    setS Selector (XIOState s) c
    forall us. Selector (XIOState us) c
    sel' c
    c0 XIOState s
    s1, [b]
    res)

    localSysEnv                     :: IOStateArrow s a b -> IOStateArrow s a b
    localSysEnv :: IOStateArrow s a b -> IOStateArrow s a b
    localSysEnv                     = Selector XIOSysState XIOSysEnv
    -> IOStateArrow s a b -> IOStateArrow s a b
    forall c s a b.
    Selector XIOSysState c -> IOStateArrow s a b -> IOStateArrow s a b
    localSysVar Selector XIOSysState XIOSysEnv
    theSysEnv

    incrSysVar                      :: Selector XIOSysState Int -> IOStateArrow s a Int
    incrSysVar :: Selector XIOSysState Int -> IOStateArrow s a Int
    incrSysVar cnt :: Selector XIOSysState Int
    cnt                  = Selector XIOSysState Int -> IOStateArrow s a Int
    forall c s b. Selector XIOSysState c -> IOStateArrow s b c
    getSysVar Selector XIOSysState Int
    cnt
                                      IOStateArrow s a Int
    -> IOSLA (XIOState s) Int Int -> IOStateArrow s a Int
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      (Int -> Int) -> IOSLA (XIOState s) Int Int
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr (Int -> Int -> Int
    forall a. Num a => a -> a -> a
    +1)
                                      IOSLA (XIOState s) Int Int
    -> IOSLA (XIOState s) Int Int -> IOSLA (XIOState s) Int Int
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      Selector XIOSysState Int -> IOSLA (XIOState s) Int Int
    forall c s. Selector XIOSysState c -> IOStateArrow s c c
    setSysVar Selector XIOSysState Int
    cnt
                                      IOSLA (XIOState s) Int Int
    -> IOSLA (XIOState s) Int Int -> IOSLA (XIOState s) Int Int
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                      (Int -> Int) -> IOSLA (XIOState s) Int Int
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr (\ x :: Int
    x -> Int
    x Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - 1)

    -- ------------------------------

    -- | store a string in global state under a given attribute name

    setSysAttr              :: String -> IOStateArrow s String String
    setSysAttr :: String -> IOStateArrow s String String
    setSysAttr n :: String
    n            = Selector XIOSysState Attributes
    -> (String -> Attributes -> Attributes)
    -> IOStateArrow s String String
    forall c b s.
    Selector XIOSysState c -> (b -> c -> c) -> IOStateArrow s b b
    chgSysVar Selector XIOSysState Attributes
    theAttrList (String -> String -> Attributes -> Attributes
    forall k v. Eq k => k -> v -> AssocList k v -> AssocList k v
    addEntry String
    n)

    -- | remove an entry in global state, arrow input remains unchanged

    unsetSysAttr            :: String -> IOStateArrow s b b
    unsetSysAttr :: String -> IOStateArrow s b b
    unsetSysAttr n :: String
    n            = (XIOSysState -> XIOSysState) -> IOStateArrow s b b
    forall s c. (XIOSysState -> XIOSysState) -> IOStateArrow s c c
    configSysVar ((XIOSysState -> XIOSysState) -> IOStateArrow s b b)
    -> (XIOSysState -> XIOSysState) -> IOStateArrow s b b
    forall a b. (a -> b) -> a -> b
    $ Selector XIOSysState Attributes
    -> (Attributes -> Attributes) -> XIOSysState -> XIOSysState
    forall s a. Selector s a -> (a -> a) -> s -> s
    chgS Selector XIOSysState Attributes
    theAttrList (String -> Attributes -> Attributes
    forall k v. Eq k => k -> AssocList k v -> AssocList k v
    delEntry String
    n)

    -- | read an attribute value from global state

    getSysAttr                :: String -> IOStateArrow s b String
    getSysAttr :: String -> IOStateArrow s b String
    getSysAttr n :: String
    n              = Selector XIOSysState Attributes -> IOStateArrow s b Attributes
    forall c s b. Selector XIOSysState c -> IOStateArrow s b c
    getSysVar Selector XIOSysState Attributes
    theAttrList
                              IOStateArrow s b Attributes
    -> (Attributes -> String) -> IOStateArrow s b String
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^
                              String -> Attributes -> String
    forall k e. Eq k => k -> AssocList k [e] -> [e]
    lookup1 String
    n

    -- | read all attributes from global state

    getAllSysAttrs            :: IOStateArrow s b Attributes
    getAllSysAttrs :: IOStateArrow s b Attributes
    getAllSysAttrs            = Selector XIOSysState Attributes -> IOStateArrow s b Attributes
    forall c s b. Selector XIOSysState c -> IOStateArrow s b c
    getSysVar Selector XIOSysState Attributes
    theAttrList

    setSysAttrString        :: String -> String -> IOStateArrow s b b
    setSysAttrString :: String -> String -> IOStateArrow s b b
    setSysAttrString n :: String
    n v :: String
    v    = IOSLA (XIOState s) b String -> IOStateArrow s b b
    forall (a :: * -> * -> *) b c. ArrowList a => a b c -> a b b
    perform ( String -> IOSLA (XIOState s) b String
    forall (a :: * -> * -> *) c b. ArrowList a => c -> a b c
    constA String
    v
                                        IOSLA (XIOState s) b String
    -> IOSLA (XIOState s) String String -> IOSLA (XIOState s) b String
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
                                        String -> IOSLA (XIOState s) String String
    forall s. String -> IOStateArrow s String String
    setSysAttr String
    n
                                      )

    -- | store an int value in global state

    setSysAttrInt           :: String -> Int -> IOStateArrow s b b
    setSysAttrInt :: String -> Int -> IOStateArrow s b b
    setSysAttrInt n :: String
    n v :: Int
    v       = String -> String -> IOStateArrow s b b
    forall s b. String -> String -> IOStateArrow s b b
    setSysAttrString String
    n (Int -> String
    forall a. Show a => a -> String
    show Int
    v)

    -- | read an int value from global state
    --
    -- > getSysAttrInt 0 myIntAttr

    getSysAttrInt           :: Int -> String -> IOStateArrow s b Int
    getSysAttrInt :: Int -> String -> IOStateArrow s b Int
    getSysAttrInt def :: Int
    def n :: String
    n     = String -> IOStateArrow s b String
    forall s b. String -> IOStateArrow s b String
    getSysAttr String
    n
                              IOStateArrow s b String -> (String -> Int) -> IOStateArrow s b Int
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^
                              Int -> String -> Int
    toInt Int
    def

    toInt                   :: Int -> String -> Int
    toInt :: Int -> String -> Int
    toInt def :: Int
    def s :: String
    s
        | Bool -> Bool
    not (String -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null String
    s)
          Bool -> Bool -> Bool
    &&
          (Char -> Bool) -> String -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all Char -> Bool
    isDigit String
    s     = String -> Int
    forall a. Read a => String -> a
    read String
    s
        | Bool
    otherwise         = Int
    def

    -- ------------------------------------------------------------