-- | construct data object from XML tree.

{-# language NoMonomorphismRestriction, PatternSignatures, OverloadedStrings
  , BangPatterns
#-}


module TPDB.XTC.Read (readProblemF, readProblemT ) where

import TPDB.Data
import TPDB.Data.Attributes

import Text.XML
import Text.XML.Cursor
import qualified Data.Text as ST
import qualified Data.Text.Lazy as LT
import qualified Data.Text.Lazy.IO as LT
import Data.String
import Control.Monad.Catch
import Data.Monoid ((<>))

readProblemF :: FilePath -> IO ( Problem Identifier Identifier )
readProblemF :: FilePath -> IO (Problem Identifier Identifier)
readProblemF FilePath
file = do
  Document
doc <- ParseSettings -> FilePath -> IO Document
Text.XML.readFile ParseSettings
forall a. Default a => a
Text.XML.def FilePath
file
  case Cursor -> [Problem Identifier Identifier]
getProblem (Cursor -> [Problem Identifier Identifier])
-> Cursor -> [Problem Identifier Identifier]
forall a b. (a -> b) -> a -> b
$ Document -> Cursor
fromDocument Document
doc of
    [] -> FilePath -> IO (Problem Identifier Identifier)
forall a. HasCallStack => FilePath -> a
error FilePath
"input contains no XTC problem"
    [Problem Identifier Identifier
p] -> Problem Identifier Identifier -> IO (Problem Identifier Identifier)
forall (m :: * -> *) a. Monad m => a -> m a
return Problem Identifier Identifier
p
    [Problem Identifier Identifier]
ps -> FilePath -> IO (Problem Identifier Identifier)
forall a. HasCallStack => FilePath -> a
error FilePath
"input contains more than one XTC problem"

readProblemT :: LT.Text -> Either SomeException (Problem Identifier Identifier)
readProblemT :: Text -> Either SomeException (Problem Identifier Identifier)
readProblemT Text
t = case ( Cursor -> [Problem Identifier Identifier]
getProblem (Cursor -> [Problem Identifier Identifier])
-> (Document -> Cursor)
-> Document
-> [Problem Identifier Identifier]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Document -> Cursor
fromDocument ) (Document -> [Problem Identifier Identifier])
-> Either SomeException Document
-> Either SomeException [Problem Identifier Identifier]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParseSettings -> Text -> Either SomeException Document
Text.XML.parseText ParseSettings
forall a. Default a => a
Text.XML.def Text
t of
  Right [ Problem Identifier Identifier
p ] -> Problem Identifier Identifier
-> Either SomeException (Problem Identifier Identifier)
forall a b. b -> Either a b
Right Problem Identifier Identifier
p
  Left SomeException
ex -> SomeException
-> Either SomeException (Problem Identifier Identifier)
forall a b. a -> Either a b
Left SomeException
ex


getProblem :: Cursor -> [ Problem Identifier Identifier ]
getProblem :: Cursor -> [Problem Identifier Identifier]
getProblem = Name -> Axis
element Name
"problem" Axis
-> (Cursor -> [Problem Identifier Identifier])
-> Cursor
-> [Problem Identifier Identifier]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> \ Cursor
c -> do
    let !ty :: Type
ty = case Cursor
c Cursor -> (Cursor -> [Text]) -> [Text]
forall node a. Cursor node -> (Cursor node -> a) -> a
$| Name -> Cursor -> [Text]
attribute Name
"type" of
         [ Text
"termination" ] -> Type
Termination
         [ Text
"complexity"  ] -> Type
Complexity
         [Text]
_ -> FilePath -> Type
forall a. HasCallStack => FilePath -> a
error FilePath
"type"
    let !st :: Maybe Strategy
st = case Cursor
c Cursor -> (Cursor -> [Text]) -> [Text]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"strategy" Axis -> (Cursor -> [Text]) -> Cursor -> [Text]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Cursor -> [Text]
content of
         [ Text
"FULL" ]      -> Strategy -> Maybe Strategy
forall a. a -> Maybe a
Just Strategy
Full
         [ Text
"INNERMOST" ] -> Strategy -> Maybe Strategy
forall a. a -> Maybe a
Just Strategy
Innermost
         [ Text
"OUTERMOST" ] -> Strategy -> Maybe Strategy
forall a. a -> Maybe a
Just Strategy
Outermost
         [] -> Maybe Strategy
forall a. Maybe a
Nothing
         [Text]
_ -> FilePath -> Maybe Strategy
forall a. HasCallStack => FilePath -> a
error FilePath
"strategy"
    RS Identifier (Term Identifier Identifier)
rs <- Cursor
c Cursor
-> (Cursor -> [RS Identifier (Term Identifier Identifier)])
-> [RS Identifier (Term Identifier Identifier)]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"trs" Axis
-> (Cursor -> [RS Identifier (Term Identifier Identifier)])
-> Cursor
-> [RS Identifier (Term Identifier Identifier)]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor -> [RS Identifier (Term Identifier Identifier)]
getTRS         
    let stt :: [Startterm]
stt = Cursor
c Cursor -> (Cursor -> [Startterm]) -> [Startterm]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"startterm" Axis -> (Cursor -> [Startterm]) -> Cursor -> [Startterm]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Cursor -> [Startterm]
getStartterm
    Signature
sig <- Cursor
c Cursor -> (Cursor -> [Signature]) -> [Signature]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"trs" Axis -> (Cursor -> [Signature]) -> Cursor -> [Signature]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor -> [Signature]
getSignature 
    Problem Identifier Identifier -> [Problem Identifier Identifier]
forall (m :: * -> *) a. Monad m => a -> m a
return (Problem Identifier Identifier -> [Problem Identifier Identifier])
-> Problem Identifier Identifier -> [Problem Identifier Identifier]
forall a b. (a -> b) -> a -> b
$ Problem :: forall v s.
Type
-> TRS v s
-> Maybe Strategy
-> Signature
-> Maybe Startterm
-> Attributes
-> Problem v s
Problem { trs :: RS Identifier (Term Identifier Identifier)
trs = RS Identifier (Term Identifier Identifier)
rs
                        , strategy :: Maybe Strategy
TPDB.Data.strategy = Maybe Strategy
st
                        , full_signature :: Signature
TPDB.Data.full_signature = Signature
sig
                        , type_ :: Type
type_ = Type
ty
                        , startterm :: Maybe Startterm
startterm = case [Startterm]
stt of
                             [] -> Maybe Startterm
forall a. Maybe a
Nothing
                             [Startterm
x] -> Startterm -> Maybe Startterm
forall a. a -> Maybe a
Just Startterm
x
                        , attributes :: Attributes
attributes = [Rule (Term Identifier Identifier)] -> Attributes
forall v c. (Ord v, Ord c) => [Rule (Term v c)] -> Attributes
compute_attributes ([Rule (Term Identifier Identifier)] -> Attributes)
-> [Rule (Term Identifier Identifier)] -> Attributes
forall a b. (a -> b) -> a -> b
$ RS Identifier (Term Identifier Identifier)
-> [Rule (Term Identifier Identifier)]
forall s r. RS s r -> [Rule r]
rules RS Identifier (Term Identifier Identifier)
rs
                        }

getTerm :: Cursor -> [ Term Identifier Identifier ]
getTerm :: Cursor -> [Term Identifier Identifier]
getTerm = Cursor -> [Term Identifier Identifier]
getVar (Cursor -> [Term Identifier Identifier])
-> (Cursor -> [Term Identifier Identifier])
-> Cursor
-> [Term Identifier Identifier]
forall a. Semigroup a => a -> a -> a
<> Cursor -> [Term Identifier Identifier]
getFunApp

getVar :: Cursor -> [ Term Identifier Identifier ]
getVar :: Cursor -> [Term Identifier Identifier]
getVar = Name -> Axis
element Name
"var" Axis
-> (Cursor -> [Term Identifier Identifier])
-> Cursor
-> [Term Identifier Identifier]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ \ Cursor
c -> ( Identifier -> Term Identifier Identifier
forall v s. v -> Term v s
Var (Identifier -> Term Identifier Identifier)
-> (Text -> Identifier) -> Text -> Term Identifier Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text -> Identifier
mk Int
0 ) (Text -> Term Identifier Identifier)
-> [Text] -> [Term Identifier Identifier]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cursor -> [Text]
content Cursor
c

getFunApp :: Cursor -> [ Term Identifier Identifier ]
getFunApp :: Cursor -> [Term Identifier Identifier]
getFunApp = Name -> Axis
element Name
"funapp" Axis
-> (Cursor -> [Term Identifier Identifier])
-> Cursor
-> [Term Identifier Identifier]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> \ Cursor
c -> do
  Text
nm <- Cursor
c Cursor -> (Cursor -> [Text]) -> [Text]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"name" Axis -> (Cursor -> [Text]) -> Cursor -> [Text]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Cursor -> [Text]
content
  let args :: [Term Identifier Identifier]
args = Cursor
c Cursor
-> (Cursor -> [Term Identifier Identifier])
-> [Term Identifier Identifier]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"arg" Axis
-> (Cursor -> [Term Identifier Identifier])
-> Cursor
-> [Term Identifier Identifier]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Cursor -> [Term Identifier Identifier]
getTerm
      f :: Identifier
f = Int -> Text -> Identifier
mk ([Term Identifier Identifier] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Term Identifier Identifier]
args) (Text -> Identifier) -> Text -> Identifier
forall a b. (a -> b) -> a -> b
$ Text
nm
  Term Identifier Identifier -> [Term Identifier Identifier]
forall (m :: * -> *) a. Monad m => a -> m a
return (Term Identifier Identifier -> [Term Identifier Identifier])
-> Term Identifier Identifier -> [Term Identifier Identifier]
forall a b. (a -> b) -> a -> b
$ Identifier
-> [Term Identifier Identifier] -> Term Identifier Identifier
forall v s. s -> [Term v s] -> Term v s
Node Identifier
f [Term Identifier Identifier]
args
          

        

getStartterm :: Cursor -> [Startterm]
getStartterm =
     (Name -> Axis
element Name
"constructor-based" Axis -> (Cursor -> Startterm) -> Cursor -> [Startterm]
forall node a b.
(Cursor node -> [a]) -> (a -> b) -> Cursor node -> [b]
&| Startterm -> Cursor -> Startterm
forall a b. a -> b -> a
const  Startterm
Startterm_Constructor_based )
  (Cursor -> [Startterm])
-> (Cursor -> [Startterm]) -> Cursor -> [Startterm]
forall a. Semigroup a => a -> a -> a
<> (Name -> Axis
element Name
"full" Axis -> (Cursor -> Startterm) -> Cursor -> [Startterm]
forall node a b.
(Cursor node -> [a]) -> (a -> b) -> Cursor node -> [b]
&| Startterm -> Cursor -> Startterm
forall a b. a -> b -> a
const Startterm
Startterm_Full   ) 

getTRS :: Cursor -> [RS Identifier (Term Identifier Identifier)]
getTRS Cursor
c = do
    Signature
sig <- Cursor -> [Signature]
getSignature Cursor
c
    let str :: [[Rule (Term Identifier Identifier)]]
str   = Cursor
c Cursor
-> (Cursor -> [[Rule (Term Identifier Identifier)]])
-> [[Rule (Term Identifier Identifier)]]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"rules" Axis
-> (Cursor -> [[Rule (Term Identifier Identifier)]])
-> Cursor
-> [[Rule (Term Identifier Identifier)]]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Relation -> Cursor -> [[Rule (Term Identifier Identifier)]]
forall (m :: * -> *).
Monad m =>
Relation -> Cursor -> m [Rule (Term Identifier Identifier)]
getRulesWith Relation
Strict 
        nostr :: [[Rule (Term Identifier Identifier)]]
nostr = Cursor
c Cursor
-> (Cursor -> [[Rule (Term Identifier Identifier)]])
-> [[Rule (Term Identifier Identifier)]]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"rules" Axis
-> (Cursor -> [[Rule (Term Identifier Identifier)]])
-> Cursor
-> [[Rule (Term Identifier Identifier)]]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ ( Name -> Axis
element Name
"relrules" Axis
-> (Cursor -> [[Rule (Term Identifier Identifier)]])
-> Cursor
-> [[Rule (Term Identifier Identifier)]]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Relation -> Cursor -> [[Rule (Term Identifier Identifier)]]
forall (m :: * -> *).
Monad m =>
Relation -> Cursor -> m [Rule (Term Identifier Identifier)]
getRulesWith Relation
Weak )
    -- FIXME: check that symbols are use with correct arity
    RS Identifier (Term Identifier Identifier)
-> [RS Identifier (Term Identifier Identifier)]
forall (m :: * -> *) a. Monad m => a -> m a
return (RS Identifier (Term Identifier Identifier)
 -> [RS Identifier (Term Identifier Identifier)])
-> RS Identifier (Term Identifier Identifier)
-> [RS Identifier (Term Identifier Identifier)]
forall a b. (a -> b) -> a -> b
$ RS :: forall s r. [s] -> [Rule r] -> Bool -> RS s r
RS { signature :: [Identifier]
signature = case Signature
sig of
                       Signature [Funcsym]
fs -> do Funcsym
f <- [Funcsym]
fs ; Identifier -> [Identifier]
forall (m :: * -> *) a. Monad m => a -> m a
return (Identifier -> [Identifier]) -> Identifier -> [Identifier]
forall a b. (a -> b) -> a -> b
$ Int -> Text -> Identifier
mk (Funcsym -> Int
fs_arity Funcsym
f) ( Funcsym -> Text
fs_name Funcsym
f)
                       HigherOrderSignature {} -> []
                  , rules :: [Rule (Term Identifier Identifier)]
rules = [[Rule (Term Identifier Identifier)]]
-> [Rule (Term Identifier Identifier)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Rule (Term Identifier Identifier)]]
str [Rule (Term Identifier Identifier)]
-> [Rule (Term Identifier Identifier)]
-> [Rule (Term Identifier Identifier)]
forall a. [a] -> [a] -> [a]
++ [[Rule (Term Identifier Identifier)]]
-> [Rule (Term Identifier Identifier)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Rule (Term Identifier Identifier)]]
nostr
                  , separate :: Bool
separate = Bool
False -- for TRS, don't need comma between rules
                  }

getSignature :: Cursor -> [Signature]
getSignature Cursor
c =  ( Cursor
c Cursor -> (Cursor -> [Signature]) -> [Signature]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"signature" Axis -> (Cursor -> [Signature]) -> Cursor -> [Signature]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor -> [Signature]
forall (m :: * -> *). Monad m => Cursor -> m Signature
getFOSignature  )
  [Signature] -> [Signature] -> [Signature]
forall a. Semigroup a => a -> a -> a
<> ( Cursor
c Cursor -> (Cursor -> [Signature]) -> [Signature]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"higherOrderSignature" Axis -> (Cursor -> Signature) -> Cursor -> [Signature]
forall node a b.
(Cursor node -> [a]) -> (a -> b) -> Cursor node -> [b]
&| Signature -> Cursor -> Signature
forall a b. a -> b -> a
const Signature
HigherOrderSignature )

getFOSignature :: Cursor -> m Signature
getFOSignature Cursor
c =
  Signature -> m Signature
forall (m :: * -> *) a. Monad m => a -> m a
return (Signature -> m Signature) -> Signature -> m Signature
forall a b. (a -> b) -> a -> b
$ [Funcsym] -> Signature
Signature ( Cursor
c Cursor -> (Cursor -> [Funcsym]) -> [Funcsym]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"funcsym" Axis -> (Cursor -> [Funcsym]) -> Cursor -> [Funcsym]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor -> [Funcsym]
getFuncsym )

getFuncsym :: Cursor -> [Funcsym]
getFuncsym Cursor
c = do
    Text
nm <- Cursor
c Cursor -> (Cursor -> [Text]) -> [Text]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"name" Axis -> (Cursor -> [Text]) -> Cursor -> [Text]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Cursor -> [Text]
content
    Int
ar <- Cursor
c Cursor -> (Cursor -> [Int]) -> [Int]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"arity" Axis -> (Cursor -> [Int]) -> Cursor -> [Int]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Cursor -> [Int]
forall b. Read b => Cursor -> [b]
read_content
    let th :: [a]
th = Cursor
c Cursor -> (Cursor -> [a]) -> [a]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"theory" Axis -> (Cursor -> [a]) -> Cursor -> [a]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Cursor -> [a]
forall b. Read b => Cursor -> [b]
read_content
        rm :: [[a]]
rm = Cursor
c Cursor -> (Cursor -> [[a]]) -> [[a]]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"replacementmap" Axis -> (Cursor -> [[a]]) -> Cursor -> [[a]]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> \ Cursor
c ->
          [a] -> [[a]]
forall (m :: * -> *) a. Monad m => a -> m a
return ([a] -> [[a]]) -> [a] -> [[a]]
forall a b. (a -> b) -> a -> b
$ Cursor
c Cursor -> (Cursor -> [a]) -> [a]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"entry" Axis -> (Cursor -> [a]) -> Cursor -> [a]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Cursor -> [a]
forall b. Read b => Cursor -> [b]
read_content
    Funcsym -> [Funcsym]
forall (m :: * -> *) a. Monad m => a -> m a
return (Funcsym -> [Funcsym]) -> Funcsym -> [Funcsym]
forall a b. (a -> b) -> a -> b
$ Funcsym :: Text -> Int -> Maybe Theory -> Maybe Replacementmap -> Funcsym
Funcsym  { fs_name :: Text
fs_name = Text
nm
                        , fs_arity :: Int
fs_arity = Int
ar
                        , fs_theory :: Maybe Theory
fs_theory = case [Theory]
forall a. Read a => [a]
th of [] -> Maybe Theory
forall a. Maybe a
Nothing ; [Theory
t] -> Theory -> Maybe Theory
forall a. a -> Maybe a
Just Theory
t
                        , fs_replacementmap :: Maybe Replacementmap
fs_replacementmap = case [[Int]]
forall a. Read a => [[a]]
rm of [] -> Maybe Replacementmap
forall a. Maybe a
Nothing ; [[Int]
r] -> Replacementmap -> Maybe Replacementmap
forall a. a -> Maybe a
Just ([Int] -> Replacementmap
Replacementmap [Int]
r)
                        }

read_content :: Cursor -> [b]
read_content Cursor
c = (FilePath -> b
forall a. Read a => FilePath -> a
read (FilePath -> b) -> (Text -> FilePath) -> Text -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> FilePath
ST.unpack) (Text -> b) -> [Text] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cursor -> [Text]
content Cursor
c

getRulesWith :: Relation -> Cursor -> m [Rule (Term Identifier Identifier)]
getRulesWith Relation
s Cursor
c =
  [Rule (Term Identifier Identifier)]
-> m [Rule (Term Identifier Identifier)]
forall (m :: * -> *) a. Monad m => a -> m a
return ( Cursor
c Cursor
-> (Cursor -> [Rule (Term Identifier Identifier)])
-> [Rule (Term Identifier Identifier)]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ ( Name -> Axis
element Name
"rule" Axis
-> (Cursor -> [Rule (Term Identifier Identifier)])
-> Cursor
-> [Rule (Term Identifier Identifier)]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Relation -> Cursor -> [Rule (Term Identifier Identifier)]
getRule Relation
s ) )

getRule :: Relation -> Cursor -> [ Rule (Term Identifier Identifier) ]
getRule :: Relation -> Cursor -> [Rule (Term Identifier Identifier)]
getRule Relation
s Cursor
c = 
  ( \ Term Identifier Identifier
l Term Identifier Identifier
r -> Rule :: forall a. a -> a -> Relation -> Bool -> Rule a
Rule {lhs :: Term Identifier Identifier
lhs=Term Identifier Identifier
l,relation :: Relation
relation=Relation
s,rhs :: Term Identifier Identifier
rhs=Term Identifier Identifier
r,top :: Bool
top=Bool
False})
    (Term Identifier Identifier
 -> Term Identifier Identifier -> Rule (Term Identifier Identifier))
-> [Term Identifier Identifier]
-> [Term Identifier Identifier
    -> Rule (Term Identifier Identifier)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Cursor
c Cursor
-> (Cursor -> [Term Identifier Identifier])
-> [Term Identifier Identifier]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"lhs" Axis
-> (Cursor -> [Term Identifier Identifier])
-> Cursor
-> [Term Identifier Identifier]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Cursor -> [Term Identifier Identifier]
getTerm) [Term Identifier Identifier -> Rule (Term Identifier Identifier)]
-> [Term Identifier Identifier]
-> [Rule (Term Identifier Identifier)]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Cursor
c Cursor
-> (Cursor -> [Term Identifier Identifier])
-> [Term Identifier Identifier]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element Name
"rhs" Axis
-> (Cursor -> [Term Identifier Identifier])
-> Cursor
-> [Term Identifier Identifier]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Cursor -> [Term Identifier Identifier]
getTerm)