{-# language MagicHash #-}
module XML (module XML, module X) where
import Xeno.DOM as X
import Xeno.Types as X
import Data.Function as X ((&))
import Data.List as X (find)
import qualified Data.Map as Map
import Data.Map (Map, (!))
import Data.ByteString (ByteString)
import qualified Data.ByteString.Char8 as BS

class XML a where
  fromXML :: Node -> a
  toXML :: a -> String

just# :: Maybe a -> a
just# :: Maybe a -> a
just# = \case Just a
a -> a
a; Maybe a
_ -> [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"just# Nothing"
find# :: ByteString -> t Node -> c
find# ByteString
n t Node
x = Node -> c
forall a. XML a => Node -> a
fromXML (Node -> c) -> (Maybe Node -> Node) -> Maybe Node -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Node -> Node
forall a. Maybe a -> a
just# (Maybe Node -> c) -> Maybe Node -> c
forall a b. (a -> b) -> a -> b
$ t Node
x t Node -> (t Node -> Maybe Node) -> Maybe Node
forall a b. a -> (a -> b) -> b
& (Node -> Bool) -> t Node -> Maybe Node
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find \ Node
a -> Node -> ByteString
name Node
a ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
n 
find' :: ByteString -> [Node] -> [b]
find' ByteString
n [Node]
x = (Node -> b) -> [Node] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Node -> b
forall a. XML a => Node -> a
fromXML ([Node] -> [b]) -> [Node] -> [b]
forall a b. (a -> b) -> a -> b
$ [Node]
x [Node] -> ([Node] -> [Node]) -> [Node]
forall a b. a -> (a -> b) -> b
& (Node -> Bool) -> [Node] -> [Node]
forall a. (a -> Bool) -> [a] -> [a]
filter \ Node
a -> Node -> ByteString
name Node
a ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
n 

pattern XML :: ByteString ->  Map ByteString ByteString ->  [Node] -> Node
pattern $mXML :: forall r.
Node
-> (ByteString -> Map ByteString ByteString -> [Node] -> r)
-> (Void# -> r)
-> r
XML {Node -> ByteString
xml_name, Node -> Map ByteString ByteString
xml_attributes , Node -> [Node]
xml_children}
  <- ((\n -> (name n
             , Map.fromList $ attributes n
             , children n)) -> (xml_name,xml_attributes,xml_children))

readBS :: Read a => ByteString -> a
readBS :: ByteString -> a
readBS = [Char] -> a
forall a. Read a => [Char] -> a
read ([Char] -> a) -> (ByteString -> [Char]) -> ByteString -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Char]
BS.unpack