{-# LANGUAGE CPP #-}
{-# LANGUAGE OverloadedStrings #-}
module Swish.Script
(
parseScriptFromText
)
where
import Swish.Datatype (typeMkRules)
import Swish.Monad ( SwishStateIO, SwishStatus(..))
import Swish.Monad (modGraphs, findGraph, findFormula
, modRules, findRule
, modRulesets, findRuleset
, findOpenVarModify, findDatatype
, setInfo, setError, setStatus)
import Swish.Proof (explainProof, showsProof)
import Swish.Rule (Formula(..), Rule(..))
import Swish.Ruleset (makeRuleset, getRulesetRule, getRulesetNamespace, getMaybeContextRule)
import Swish.VarBinding (composeSequence)
import Swish.RDF.Datatype (RDFDatatype)
import Swish.RDF.Ruleset (RDFFormula, RDFRule, RDFRuleset)
import Swish.RDF.Ruleset (makeRDFClosureRule)
import Swish.RDF.Proof (RDFProofStep)
import Swish.RDF.Proof (makeRDFProof, makeRDFProofStep)
import Swish.RDF.VarBinding (RDFVarBindingModify)
import Swish.RDF.GraphShowLines ()
import Swish.RDF.Graph
( RDFGraph, RDFLabel(..)
, NamespaceMap
, setNamespaces
, merge, addGraphs
)
import Swish.RDF.Parser.Utils (whiteSpace, lexeme, symbol, eoln, manyTill)
import Swish.RDF.Parser.N3
( parseAnyfromText
, parseN3
, N3Parser, N3State(..)
, getPrefix
, subgraph
, n3symbol
, quickVariable
, lexUriRef
, newBlankNode
)
import Swish.Namespace (ScopedName, getScopeNamespace)
import Swish.QName (QName, qnameFromURI)
import Swish.RDF.Formatter.N3 (formatGraphAsBuilder)
import Swish.Utils.ListHelpers (flist)
import Text.ParserCombinators.Poly.StateText
import Control.Monad (unless, when, void)
import Control.Monad.State (modify, gets, lift)
#if (!defined(__GLASGOW_HASKELL__)) || (__GLASGOW_HASKELL__ < 710)
import Data.Monoid (Monoid(..))
#endif
#if MIN_VERSION_base(4, 7, 0)
import Data.Functor (($>))
#endif
import Network.URI (URI(..))
import qualified Control.Exception as CE
import qualified Data.Map as M
import qualified Data.Set as S
import qualified Data.Text.Lazy as L
import qualified Data.Text.Lazy.Builder as B
import qualified Data.Text.Lazy.IO as LIO
import qualified System.IO.Error as IO
#if !MIN_VERSION_base(4, 7, 0)
($>) :: Functor f => f a -> b -> f b
($>) = flip (<$)
#endif
parseScriptFromText ::
Maybe QName
-> L.Text
-> Either String [SwishStateIO ()]
parseScriptFromText :: Maybe QName -> Text -> Either [Char] [SwishStateIO ()]
parseScriptFromText = N3Parser [SwishStateIO ()]
-> Maybe QName -> Text -> Either [Char] [SwishStateIO ()]
forall a. N3Parser a -> Maybe QName -> Text -> Either [Char] a
parseAnyfromText N3Parser [SwishStateIO ()]
script
between :: Parser s lbr -> Parser s rbr -> Parser s a -> Parser s a
between :: forall s lbr rbr a.
Parser s lbr -> Parser s rbr -> Parser s a -> Parser s a
between = Parser s lbr -> Parser s rbr -> Parser s a -> Parser s a
forall (p :: * -> *) bra ket a.
PolyParse p =>
p bra -> p ket -> p a -> p a
bracket
n3SymLex :: N3Parser ScopedName
n3SymLex :: N3Parser ScopedName
n3SymLex = N3Parser ScopedName -> N3Parser ScopedName
forall s a. Parser s a -> Parser s a
lexeme N3Parser ScopedName
n3symbol
setTo :: N3Parser ()
setTo :: N3Parser ()
setTo = [Char] -> N3Parser ()
isymbol [Char]
":-"
semicolon :: N3Parser ()
semicolon :: N3Parser ()
semicolon = [Char] -> N3Parser ()
isymbol [Char]
";"
comma :: N3Parser ()
comma :: N3Parser ()
comma = [Char] -> N3Parser ()
isymbol [Char]
","
commentText :: N3Parser String
= N3Parser ()
semicolon N3Parser () -> N3Parser [Char] -> N3Parser [Char]
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> N3Parser [Char]
restOfLine
script :: N3Parser [SwishStateIO ()]
script :: N3Parser [SwishStateIO ()]
script = do
N3Parser ()
forall s. Parser s ()
whiteSpace
[SwishStateIO ()]
scs <- Parser N3State (SwishStateIO ()) -> N3Parser [SwishStateIO ()]
forall a. Parser N3State a -> Parser N3State [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser N3State (SwishStateIO ())
command
N3Parser ()
forall s. Parser s ()
eof
[SwishStateIO ()] -> N3Parser [SwishStateIO ()]
forall a. a -> Parser N3State a
forall (m :: * -> *) a. Monad m => a -> m a
return [SwishStateIO ()]
scs
isymbol :: String -> N3Parser ()
isymbol :: [Char] -> N3Parser ()
isymbol = N3Parser [Char] -> N3Parser ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (N3Parser [Char] -> N3Parser ())
-> ([Char] -> N3Parser [Char]) -> [Char] -> N3Parser ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> N3Parser [Char]
forall s. [Char] -> Parser s [Char]
symbol
command :: N3Parser (SwishStateIO ())
command :: Parser N3State (SwishStateIO ())
command =
Parser N3State (SwishStateIO ())
prefixLine
Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State (SwishStateIO ())
nameItem
Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State (SwishStateIO ())
readGraph
Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State (SwishStateIO ())
writeGraph
Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State (SwishStateIO ())
mergeGraphs
Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State (SwishStateIO ())
compareGraphs
Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State (SwishStateIO ())
assertEquiv
Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State (SwishStateIO ())
assertMember
Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State (SwishStateIO ())
defineRule
Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State (SwishStateIO ())
defineRuleset
Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State (SwishStateIO ())
defineConstraints
Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State (SwishStateIO ())
checkProofCmd
Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State (SwishStateIO ())
fwdChain
Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State (SwishStateIO ())
bwdChain
prefixLine :: N3Parser (SwishStateIO ())
prefixLine :: Parser N3State (SwishStateIO ())
prefixLine = do
[Char] -> N3Parser ()
isymbol [Char]
"@prefix"
N3Parser ()
getPrefix
N3Parser ()
forall s. Parser s ()
whiteSpace
[Char] -> N3Parser ()
isymbol [Char]
"."
SwishStateIO () -> Parser N3State (SwishStateIO ())
forall a. a -> Parser N3State a
forall (m :: * -> *) a. Monad m => a -> m a
return (SwishStateIO () -> Parser N3State (SwishStateIO ()))
-> SwishStateIO () -> Parser N3State (SwishStateIO ())
forall a b. (a -> b) -> a -> b
$ () -> SwishStateIO ()
forall a. a -> StateT SwishState IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
nameItem :: N3Parser (SwishStateIO ())
nameItem :: Parser N3State (SwishStateIO ())
nameItem =
ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)] -> SwishStateIO ()
ssAddGraph (ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)] -> SwishStateIO ())
-> N3Parser ScopedName
-> Parser
N3State
([SwishStateIO (Either [Char] RDFGraph)] -> SwishStateIO ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> N3Parser ScopedName
n3SymLex Parser
N3State
([SwishStateIO (Either [Char] RDFGraph)] -> SwishStateIO ())
-> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
-> Parser N3State (SwishStateIO ())
forall a b.
Parser N3State (a -> b) -> Parser N3State a -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ([Char] -> N3Parser [Char]
forall s. [Char] -> Parser s [Char]
symbol [Char]
":-" N3Parser [Char]
-> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
-> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
graphOrList)
maybeURI :: N3Parser (Maybe URI)
maybeURI :: N3Parser (Maybe URI)
maybeURI = (URI -> Maybe URI
forall a. a -> Maybe a
Just (URI -> Maybe URI) -> Parser N3State URI -> N3Parser (Maybe URI)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser N3State URI
lexUriRef) N3Parser (Maybe URI)
-> N3Parser (Maybe URI) -> N3Parser (Maybe URI)
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe URI -> N3Parser (Maybe URI)
forall a. a -> Parser N3State a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe URI
forall a. Maybe a
Nothing
readGraph :: N3Parser (SwishStateIO ())
readGraph :: Parser N3State (SwishStateIO ())
readGraph = [Char] -> N3Parser ()
commandName [Char]
"@read" N3Parser ()
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (ScopedName -> Maybe URI -> SwishStateIO ()
ssRead (ScopedName -> Maybe URI -> SwishStateIO ())
-> N3Parser ScopedName
-> Parser N3State (Maybe URI -> SwishStateIO ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> N3Parser ScopedName
n3SymLex Parser N3State (Maybe URI -> SwishStateIO ())
-> N3Parser (Maybe URI) -> Parser N3State (SwishStateIO ())
forall a b.
Parser N3State (a -> b) -> Parser N3State a -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> N3Parser (Maybe URI)
maybeURI)
writeGraph :: N3Parser (SwishStateIO ())
writeGraph :: Parser N3State (SwishStateIO ())
writeGraph =
do { [Char] -> N3Parser ()
commandName [Char]
"@write"
; ScopedName
n <- N3Parser ScopedName
n3SymLex
; let gs :: SwishStateIO (Either [Char] [RDFGraph])
gs = ScopedName -> SwishStateIO (Either [Char] [RDFGraph])
ssGetList ScopedName
n :: SwishStateIO (Either String [RDFGraph])
; Maybe URI
muri <- N3Parser (Maybe URI)
maybeURI
; Maybe URI
-> SwishStateIO (Either [Char] [RDFGraph])
-> [Char]
-> SwishStateIO ()
ssWriteList Maybe URI
muri SwishStateIO (Either [Char] [RDFGraph])
gs ([Char] -> SwishStateIO ())
-> N3Parser [Char] -> Parser N3State (SwishStateIO ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> N3Parser [Char]
commentText
}
mergeGraphs :: N3Parser (SwishStateIO ())
mergeGraphs :: Parser N3State (SwishStateIO ())
mergeGraphs = do
[Char] -> N3Parser ()
commandName [Char]
"@merge"
[SwishStateIO (Either [Char] RDFGraph)]
gs <- Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
graphList
[Char] -> N3Parser ()
isymbol [Char]
"=>"
ScopedName
n <- N3Parser ScopedName
n3SymLex
SwishStateIO () -> Parser N3State (SwishStateIO ())
forall a. a -> Parser N3State a
forall (m :: * -> *) a. Monad m => a -> m a
return (SwishStateIO () -> Parser N3State (SwishStateIO ()))
-> SwishStateIO () -> Parser N3State (SwishStateIO ())
forall a b. (a -> b) -> a -> b
$ ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)] -> SwishStateIO ()
ssMerge ScopedName
n [SwishStateIO (Either [Char] RDFGraph)]
gs
compareGraphs :: N3Parser (SwishStateIO ())
compareGraphs :: Parser N3State (SwishStateIO ())
compareGraphs =
[Char] -> N3Parser ()
commandName [Char]
"@compare" N3Parser ()
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (ScopedName -> ScopedName -> SwishStateIO ()
ssCompare (ScopedName -> ScopedName -> SwishStateIO ())
-> N3Parser ScopedName
-> Parser N3State (ScopedName -> SwishStateIO ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> N3Parser ScopedName
n3SymLex Parser N3State (ScopedName -> SwishStateIO ())
-> N3Parser ScopedName -> Parser N3State (SwishStateIO ())
forall a b.
Parser N3State (a -> b) -> Parser N3State a -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> N3Parser ScopedName
n3SymLex)
assertArgs :: (ScopedName -> ScopedName -> String -> SwishStateIO ())
-> String -> N3Parser (SwishStateIO ())
assertArgs :: (ScopedName -> ScopedName -> [Char] -> SwishStateIO ())
-> [Char] -> Parser N3State (SwishStateIO ())
assertArgs ScopedName -> ScopedName -> [Char] -> SwishStateIO ()
assertFunc [Char]
cName = do
[Char] -> N3Parser ()
commandName ([Char] -> N3Parser ()) -> [Char] -> N3Parser ()
forall a b. (a -> b) -> a -> b
$ Char
'@'Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
:[Char]
cName
ScopedName -> ScopedName -> [Char] -> SwishStateIO ()
assertFunc (ScopedName -> ScopedName -> [Char] -> SwishStateIO ())
-> N3Parser ScopedName
-> Parser N3State (ScopedName -> [Char] -> SwishStateIO ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> N3Parser ScopedName
n3SymLex Parser N3State (ScopedName -> [Char] -> SwishStateIO ())
-> N3Parser ScopedName
-> Parser N3State ([Char] -> SwishStateIO ())
forall a b.
Parser N3State (a -> b) -> Parser N3State a -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> N3Parser ScopedName
n3SymLex Parser N3State ([Char] -> SwishStateIO ())
-> N3Parser [Char] -> Parser N3State (SwishStateIO ())
forall a b.
Parser N3State (a -> b) -> Parser N3State a -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> N3Parser [Char]
commentText
assertEquiv :: N3Parser (SwishStateIO ())
assertEquiv :: Parser N3State (SwishStateIO ())
assertEquiv = (ScopedName -> ScopedName -> [Char] -> SwishStateIO ())
-> [Char] -> Parser N3State (SwishStateIO ())
assertArgs ScopedName -> ScopedName -> [Char] -> SwishStateIO ()
ssAssertEq [Char]
"asserteq"
assertMember :: N3Parser (SwishStateIO ())
assertMember :: Parser N3State (SwishStateIO ())
assertMember = (ScopedName -> ScopedName -> [Char] -> SwishStateIO ())
-> [Char] -> Parser N3State (SwishStateIO ())
assertArgs ScopedName -> ScopedName -> [Char] -> SwishStateIO ()
ssAssertIn [Char]
"assertin"
defineRule :: N3Parser (SwishStateIO ())
defineRule :: Parser N3State (SwishStateIO ())
defineRule =
do { [Char] -> N3Parser ()
commandName [Char]
"@rule"
; ScopedName
rn <- N3Parser ScopedName
n3SymLex
; N3Parser ()
setTo
; [SwishStateIO (Either [Char] RDFGraph)]
ags <- Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
graphOrList
; [Char] -> N3Parser ()
isymbol [Char]
"=>"
; SwishStateIO (Either [Char] RDFGraph)
cg <- N3Parser (SwishStateIO (Either [Char] RDFGraph))
graphExpr
; [(ScopedName, [RDFLabel])]
vms <- N3Parser [(ScopedName, [RDFLabel])]
varModifiers N3Parser [(ScopedName, [RDFLabel])]
-> N3Parser [(ScopedName, [RDFLabel])]
-> N3Parser [(ScopedName, [RDFLabel])]
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [(ScopedName, [RDFLabel])] -> N3Parser [(ScopedName, [RDFLabel])]
forall a. a -> Parser N3State a
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
; SwishStateIO () -> Parser N3State (SwishStateIO ())
forall a. a -> Parser N3State a
forall (m :: * -> *) a. Monad m => a -> m a
return (SwishStateIO () -> Parser N3State (SwishStateIO ()))
-> SwishStateIO () -> Parser N3State (SwishStateIO ())
forall a b. (a -> b) -> a -> b
$ ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)]
-> SwishStateIO (Either [Char] RDFGraph)
-> [(ScopedName, [RDFLabel])]
-> SwishStateIO ()
ssDefineRule ScopedName
rn [SwishStateIO (Either [Char] RDFGraph)]
ags SwishStateIO (Either [Char] RDFGraph)
cg [(ScopedName, [RDFLabel])]
vms
}
defineRuleset :: N3Parser (SwishStateIO ())
defineRuleset :: Parser N3State (SwishStateIO ())
defineRuleset =
[Char] -> N3Parser ()
commandName [Char]
"@ruleset" N3Parser ()
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
(ScopedName -> [ScopedName] -> [ScopedName] -> SwishStateIO ()
ssDefineRuleset (ScopedName -> [ScopedName] -> [ScopedName] -> SwishStateIO ())
-> N3Parser ScopedName
-> Parser N3State ([ScopedName] -> [ScopedName] -> SwishStateIO ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> N3Parser ScopedName
n3SymLex Parser N3State ([ScopedName] -> [ScopedName] -> SwishStateIO ())
-> Parser N3State [ScopedName]
-> Parser N3State ([ScopedName] -> SwishStateIO ())
forall a b.
Parser N3State (a -> b) -> Parser N3State a -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (N3Parser ()
setTo N3Parser ()
-> Parser N3State [ScopedName] -> Parser N3State [ScopedName]
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser N3State [ScopedName]
nameList) Parser N3State ([ScopedName] -> SwishStateIO ())
-> Parser N3State [ScopedName] -> Parser N3State (SwishStateIO ())
forall a b.
Parser N3State (a -> b) -> Parser N3State a -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (N3Parser ()
semicolon N3Parser ()
-> Parser N3State [ScopedName] -> Parser N3State [ScopedName]
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser N3State [ScopedName]
nameList))
defineConstraints :: N3Parser (SwishStateIO ())
defineConstraints :: Parser N3State (SwishStateIO ())
defineConstraints =
[Char] -> N3Parser ()
commandName [Char]
"@constraints" N3Parser ()
-> Parser N3State (SwishStateIO ())
-> Parser N3State (SwishStateIO ())
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
(ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)]
-> [ScopedName]
-> SwishStateIO ()
ssDefineConstraints (ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)]
-> [ScopedName]
-> SwishStateIO ())
-> N3Parser ScopedName
-> Parser
N3State
([SwishStateIO (Either [Char] RDFGraph)]
-> [ScopedName] -> SwishStateIO ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> N3Parser ScopedName
n3SymLex Parser
N3State
([SwishStateIO (Either [Char] RDFGraph)]
-> [ScopedName] -> SwishStateIO ())
-> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
-> Parser N3State ([ScopedName] -> SwishStateIO ())
forall a b.
Parser N3State (a -> b) -> Parser N3State a -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (N3Parser ()
setTo N3Parser ()
-> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
-> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
graphOrList) Parser N3State ([ScopedName] -> SwishStateIO ())
-> Parser N3State [ScopedName] -> Parser N3State (SwishStateIO ())
forall a b.
Parser N3State (a -> b) -> Parser N3State a -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ([Char] -> N3Parser [Char]
forall s. [Char] -> Parser s [Char]
symbol [Char]
"|" N3Parser [Char]
-> Parser N3State [ScopedName] -> Parser N3State [ScopedName]
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser N3State [ScopedName]
nameOrList))
checkProofCmd :: N3Parser (SwishStateIO ())
checkProofCmd :: Parser N3State (SwishStateIO ())
checkProofCmd =
do { [Char] -> N3Parser ()
commandName [Char]
"@proof"
; ScopedName
pn <- N3Parser ScopedName
n3SymLex
; [ScopedName]
sns <- Parser N3State [ScopedName]
nameList
; [Char] -> N3Parser ()
commandName [Char]
"@input"
; SwishStateIO (Either [Char] RDFFormula)
igf <- N3Parser (SwishStateIO (Either [Char] RDFFormula))
formulaExpr
; [Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep)]
sts <- Parser
N3State
(Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep))
-> Parser
N3State
[Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep)]
forall a. Parser N3State a -> Parser N3State [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser
N3State
(Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep))
checkStep
; [Char] -> N3Parser ()
commandName [Char]
"@result"
; ScopedName
-> [ScopedName]
-> SwishStateIO (Either [Char] RDFFormula)
-> [Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep)]
-> SwishStateIO (Either [Char] RDFFormula)
-> SwishStateIO ()
ssCheckProof ScopedName
pn [ScopedName]
sns SwishStateIO (Either [Char] RDFFormula)
igf [Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep)]
sts (SwishStateIO (Either [Char] RDFFormula) -> SwishStateIO ())
-> N3Parser (SwishStateIO (Either [Char] RDFFormula))
-> Parser N3State (SwishStateIO ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> N3Parser (SwishStateIO (Either [Char] RDFFormula))
formulaExpr
}
checkStep ::
N3Parser (Either String [RDFRuleset]
-> SwishStateIO (Either String RDFProofStep))
checkStep :: Parser
N3State
(Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep))
checkStep =
[Char] -> N3Parser ()
commandName [Char]
"@step" N3Parser ()
-> Parser
N3State
(Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep))
-> Parser
N3State
(Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep))
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
(ScopedName
-> [SwishStateIO (Either [Char] RDFFormula)]
-> SwishStateIO (Either [Char] RDFFormula)
-> Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep)
ssCheckStep (ScopedName
-> [SwishStateIO (Either [Char] RDFFormula)]
-> SwishStateIO (Either [Char] RDFFormula)
-> Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep))
-> N3Parser ScopedName
-> Parser
N3State
([SwishStateIO (Either [Char] RDFFormula)]
-> SwishStateIO (Either [Char] RDFFormula)
-> Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> N3Parser ScopedName
n3SymLex Parser
N3State
([SwishStateIO (Either [Char] RDFFormula)]
-> SwishStateIO (Either [Char] RDFFormula)
-> Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep))
-> Parser N3State [SwishStateIO (Either [Char] RDFFormula)]
-> Parser
N3State
(SwishStateIO (Either [Char] RDFFormula)
-> Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep))
forall a b.
Parser N3State (a -> b) -> Parser N3State a -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser N3State [SwishStateIO (Either [Char] RDFFormula)]
formulaList Parser
N3State
(SwishStateIO (Either [Char] RDFFormula)
-> Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep))
-> N3Parser (SwishStateIO (Either [Char] RDFFormula))
-> Parser
N3State
(Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep))
forall a b.
Parser N3State (a -> b) -> Parser N3State a -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ([Char] -> N3Parser [Char]
forall s. [Char] -> Parser s [Char]
symbol [Char]
"=>" N3Parser [Char]
-> N3Parser (SwishStateIO (Either [Char] RDFFormula))
-> N3Parser (SwishStateIO (Either [Char] RDFFormula))
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> N3Parser (SwishStateIO (Either [Char] RDFFormula))
formulaExpr))
fwdChain :: N3Parser (SwishStateIO ())
fwdChain :: Parser N3State (SwishStateIO ())
fwdChain =
do { [Char] -> N3Parser ()
commandName [Char]
"@fwdchain"
; ScopedName
sn <- N3Parser ScopedName
n3SymLex
; ScopedName
rn <- N3Parser ScopedName
n3SymLex
; [SwishStateIO (Either [Char] RDFGraph)]
ags <- Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
graphOrList
; [Char] -> N3Parser ()
isymbol [Char]
"=>"
; ScopedName
cn <- N3Parser ScopedName
n3SymLex
; N3State
s <- Parser N3State N3State
forall s. Parser s s
stGet
; let prefs :: NamespaceMap
prefs = N3State -> NamespaceMap
prefixUris N3State
s
; SwishStateIO () -> Parser N3State (SwishStateIO ())
forall a. a -> Parser N3State a
forall (m :: * -> *) a. Monad m => a -> m a
return (SwishStateIO () -> Parser N3State (SwishStateIO ()))
-> SwishStateIO () -> Parser N3State (SwishStateIO ())
forall a b. (a -> b) -> a -> b
$ ScopedName
-> ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)]
-> ScopedName
-> NamespaceMap
-> SwishStateIO ()
ssFwdChain ScopedName
sn ScopedName
rn [SwishStateIO (Either [Char] RDFGraph)]
ags ScopedName
cn NamespaceMap
prefs
}
bwdChain :: N3Parser (SwishStateIO ())
bwdChain :: Parser N3State (SwishStateIO ())
bwdChain =
do { [Char] -> N3Parser ()
commandName [Char]
"@bwdchain"
; ScopedName
sn <- N3Parser ScopedName
n3SymLex
; ScopedName
rn <- N3Parser ScopedName
n3SymLex
; SwishStateIO (Either [Char] RDFGraph)
cg <- N3Parser (SwishStateIO (Either [Char] RDFGraph))
graphExpr
; [Char] -> N3Parser ()
isymbol [Char]
"<="
; ScopedName
an <- N3Parser ScopedName
n3SymLex
; N3State
s <- Parser N3State N3State
forall s. Parser s s
stGet
; let prefs :: NamespaceMap
prefs = N3State -> NamespaceMap
prefixUris N3State
s
; SwishStateIO () -> Parser N3State (SwishStateIO ())
forall a. a -> Parser N3State a
forall (m :: * -> *) a. Monad m => a -> m a
return (SwishStateIO () -> Parser N3State (SwishStateIO ()))
-> SwishStateIO () -> Parser N3State (SwishStateIO ())
forall a b. (a -> b) -> a -> b
$ ScopedName
-> ScopedName
-> SwishStateIO (Either [Char] RDFGraph)
-> ScopedName
-> NamespaceMap
-> SwishStateIO ()
ssBwdChain ScopedName
sn ScopedName
rn SwishStateIO (Either [Char] RDFGraph)
cg ScopedName
an NamespaceMap
prefs
}
commandName :: String -> N3Parser ()
commandName :: [Char] -> N3Parser ()
commandName [Char]
cmd = [Char] -> N3Parser [Char]
forall s. [Char] -> Parser s [Char]
symbol [Char]
cmd N3Parser [Char] -> () -> N3Parser ()
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ()
restOfLine :: N3Parser String
restOfLine :: N3Parser [Char]
restOfLine = Parser N3State Char -> N3Parser () -> N3Parser [Char]
forall s a b. Parser s a -> Parser s b -> Parser s [a]
manyTill ((Char -> Bool) -> Parser N3State Char
forall s. (Char -> Bool) -> Parser s Char
satisfy (Bool -> Char -> Bool
forall a b. a -> b -> a
const Bool
True)) N3Parser ()
forall s. Parser s ()
eoln N3Parser [Char] -> N3Parser () -> N3Parser [Char]
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* N3Parser ()
forall s. Parser s ()
whiteSpace
br :: N3Parser a -> N3Parser a
br :: forall a. N3Parser a -> N3Parser a
br = N3Parser [Char]
-> N3Parser [Char] -> Parser N3State a -> Parser N3State a
forall s lbr rbr a.
Parser s lbr -> Parser s rbr -> Parser s a -> Parser s a
between ([Char] -> N3Parser [Char]
forall s. [Char] -> Parser s [Char]
symbol [Char]
"(") ([Char] -> N3Parser [Char]
forall s. [Char] -> Parser s [Char]
symbol [Char]
")")
nameList :: N3Parser [ScopedName]
nameList :: Parser N3State [ScopedName]
nameList = Parser N3State [ScopedName] -> Parser N3State [ScopedName]
forall a. N3Parser a -> N3Parser a
br (Parser N3State [ScopedName] -> Parser N3State [ScopedName])
-> Parser N3State [ScopedName] -> Parser N3State [ScopedName]
forall a b. (a -> b) -> a -> b
$ N3Parser ScopedName -> Parser N3State [ScopedName]
forall a. Parser N3State a -> Parser N3State [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many N3Parser ScopedName
n3SymLex
toList :: a -> [a]
toList :: forall a. a -> [a]
toList = (a -> [a] -> [a]
forall a. a -> [a] -> [a]
:[])
nameOrList :: N3Parser [ScopedName]
nameOrList :: Parser N3State [ScopedName]
nameOrList =
(ScopedName -> [ScopedName]
forall a. a -> [a]
toList (ScopedName -> [ScopedName])
-> N3Parser ScopedName -> Parser N3State [ScopedName]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> N3Parser ScopedName
n3SymLex)
Parser N3State [ScopedName]
-> Parser N3State [ScopedName] -> Parser N3State [ScopedName]
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State [ScopedName]
nameList
graphExpr :: N3Parser (SwishStateIO (Either String RDFGraph))
graphExpr :: N3Parser (SwishStateIO (Either [Char] RDFGraph))
graphExpr =
N3Parser (SwishStateIO (Either [Char] RDFGraph))
graphOnly
N3Parser (SwishStateIO (Either [Char] RDFGraph))
-> N3Parser (SwishStateIO (Either [Char] RDFGraph))
-> N3Parser (SwishStateIO (Either [Char] RDFGraph))
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
(Either [Char] RDFFormula -> Either [Char] RDFGraph)
-> SwishStateIO (Either [Char] RDFFormula)
-> SwishStateIO (Either [Char] RDFGraph)
forall a b.
(a -> b) -> StateT SwishState IO a -> StateT SwishState IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((RDFFormula -> RDFGraph)
-> Either [Char] RDFFormula -> Either [Char] RDFGraph
forall a b. (a -> b) -> Either [Char] a -> Either [Char] b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap RDFFormula -> RDFGraph
forall ex. Formula ex -> ex
formExpr) (SwishStateIO (Either [Char] RDFFormula)
-> SwishStateIO (Either [Char] RDFGraph))
-> N3Parser (SwishStateIO (Either [Char] RDFFormula))
-> N3Parser (SwishStateIO (Either [Char] RDFGraph))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> N3Parser (SwishStateIO (Either [Char] RDFFormula))
formulaExpr
graphOnly :: N3Parser (SwishStateIO (Either String RDFGraph))
graphOnly :: N3Parser (SwishStateIO (Either [Char] RDFGraph))
graphOnly =
do { [Char] -> N3Parser ()
isymbol [Char]
"{"
; RDFLabel
b <- N3Parser RDFLabel
newBlankNode
; RDFGraph
g <- RDFLabel -> N3Parser RDFGraph
subgraph RDFLabel
b
; [Char] -> N3Parser ()
isymbol [Char]
"}"
; N3State
s <- Parser N3State N3State
forall s. Parser s s
stGet
; let gp :: RDFGraph
gp = NamespaceMap -> RDFGraph -> RDFGraph
forall lb. NamespaceMap -> NSGraph lb -> NSGraph lb
setNamespaces (N3State -> NamespaceMap
prefixUris N3State
s) RDFGraph
g
; SwishStateIO (Either [Char] RDFGraph)
-> N3Parser (SwishStateIO (Either [Char] RDFGraph))
forall a. a -> Parser N3State a
forall (m :: * -> *) a. Monad m => a -> m a
return (SwishStateIO (Either [Char] RDFGraph)
-> N3Parser (SwishStateIO (Either [Char] RDFGraph)))
-> SwishStateIO (Either [Char] RDFGraph)
-> N3Parser (SwishStateIO (Either [Char] RDFGraph))
forall a b. (a -> b) -> a -> b
$ Either [Char] RDFGraph -> SwishStateIO (Either [Char] RDFGraph)
forall a. a -> StateT SwishState IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (RDFGraph -> Either [Char] RDFGraph
forall a b. b -> Either a b
Right RDFGraph
gp)
}
graphList :: N3Parser [SwishStateIO (Either String RDFGraph)]
graphList :: Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
graphList = Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
-> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
forall a. N3Parser a -> N3Parser a
br (N3Parser (SwishStateIO (Either [Char] RDFGraph))
-> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
forall a. Parser N3State a -> Parser N3State [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many N3Parser (SwishStateIO (Either [Char] RDFGraph))
graphExpr)
graphOrList :: N3Parser [SwishStateIO (Either String RDFGraph)]
graphOrList :: Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
graphOrList =
(SwishStateIO (Either [Char] RDFGraph)
-> [SwishStateIO (Either [Char] RDFGraph)]
forall a. a -> [a]
toList (SwishStateIO (Either [Char] RDFGraph)
-> [SwishStateIO (Either [Char] RDFGraph)])
-> N3Parser (SwishStateIO (Either [Char] RDFGraph))
-> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> N3Parser (SwishStateIO (Either [Char] RDFGraph))
graphExpr)
Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
-> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
-> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser N3State [SwishStateIO (Either [Char] RDFGraph)]
graphList
formulaExpr :: N3Parser (SwishStateIO (Either String RDFFormula))
formulaExpr :: N3Parser (SwishStateIO (Either [Char] RDFFormula))
formulaExpr = N3Parser ScopedName
n3SymLex N3Parser ScopedName
-> (ScopedName
-> N3Parser (SwishStateIO (Either [Char] RDFFormula)))
-> N3Parser (SwishStateIO (Either [Char] RDFFormula))
forall a b.
Parser N3State a -> (a -> Parser N3State b) -> Parser N3State b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ScopedName -> N3Parser (SwishStateIO (Either [Char] RDFFormula))
namedGraph
namedGraph :: ScopedName -> N3Parser (SwishStateIO (Either String RDFFormula))
namedGraph :: ScopedName -> N3Parser (SwishStateIO (Either [Char] RDFFormula))
namedGraph ScopedName
n =
(ScopedName
-> SwishStateIO (Either [Char] RDFGraph)
-> SwishStateIO (Either [Char] RDFFormula)
ssAddReturnFormula ScopedName
n (SwishStateIO (Either [Char] RDFGraph)
-> SwishStateIO (Either [Char] RDFFormula))
-> N3Parser (SwishStateIO (Either [Char] RDFGraph))
-> N3Parser (SwishStateIO (Either [Char] RDFFormula))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (N3Parser ()
setTo N3Parser ()
-> N3Parser (SwishStateIO (Either [Char] RDFGraph))
-> N3Parser (SwishStateIO (Either [Char] RDFGraph))
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> N3Parser (SwishStateIO (Either [Char] RDFGraph))
graphOnly))
N3Parser (SwishStateIO (Either [Char] RDFFormula))
-> N3Parser (SwishStateIO (Either [Char] RDFFormula))
-> N3Parser (SwishStateIO (Either [Char] RDFFormula))
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> SwishStateIO (Either [Char] RDFFormula)
-> N3Parser (SwishStateIO (Either [Char] RDFFormula))
forall a. a -> Parser N3State a
forall (m :: * -> *) a. Monad m => a -> m a
return (ScopedName -> SwishStateIO (Either [Char] RDFFormula)
ssGetFormula ScopedName
n)
formulaList :: N3Parser [SwishStateIO (Either String RDFFormula)]
formulaList :: Parser N3State [SwishStateIO (Either [Char] RDFFormula)]
formulaList = N3Parser [Char]
-> N3Parser [Char]
-> Parser N3State [SwishStateIO (Either [Char] RDFFormula)]
-> Parser N3State [SwishStateIO (Either [Char] RDFFormula)]
forall s lbr rbr a.
Parser s lbr -> Parser s rbr -> Parser s a -> Parser s a
between ([Char] -> N3Parser [Char]
forall s. [Char] -> Parser s [Char]
symbol [Char]
"(") ([Char] -> N3Parser [Char]
forall s. [Char] -> Parser s [Char]
symbol [Char]
")") (N3Parser (SwishStateIO (Either [Char] RDFFormula))
-> Parser N3State [SwishStateIO (Either [Char] RDFFormula)]
forall a. Parser N3State a -> Parser N3State [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many N3Parser (SwishStateIO (Either [Char] RDFFormula))
formulaExpr)
varModifiers :: N3Parser [(ScopedName,[RDFLabel])]
varModifiers :: N3Parser [(ScopedName, [RDFLabel])]
varModifiers = [Char] -> N3Parser [Char]
forall s. [Char] -> Parser s [Char]
symbol [Char]
"|" N3Parser [Char]
-> N3Parser [(ScopedName, [RDFLabel])]
-> N3Parser [(ScopedName, [RDFLabel])]
forall a b.
Parser N3State a -> Parser N3State b -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> N3Parser [(ScopedName, [RDFLabel])]
varModList
varModList :: N3Parser [(ScopedName,[RDFLabel])]
varModList :: N3Parser [(ScopedName, [RDFLabel])]
varModList =
N3Parser [(ScopedName, [RDFLabel])]
-> N3Parser [(ScopedName, [RDFLabel])]
forall a. N3Parser a -> N3Parser a
br (Parser N3State (ScopedName, [RDFLabel])
-> N3Parser () -> N3Parser [(ScopedName, [RDFLabel])]
forall (p :: * -> *) a sep. PolyParse p => p a -> p sep -> p [a]
sepBy Parser N3State (ScopedName, [RDFLabel])
varMod N3Parser ()
comma)
N3Parser [(ScopedName, [RDFLabel])]
-> N3Parser [(ScopedName, [RDFLabel])]
-> N3Parser [(ScopedName, [RDFLabel])]
forall a. Parser N3State a -> Parser N3State a -> Parser N3State a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (ScopedName, [RDFLabel]) -> [(ScopedName, [RDFLabel])]
forall a. a -> [a]
toList ((ScopedName, [RDFLabel]) -> [(ScopedName, [RDFLabel])])
-> Parser N3State (ScopedName, [RDFLabel])
-> N3Parser [(ScopedName, [RDFLabel])]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser N3State (ScopedName, [RDFLabel])
-> Parser N3State (ScopedName, [RDFLabel])
forall s a. Parser s a -> Parser s a
lexeme Parser N3State (ScopedName, [RDFLabel])
varMod
varMod :: N3Parser (ScopedName,[RDFLabel])
varMod :: Parser N3State (ScopedName, [RDFLabel])
varMod = (,) (ScopedName -> [RDFLabel] -> (ScopedName, [RDFLabel]))
-> N3Parser ScopedName
-> Parser N3State ([RDFLabel] -> (ScopedName, [RDFLabel]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> N3Parser ScopedName
n3SymLex Parser N3State ([RDFLabel] -> (ScopedName, [RDFLabel]))
-> Parser N3State [RDFLabel]
-> Parser N3State (ScopedName, [RDFLabel])
forall a b.
Parser N3State (a -> b) -> Parser N3State a -> Parser N3State b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> N3Parser RDFLabel -> Parser N3State [RDFLabel]
forall a. Parser N3State a -> Parser N3State [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (N3Parser RDFLabel -> N3Parser RDFLabel
forall s a. Parser s a -> Parser s a
lexeme N3Parser RDFLabel
quickVariable)
ssReport ::
String
-> SwishStateIO ()
ssReport :: [Char] -> SwishStateIO ()
ssReport [Char]
msg = (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((SwishState -> SwishState) -> SwishStateIO ())
-> (SwishState -> SwishState) -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> SwishState -> SwishState
setInfo ([Char] -> SwishState -> SwishState)
-> [Char] -> SwishState -> SwishState
forall a b. (a -> b) -> a -> b
$ [Char]
"# " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
msg
ssReportLabel ::
String
-> String
-> SwishStateIO ()
ssReportLabel :: [Char] -> [Char] -> SwishStateIO ()
ssReportLabel [Char]
lbl [Char]
msg = [Char] -> SwishStateIO ()
ssReport ([Char] -> SwishStateIO ()) -> [Char] -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$ [Char]
lbl [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
": " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
msg
ssAddReturnFormula ::
ScopedName -> SwishStateIO (Either String RDFGraph)
-> SwishStateIO (Either String RDFFormula)
ssAddReturnFormula :: ScopedName
-> SwishStateIO (Either [Char] RDFGraph)
-> SwishStateIO (Either [Char] RDFFormula)
ssAddReturnFormula ScopedName
nam SwishStateIO (Either [Char] RDFGraph)
gf =
do { Either [Char] RDFGraph
egr <- SwishStateIO (Either [Char] RDFGraph)
gf
; ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)] -> SwishStateIO ()
ssAddGraph ScopedName
nam [Either [Char] RDFGraph -> SwishStateIO (Either [Char] RDFGraph)
forall a. a -> StateT SwishState IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Either [Char] RDFGraph
egr]
; Either [Char] RDFFormula -> SwishStateIO (Either [Char] RDFFormula)
forall a. a -> StateT SwishState IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either [Char] RDFFormula
-> SwishStateIO (Either [Char] RDFFormula))
-> Either [Char] RDFFormula
-> SwishStateIO (Either [Char] RDFFormula)
forall a b. (a -> b) -> a -> b
$ (RDFGraph -> RDFFormula)
-> Either [Char] RDFGraph -> Either [Char] RDFFormula
forall a b. (a -> b) -> Either [Char] a -> Either [Char] b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ScopedName -> RDFGraph -> RDFFormula
forall ex. ScopedName -> ex -> Formula ex
Formula ScopedName
nam) Either [Char] RDFGraph
egr
}
ssAddGraph ::
ScopedName -> [SwishStateIO (Either String RDFGraph)]
-> SwishStateIO ()
ssAddGraph :: ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)] -> SwishStateIO ()
ssAddGraph ScopedName
nam [SwishStateIO (Either [Char] RDFGraph)]
gf =
let errmsg :: [Char]
errmsg = [Char]
"Graph/list not added: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
nam [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"; "
in
do { [Either [Char] RDFGraph]
esg <- [SwishStateIO (Either [Char] RDFGraph)]
-> StateT SwishState IO [Either [Char] RDFGraph]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [SwishStateIO (Either [Char] RDFGraph)]
gf
; let egs :: Either [Char] [RDFGraph]
egs = [Either [Char] RDFGraph] -> Either [Char] [RDFGraph]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Either [Char] RDFGraph]
esg
; let fgs :: SwishState -> SwishState
fgs = case Either [Char] [RDFGraph]
egs of
Left [Char]
er -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
Right [RDFGraph]
gs -> (NamedGraphMap -> NamedGraphMap) -> SwishState -> SwishState
modGraphs (ScopedName -> [RDFGraph] -> NamedGraphMap -> NamedGraphMap
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert ScopedName
nam [RDFGraph]
gs)
; (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify SwishState -> SwishState
fgs
}
ssGetGraph :: ScopedName -> SwishStateIO (Either String RDFGraph)
ssGetGraph :: ScopedName -> SwishStateIO (Either [Char] RDFGraph)
ssGetGraph ScopedName
nam = do
Either [Char] [RDFGraph]
grs <- ScopedName -> SwishStateIO (Either [Char] [RDFGraph])
ssGetList ScopedName
nam
Either [Char] RDFGraph -> SwishStateIO (Either [Char] RDFGraph)
forall a. a -> StateT SwishState IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either [Char] RDFGraph -> SwishStateIO (Either [Char] RDFGraph))
-> Either [Char] RDFGraph -> SwishStateIO (Either [Char] RDFGraph)
forall a b. (a -> b) -> a -> b
$ case Either [Char] [RDFGraph]
grs of
Left [Char]
emsg -> [Char] -> Either [Char] RDFGraph
forall a b. a -> Either a b
Left [Char]
emsg
Right [] -> [Char] -> Either [Char] RDFGraph
forall a b. a -> Either a b
Left ([Char]
"Graph or list is empty: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
nam)
Right (RDFGraph
gr:[RDFGraph]
_) -> RDFGraph -> Either [Char] RDFGraph
forall a b. b -> Either a b
Right RDFGraph
gr
ssGetFormula :: ScopedName -> SwishStateIO (Either String RDFFormula)
ssGetFormula :: ScopedName -> SwishStateIO (Either [Char] RDFFormula)
ssGetFormula ScopedName
nam = (SwishState -> Either [Char] RDFFormula)
-> SwishStateIO (Either [Char] RDFFormula)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets SwishState -> Either [Char] RDFFormula
find
where
find :: SwishState -> Either [Char] RDFFormula
find SwishState
st = case ScopedName -> SwishState -> Maybe RDFFormula
findFormula ScopedName
nam SwishState
st of
Maybe RDFFormula
Nothing -> [Char] -> Either [Char] RDFFormula
forall a b. a -> Either a b
Left ([Char]
"Formula not present: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
nam)
Just RDFFormula
gr -> RDFFormula -> Either [Char] RDFFormula
forall a b. b -> Either a b
Right RDFFormula
gr
ssGetList :: ScopedName -> SwishStateIO (Either String [RDFGraph])
ssGetList :: ScopedName -> SwishStateIO (Either [Char] [RDFGraph])
ssGetList ScopedName
nam = (SwishState -> Either [Char] [RDFGraph])
-> SwishStateIO (Either [Char] [RDFGraph])
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets SwishState -> Either [Char] [RDFGraph]
find
where
find :: SwishState -> Either [Char] [RDFGraph]
find SwishState
st = case ScopedName -> SwishState -> Maybe [RDFGraph]
findGraph ScopedName
nam SwishState
st of
Maybe [RDFGraph]
Nothing -> [Char] -> Either [Char] [RDFGraph]
forall a b. a -> Either a b
Left ([Char]
"Graph or list not present: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
nam)
Just [RDFGraph]
grs -> [RDFGraph] -> Either [Char] [RDFGraph]
forall a b. b -> Either a b
Right [RDFGraph]
grs
ssRead :: ScopedName -> Maybe URI -> SwishStateIO ()
ssRead :: ScopedName -> Maybe URI -> SwishStateIO ()
ssRead ScopedName
nam Maybe URI
muri = ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)] -> SwishStateIO ()
ssAddGraph ScopedName
nam [Maybe URI -> SwishStateIO (Either [Char] RDFGraph)
ssReadGraph Maybe URI
muri]
ssReadGraph :: Maybe URI -> SwishStateIO (Either String RDFGraph)
ssReadGraph :: Maybe URI -> SwishStateIO (Either [Char] RDFGraph)
ssReadGraph Maybe URI
muri =
let gf :: Either [Char] Text -> Either [Char] RDFGraph
gf Either [Char] Text
inp = case Either [Char] Text
inp of
Left [Char]
es -> [Char] -> Either [Char] RDFGraph
forall a b. a -> Either a b
Left [Char]
es
Right Text
is -> Text -> Maybe QName -> Either [Char] RDFGraph
parseN3 Text
is (Maybe URI
muri Maybe URI -> (URI -> Maybe QName) -> Maybe QName
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= URI -> Maybe QName
qnameFromURI)
in Either [Char] Text -> Either [Char] RDFGraph
gf (Either [Char] Text -> Either [Char] RDFGraph)
-> StateT SwishState IO (Either [Char] Text)
-> SwishStateIO (Either [Char] RDFGraph)
forall a b.
(a -> b) -> StateT SwishState IO a -> StateT SwishState IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Maybe URI -> StateT SwishState IO (Either [Char] Text)
getResourceData Maybe URI
muri
ssWriteList ::
Maybe URI -> SwishStateIO (Either String [RDFGraph]) -> String
-> SwishStateIO ()
ssWriteList :: Maybe URI
-> SwishStateIO (Either [Char] [RDFGraph])
-> [Char]
-> SwishStateIO ()
ssWriteList Maybe URI
muri SwishStateIO (Either [Char] [RDFGraph])
gf [Char]
comment = do
Either [Char] [RDFGraph]
esgs <- SwishStateIO (Either [Char] [RDFGraph])
gf
case Either [Char] [RDFGraph]
esgs of
Left [Char]
er -> (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((SwishState -> SwishState) -> SwishStateIO ())
-> (SwishState -> SwishState) -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> SwishState -> SwishState
setError ([Char]
"Cannot write list: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
Right [] -> Maybe URI -> Builder -> SwishStateIO ()
putResourceData Maybe URI
forall a. Maybe a
Nothing (Text -> Builder
B.fromLazyText ([Text] -> Text
L.concat [Text
"# ", [Char] -> Text
L.pack [Char]
comment, Text
"\n+ Swish: Writing empty list"]))
Right [RDFGraph
gr] -> Maybe URI -> RDFGraph -> [Char] -> SwishStateIO ()
ssWriteGraph Maybe URI
muri RDFGraph
gr [Char]
comment
Right [RDFGraph]
grs -> ((Int, RDFGraph) -> SwishStateIO ())
-> [(Int, RDFGraph)] -> SwishStateIO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (Int, RDFGraph) -> SwishStateIO ()
forall {a}. Show a => (a, RDFGraph) -> SwishStateIO ()
writegr ([Int] -> [RDFGraph] -> [(Int, RDFGraph)]
forall a b. [a] -> [b] -> [(a, b)]
zip [(Int
0::Int)..] [RDFGraph]
grs)
where
writegr :: (a, RDFGraph) -> SwishStateIO ()
writegr (a
n,RDFGraph
gr) = Maybe URI -> RDFGraph -> [Char] -> SwishStateIO ()
ssWriteGraph (Maybe URI -> a -> Maybe URI
forall {p}. Show p => Maybe URI -> p -> Maybe URI
murin Maybe URI
muri a
n) RDFGraph
gr
([Char]
"[" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ a -> [Char]
forall a. Show a => a -> [Char]
show a
n [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"] " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
comment)
murin :: Maybe URI -> p -> Maybe URI
murin Maybe URI
Nothing p
_ = Maybe URI
forall a. Maybe a
Nothing
murin (Just URI
uri) p
n =
let rp :: [Char]
rp = [Char] -> [Char]
forall a. [a] -> [a]
reverse ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ URI -> [Char]
uriPath URI
uri
([Char]
rLastSet, [Char]
rRest) = (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'/') [Char]
rp
([Char]
before, [Char]
after) = (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'.') ([Char] -> ([Char], [Char])) -> [Char] -> ([Char], [Char])
forall a b. (a -> b) -> a -> b
$ [Char] -> [Char]
forall a. [a] -> [a]
reverse [Char]
rLastSet
newPath :: [Char]
newPath = [Char] -> [Char]
forall a. [a] -> [a]
reverse [Char]
rRest [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"/" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
before [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ p -> [Char]
forall a. Show a => a -> [Char]
show p
n [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
after
in case [Char]
rLastSet of
[Char]
"" -> [Char] -> Maybe URI
forall a. HasCallStack => [Char] -> a
error ([Char] -> Maybe URI) -> [Char] -> Maybe URI
forall a b. (a -> b) -> a -> b
$ [Char]
"Invalid URI (path ends in /): " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ URI -> [Char]
forall a. Show a => a -> [Char]
show URI
uri
[Char]
_ -> URI -> Maybe URI
forall a. a -> Maybe a
Just (URI -> Maybe URI) -> URI -> Maybe URI
forall a b. (a -> b) -> a -> b
$ URI
uri { uriPath = newPath }
ssWriteGraph :: Maybe URI -> RDFGraph -> String -> SwishStateIO ()
ssWriteGraph :: Maybe URI -> RDFGraph -> [Char] -> SwishStateIO ()
ssWriteGraph Maybe URI
muri RDFGraph
gr [Char]
comment =
Maybe URI -> Builder -> SwishStateIO ()
putResourceData Maybe URI
muri (Builder
c Builder -> Builder -> Builder
forall a. Monoid a => a -> a -> a
`mappend` RDFGraph -> Builder
formatGraphAsBuilder RDFGraph
gr)
where
c :: Builder
c = Text -> Builder
B.fromLazyText (Text -> Builder) -> Text -> Builder
forall a b. (a -> b) -> a -> b
$ [Text] -> Text
L.concat [Text
"# ", [Char] -> Text
L.pack [Char]
comment, Text
"\n"]
ssMerge ::
ScopedName -> [SwishStateIO (Either String RDFGraph)]
-> SwishStateIO ()
ssMerge :: ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)] -> SwishStateIO ()
ssMerge ScopedName
nam [SwishStateIO (Either [Char] RDFGraph)]
gfs =
let errmsg :: [Char]
errmsg = [Char]
"Graph merge not defined: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
nam [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"; "
in
do { [Char] -> [Char] -> SwishStateIO ()
ssReportLabel [Char]
"Merge" (ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
nam)
; [Either [Char] RDFGraph]
esg <- [SwishStateIO (Either [Char] RDFGraph)]
-> StateT SwishState IO [Either [Char] RDFGraph]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [SwishStateIO (Either [Char] RDFGraph)]
gfs
; let egs :: Either [Char] [RDFGraph]
egs = [Either [Char] RDFGraph] -> Either [Char] [RDFGraph]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Either [Char] RDFGraph]
esg
; let fgs :: SwishState -> SwishState
fgs = case Either [Char] [RDFGraph]
egs of
Left [Char]
er -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
Right [] -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"No graphs to merge")
Right [RDFGraph]
gs -> (NamedGraphMap -> NamedGraphMap) -> SwishState -> SwishState
modGraphs (ScopedName -> [RDFGraph] -> NamedGraphMap -> NamedGraphMap
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert ScopedName
nam [RDFGraph
g])
where g :: RDFGraph
g = (RDFGraph -> RDFGraph -> RDFGraph) -> [RDFGraph] -> RDFGraph
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 RDFGraph -> RDFGraph -> RDFGraph
forall lb. Label lb => NSGraph lb -> NSGraph lb -> NSGraph lb
merge [RDFGraph]
gs
; (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify SwishState -> SwishState
fgs
}
ssCompare :: ScopedName -> ScopedName -> SwishStateIO ()
ssCompare :: ScopedName -> ScopedName -> SwishStateIO ()
ssCompare ScopedName
n1 ScopedName
n2 =
do { [Char] -> [Char] -> SwishStateIO ()
ssReportLabel [Char]
"Compare" (ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
n1 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
n2)
; Either [Char] RDFGraph
g1 <- ScopedName -> SwishStateIO (Either [Char] RDFGraph)
ssGetGraph ScopedName
n1
; Either [Char] RDFGraph
g2 <- ScopedName -> SwishStateIO (Either [Char] RDFGraph)
ssGetGraph ScopedName
n2
; Bool -> SwishStateIO () -> SwishStateIO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Either [Char] RDFGraph
g1 Either [Char] RDFGraph -> Either [Char] RDFGraph -> Bool
forall a. Eq a => a -> a -> Bool
/= Either [Char] RDFGraph
g2) ((SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((SwishState -> SwishState) -> SwishStateIO ())
-> (SwishState -> SwishState) -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$ SwishStatus -> SwishState -> SwishState
setStatus SwishStatus
SwishGraphCompareError)
}
ssAssertEq :: ScopedName -> ScopedName -> String -> SwishStateIO ()
ssAssertEq :: ScopedName -> ScopedName -> [Char] -> SwishStateIO ()
ssAssertEq ScopedName
n1 ScopedName
n2 [Char]
comment =
let er1 :: [Char]
er1 = [Char]
":\n Graph or list compare not performed: invalid graph/list."
in
do { [Char] -> [Char] -> SwishStateIO ()
ssReportLabel [Char]
"AssertEq" [Char]
comment
; Either [Char] [RDFGraph]
g1 <- ScopedName -> SwishStateIO (Either [Char] [RDFGraph])
ssGetList ScopedName
n1
; Either [Char] [RDFGraph]
g2 <- ScopedName -> SwishStateIO (Either [Char] [RDFGraph])
ssGetList ScopedName
n2
; case (Either [Char] [RDFGraph]
g1,Either [Char] [RDFGraph]
g2) of
(Left [Char]
er,Either [Char] [RDFGraph]
_) -> (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((SwishState -> SwishState) -> SwishStateIO ())
-> (SwishState -> SwishState) -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> SwishState -> SwishState
setError ([Char]
comment [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er1 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\n " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Either [Char] [RDFGraph]
_,Left [Char]
er) -> (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((SwishState -> SwishState) -> SwishStateIO ())
-> (SwishState -> SwishState) -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> SwishState -> SwishState
setError ([Char]
comment [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er1 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\n " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Right [RDFGraph]
gr1,Right [RDFGraph]
gr2) ->
Bool -> SwishStateIO () -> SwishStateIO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when ([RDFGraph] -> Set RDFGraph
forall a. Ord a => [a] -> Set a
S.fromList [RDFGraph]
gr1 Set RDFGraph -> Set RDFGraph -> Bool
forall a. Eq a => a -> a -> Bool
/= [RDFGraph] -> Set RDFGraph
forall a. Ord a => [a] -> Set a
S.fromList [RDFGraph]
gr2) (SwishStateIO () -> SwishStateIO ())
-> SwishStateIO () -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$ (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((SwishState -> SwishState) -> SwishStateIO ())
-> (SwishState -> SwishState) -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$
[Char] -> SwishState -> SwishState
setError ([Char]
comment [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
":\n Graph " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
n1
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" differs from " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
n2 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
".")
}
ssAssertIn :: ScopedName -> ScopedName -> String -> SwishStateIO ()
ssAssertIn :: ScopedName -> ScopedName -> [Char] -> SwishStateIO ()
ssAssertIn ScopedName
n1 ScopedName
n2 [Char]
comment =
let er1 :: [Char]
er1 = [Char]
":\n Membership test not performed: invalid graph."
er2 :: [Char]
er2 = [Char]
":\n Membership test not performed: invalid list."
in
do { [Char] -> [Char] -> SwishStateIO ()
ssReportLabel [Char]
"AssertIn" [Char]
comment
; Either [Char] RDFGraph
g1 <- ScopedName -> SwishStateIO (Either [Char] RDFGraph)
ssGetGraph ScopedName
n1
; Either [Char] [RDFGraph]
g2 <- ScopedName -> SwishStateIO (Either [Char] [RDFGraph])
ssGetList ScopedName
n2
; case (Either [Char] RDFGraph
g1,Either [Char] [RDFGraph]
g2) of
(Left [Char]
er,Either [Char] [RDFGraph]
_) -> (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((SwishState -> SwishState) -> SwishStateIO ())
-> (SwishState -> SwishState) -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> SwishState -> SwishState
setError ([Char]
comment [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er1 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\n " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Either [Char] RDFGraph
_,Left [Char]
er) -> (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((SwishState -> SwishState) -> SwishStateIO ())
-> (SwishState -> SwishState) -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> SwishState -> SwishState
setError ([Char]
comment [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er2 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\n " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Right RDFGraph
gr,Right [RDFGraph]
gs) ->
Bool -> SwishStateIO () -> SwishStateIO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (RDFGraph
gr RDFGraph -> [RDFGraph] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [RDFGraph]
gs) (SwishStateIO () -> SwishStateIO ())
-> SwishStateIO () -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$ (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((SwishState -> SwishState) -> SwishStateIO ())
-> (SwishState -> SwishState) -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$
[Char] -> SwishState -> SwishState
setError ([Char]
comment [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
":\n Graph " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
n1
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" not a member of " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
n2)
}
ssDefineRule ::
ScopedName
-> [SwishStateIO (Either String RDFGraph)]
-> SwishStateIO (Either String RDFGraph)
-> [(ScopedName,[RDFLabel])]
-> SwishStateIO ()
ssDefineRule :: ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)]
-> SwishStateIO (Either [Char] RDFGraph)
-> [(ScopedName, [RDFLabel])]
-> SwishStateIO ()
ssDefineRule ScopedName
rn [SwishStateIO (Either [Char] RDFGraph)]
agfs SwishStateIO (Either [Char] RDFGraph)
cgf [(ScopedName, [RDFLabel])]
vmds =
let errmsg1 :: [Char]
errmsg1 = [Char]
"Rule definition error in antecedent graph(s): "
errmsg2 :: [Char]
errmsg2 = [Char]
"Rule definition error in consequent graph: "
errmsg3 :: [Char]
errmsg3 = [Char]
"Rule definition error in variable modifier(s): "
errmsg4 :: [Char]
errmsg4 = [Char]
"Incompatible variable binding modifier sequence"
in
do { [Either [Char] RDFGraph]
aesg <- [SwishStateIO (Either [Char] RDFGraph)]
-> StateT SwishState IO [Either [Char] RDFGraph]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [SwishStateIO (Either [Char] RDFGraph)]
agfs
; let ags :: Either [Char] [RDFGraph]
ags = [Either [Char] RDFGraph] -> Either [Char] [RDFGraph]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Either [Char] RDFGraph]
aesg :: Either String [RDFGraph]
; Either [Char] RDFGraph
cg <- SwishStateIO (Either [Char] RDFGraph)
cgf
; let vmfs :: [SwishStateIO (Either [Char] RDFVarBindingModify)]
vmfs = ((ScopedName, [RDFLabel])
-> SwishStateIO (Either [Char] RDFVarBindingModify))
-> [(ScopedName, [RDFLabel])]
-> [SwishStateIO (Either [Char] RDFVarBindingModify)]
forall a b. (a -> b) -> [a] -> [b]
map (ScopedName, [RDFLabel])
-> SwishStateIO (Either [Char] RDFVarBindingModify)
ssFindVarModify [(ScopedName, [RDFLabel])]
vmds
; [Either [Char] RDFVarBindingModify]
evms <- [SwishStateIO (Either [Char] RDFVarBindingModify)]
-> StateT SwishState IO [Either [Char] RDFVarBindingModify]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [SwishStateIO (Either [Char] RDFVarBindingModify)]
vmfs
; let vms :: Either [Char] [RDFVarBindingModify]
vms = [Either [Char] RDFVarBindingModify]
-> Either [Char] [RDFVarBindingModify]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Either [Char] RDFVarBindingModify]
evms :: Either String [RDFVarBindingModify]
; let frl :: SwishState -> SwishState
frl = case (Either [Char] [RDFGraph]
ags,Either [Char] RDFGraph
cg,Either [Char] [RDFVarBindingModify]
vms) of
(Left [Char]
er,Either [Char] RDFGraph
_,Either [Char] [RDFVarBindingModify]
_) -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg1 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Either [Char] [RDFGraph]
_,Left [Char]
er,Either [Char] [RDFVarBindingModify]
_) -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg2 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Either [Char] [RDFGraph]
_,Either [Char] RDFGraph
_,Left [Char]
er) -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg3 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Right [RDFGraph]
agrs,Right RDFGraph
cgr,Right [RDFVarBindingModify]
vbms) ->
let
newRule :: RDFVarBindingModify -> RDFRule
newRule = ScopedName
-> [RDFGraph] -> RDFGraph -> RDFVarBindingModify -> RDFRule
makeRDFClosureRule ScopedName
rn [RDFGraph]
agrs RDFGraph
cgr
in
case [RDFVarBindingModify] -> Maybe RDFVarBindingModify
forall a b.
Eq a =>
[VarBindingModify a b] -> Maybe (VarBindingModify a b)
composeSequence [RDFVarBindingModify]
vbms of
Just RDFVarBindingModify
vm -> let nr :: RDFRule
nr = RDFVarBindingModify -> RDFRule
newRule RDFVarBindingModify
vm in (RDFRuleMap -> RDFRuleMap) -> SwishState -> SwishState
modRules (ScopedName -> RDFRule -> RDFRuleMap -> RDFRuleMap
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert (RDFRule -> ScopedName
forall ex. Rule ex -> ScopedName
ruleName RDFRule
nr) RDFRule
nr)
Maybe RDFVarBindingModify
Nothing -> [Char] -> SwishState -> SwishState
setError [Char]
errmsg4
; (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify SwishState -> SwishState
frl
}
ssFindVarModify ::
(ScopedName,[RDFLabel]) -> SwishStateIO (Either String RDFVarBindingModify)
ssFindVarModify :: (ScopedName, [RDFLabel])
-> SwishStateIO (Either [Char] RDFVarBindingModify)
ssFindVarModify (ScopedName
nam,[RDFLabel]
lbs) = (SwishState -> Either [Char] RDFVarBindingModify)
-> SwishStateIO (Either [Char] RDFVarBindingModify)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ((SwishState -> Either [Char] RDFVarBindingModify)
-> SwishStateIO (Either [Char] RDFVarBindingModify))
-> (SwishState -> Either [Char] RDFVarBindingModify)
-> SwishStateIO (Either [Char] RDFVarBindingModify)
forall a b. (a -> b) -> a -> b
$ \SwishState
st ->
case ScopedName -> SwishState -> Maybe RDFOpenVarBindingModify
findOpenVarModify ScopedName
nam SwishState
st of
Just RDFOpenVarBindingModify
ovbm -> RDFVarBindingModify -> Either [Char] RDFVarBindingModify
forall a b. b -> Either a b
Right (RDFOpenVarBindingModify
ovbm [RDFLabel]
lbs)
Maybe RDFOpenVarBindingModify
Nothing -> [Char] -> Either [Char] RDFVarBindingModify
forall a b. a -> Either a b
Left ([Char]
"Undefined modifier: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
nam)
ssDefineRuleset ::
ScopedName
-> [ScopedName]
-> [ScopedName]
-> SwishStateIO ()
ssDefineRuleset :: ScopedName -> [ScopedName] -> [ScopedName] -> SwishStateIO ()
ssDefineRuleset ScopedName
sn [ScopedName]
ans [ScopedName]
rns =
let errmsg1 :: [Char]
errmsg1 = [Char]
"Error in ruleset axiom(s): "
errmsg2 :: [Char]
errmsg2 = [Char]
"Error in ruleset rule(s): "
in
do { let agfs :: SwishStateIO [Either [Char] RDFFormula]
agfs = (ScopedName -> SwishStateIO (Either [Char] RDFFormula))
-> [ScopedName] -> SwishStateIO [Either [Char] RDFFormula]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ScopedName -> SwishStateIO (Either [Char] RDFFormula)
ssGetFormula [ScopedName]
ans
:: SwishStateIO [Either String RDFFormula]
; [Either [Char] RDFFormula]
aesg <- SwishStateIO [Either [Char] RDFFormula]
agfs
; let eags :: Either [Char] [RDFFormula]
eags = [Either [Char] RDFFormula] -> Either [Char] [RDFFormula]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Either [Char] RDFFormula]
aesg :: Either String [RDFFormula]
; let erlf :: SwishStateIO [Either [Char] RDFRule]
erlf = (ScopedName -> StateT SwishState IO (Either [Char] RDFRule))
-> [ScopedName] -> SwishStateIO [Either [Char] RDFRule]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ScopedName -> StateT SwishState IO (Either [Char] RDFRule)
ssFindRule [ScopedName]
rns
:: SwishStateIO [Either String RDFRule]
; [Either [Char] RDFRule]
rles <- SwishStateIO [Either [Char] RDFRule]
erlf
; let erls :: Either [Char] [RDFRule]
erls = [Either [Char] RDFRule] -> Either [Char] [RDFRule]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Either [Char] RDFRule]
rles :: Either String [RDFRule]
; let frs :: SwishState -> SwishState
frs = case (Either [Char] [RDFFormula]
eags,Either [Char] [RDFRule]
erls) of
(Left [Char]
er,Either [Char] [RDFRule]
_) -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg1 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Either [Char] [RDFFormula]
_,Left [Char]
er) -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg2 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Right [RDFFormula]
ags,Right [RDFRule]
rls) ->
(RDFRulesetMap -> RDFRulesetMap) -> SwishState -> SwishState
modRulesets (Namespace -> RDFRuleset -> RDFRulesetMap -> RDFRulesetMap
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert (RDFRuleset -> Namespace
forall ex. Ruleset ex -> Namespace
getRulesetNamespace RDFRuleset
rs) RDFRuleset
rs)
where
rs :: RDFRuleset
rs = Namespace -> [RDFFormula] -> [RDFRule] -> RDFRuleset
forall ex. Namespace -> [Formula ex] -> [Rule ex] -> Ruleset ex
makeRuleset (ScopedName -> Namespace
getScopeNamespace ScopedName
sn) [RDFFormula]
ags [RDFRule]
rls
; (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify SwishState -> SwishState
frs
}
ssFindRule :: ScopedName -> SwishStateIO (Either String RDFRule)
ssFindRule :: ScopedName -> StateT SwishState IO (Either [Char] RDFRule)
ssFindRule ScopedName
nam = (SwishState -> Either [Char] RDFRule)
-> StateT SwishState IO (Either [Char] RDFRule)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets SwishState -> Either [Char] RDFRule
find
where
find :: SwishState -> Either [Char] RDFRule
find SwishState
st = case ScopedName -> SwishState -> Maybe RDFRule
findRule ScopedName
nam SwishState
st of
Maybe RDFRule
Nothing -> [Char] -> Either [Char] RDFRule
forall a b. a -> Either a b
Left ([Char]
"Rule not found: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
nam)
Just RDFRule
rl -> RDFRule -> Either [Char] RDFRule
forall a b. b -> Either a b
Right RDFRule
rl
ssDefineConstraints ::
ScopedName
-> [SwishStateIO (Either String RDFGraph)]
-> [ScopedName]
-> SwishStateIO ()
ssDefineConstraints :: ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)]
-> [ScopedName]
-> SwishStateIO ()
ssDefineConstraints ScopedName
sn [SwishStateIO (Either [Char] RDFGraph)]
cgfs [ScopedName]
dtns =
let errmsg1 :: [Char]
errmsg1 = [Char]
"Error in constraint graph(s): "
errmsg2 :: [Char]
errmsg2 = [Char]
"Error in datatype(s): "
in
do { [Either [Char] RDFGraph]
cges <- [SwishStateIO (Either [Char] RDFGraph)]
-> StateT SwishState IO [Either [Char] RDFGraph]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [SwishStateIO (Either [Char] RDFGraph)]
cgfs
; let ecgs :: Either [Char] [RDFGraph]
ecgs = [Either [Char] RDFGraph] -> Either [Char] [RDFGraph]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Either [Char] RDFGraph]
cges :: Either String [RDFGraph]
; let ecgr :: Either [Char] RDFGraph
ecgr = case Either [Char] [RDFGraph]
ecgs of
Left [Char]
er -> [Char] -> Either [Char] RDFGraph
forall a b. a -> Either a b
Left [Char]
er
Right [] -> RDFGraph -> Either [Char] RDFGraph
forall a b. b -> Either a b
Right RDFGraph
forall a. Monoid a => a
mempty
Right [RDFGraph]
grs -> RDFGraph -> Either [Char] RDFGraph
forall a b. b -> Either a b
Right (RDFGraph -> Either [Char] RDFGraph)
-> RDFGraph -> Either [Char] RDFGraph
forall a b. (a -> b) -> a -> b
$ (RDFGraph -> RDFGraph -> RDFGraph) -> [RDFGraph] -> RDFGraph
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 RDFGraph -> RDFGraph -> RDFGraph
forall lb. Label lb => NSGraph lb -> NSGraph lb -> NSGraph lb
merge [RDFGraph]
grs
; [Either [Char] RDFDatatype]
edtf <- (ScopedName -> StateT SwishState IO (Either [Char] RDFDatatype))
-> [ScopedName] -> StateT SwishState IO [Either [Char] RDFDatatype]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ScopedName -> StateT SwishState IO (Either [Char] RDFDatatype)
ssFindDatatype [ScopedName]
dtns
; let edts :: Either [Char] [RDFDatatype]
edts = [Either [Char] RDFDatatype] -> Either [Char] [RDFDatatype]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Either [Char] RDFDatatype]
edtf :: Either String [RDFDatatype]
; let frs :: SwishState -> SwishState
frs = case (Either [Char] RDFGraph
ecgr,Either [Char] [RDFDatatype]
edts) of
(Left [Char]
er,Either [Char] [RDFDatatype]
_) -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg1 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Either [Char] RDFGraph
_,Left [Char]
er) -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg2 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Right RDFGraph
cgr,Right [RDFDatatype]
dts) ->
(RDFRulesetMap -> RDFRulesetMap) -> SwishState -> SwishState
modRulesets (Namespace -> RDFRuleset -> RDFRulesetMap -> RDFRulesetMap
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert (RDFRuleset -> Namespace
forall ex. Ruleset ex -> Namespace
getRulesetNamespace RDFRuleset
rs) RDFRuleset
rs)
where
rs :: RDFRuleset
rs = Namespace -> [RDFFormula] -> [RDFRule] -> RDFRuleset
forall ex. Namespace -> [Formula ex] -> [Rule ex] -> Ruleset ex
makeRuleset (ScopedName -> Namespace
getScopeNamespace ScopedName
sn) [] [RDFRule]
rls
rls :: [RDFRule]
rls = (RDFDatatype -> [RDFRule]) -> [RDFDatatype] -> [RDFRule]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (RDFDatatype -> RDFGraph -> [RDFRule]
forall ex lb vn. Datatype ex lb vn -> ex -> [Rule ex]
`typeMkRules` RDFGraph
cgr) [RDFDatatype]
dts
; (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify SwishState -> SwishState
frs
}
ssFindDatatype :: ScopedName -> SwishStateIO (Either String RDFDatatype)
ssFindDatatype :: ScopedName -> StateT SwishState IO (Either [Char] RDFDatatype)
ssFindDatatype ScopedName
nam = (SwishState -> Either [Char] RDFDatatype)
-> StateT SwishState IO (Either [Char] RDFDatatype)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets SwishState -> Either [Char] RDFDatatype
find
where
find :: SwishState -> Either [Char] RDFDatatype
find SwishState
st = case ScopedName -> SwishState -> Maybe RDFDatatype
findDatatype ScopedName
nam SwishState
st of
Maybe RDFDatatype
Nothing -> [Char] -> Either [Char] RDFDatatype
forall a b. a -> Either a b
Left ([Char]
"Datatype not found: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
nam)
Just RDFDatatype
dt -> RDFDatatype -> Either [Char] RDFDatatype
forall a b. b -> Either a b
Right RDFDatatype
dt
ssCheckProof ::
ScopedName
-> [ScopedName]
-> SwishStateIO (Either String RDFFormula)
-> [Either String [RDFRuleset]
-> SwishStateIO (Either String RDFProofStep)]
-> SwishStateIO (Either String RDFFormula)
-> SwishStateIO ()
ssCheckProof :: ScopedName
-> [ScopedName]
-> SwishStateIO (Either [Char] RDFFormula)
-> [Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep)]
-> SwishStateIO (Either [Char] RDFFormula)
-> SwishStateIO ()
ssCheckProof ScopedName
pn [ScopedName]
sns SwishStateIO (Either [Char] RDFFormula)
igf [Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep)]
stfs SwishStateIO (Either [Char] RDFFormula)
rgf =
let
infmsg1 :: [Char]
infmsg1 = [Char]
"Proof satisfied: "
errmsg1 :: [Char]
errmsg1 = [Char]
"Error in proof ruleset(s): "
errmsg2 :: [Char]
errmsg2 = [Char]
"Error in proof input: "
errmsg3 :: [Char]
errmsg3 = [Char]
"Error in proof step(s): "
errmsg4 :: [Char]
errmsg4 = [Char]
"Error in proof goal: "
errmsg5 :: [Char]
errmsg5 = [Char]
"Proof not satisfied: "
proofname :: [Char]
proofname = [Char]
" (Proof " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
pn [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
")"
in
do { let rs1 :: [SwishStateIO (Either [Char] RDFRuleset)]
rs1 = (ScopedName -> SwishStateIO (Either [Char] RDFRuleset))
-> [ScopedName] -> [SwishStateIO (Either [Char] RDFRuleset)]
forall a b. (a -> b) -> [a] -> [b]
map ScopedName -> SwishStateIO (Either [Char] RDFRuleset)
ssFindRuleset [ScopedName]
sns :: [SwishStateIO (Either String RDFRuleset)]
; [Either [Char] RDFRuleset]
rs2 <- [SwishStateIO (Either [Char] RDFRuleset)]
-> StateT SwishState IO [Either [Char] RDFRuleset]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [SwishStateIO (Either [Char] RDFRuleset)]
rs1
; let erss :: Either [Char] [RDFRuleset]
erss = [Either [Char] RDFRuleset] -> Either [Char] [RDFRuleset]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Either [Char] RDFRuleset]
rs2 :: Either String [RDFRuleset]
; Either [Char] RDFFormula
eig <- SwishStateIO (Either [Char] RDFFormula)
igf
; let st1 :: SwishStateIO [Either [Char] RDFProofStep]
st1 = [SwishStateIO (Either [Char] RDFProofStep)]
-> SwishStateIO [Either [Char] RDFProofStep]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence ([SwishStateIO (Either [Char] RDFProofStep)]
-> SwishStateIO [Either [Char] RDFProofStep])
-> [SwishStateIO (Either [Char] RDFProofStep)]
-> SwishStateIO [Either [Char] RDFProofStep]
forall a b. (a -> b) -> a -> b
$ [Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep)]
-> Either [Char] [RDFRuleset]
-> [SwishStateIO (Either [Char] RDFProofStep)]
forall a b. [a -> b] -> a -> [b]
flist [Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep)]
stfs Either [Char] [RDFRuleset]
erss :: SwishStateIO [Either String RDFProofStep]
; [Either [Char] RDFProofStep]
st2 <- SwishStateIO [Either [Char] RDFProofStep]
st1
; let ests :: Either [Char] [RDFProofStep]
ests = [Either [Char] RDFProofStep] -> Either [Char] [RDFProofStep]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Either [Char] RDFProofStep]
st2 :: Either String [RDFProofStep]
; Either [Char] RDFFormula
erg <- SwishStateIO (Either [Char] RDFFormula)
rgf
; let proof :: Either [Char] RDFProof
proof = case (Either [Char] [RDFRuleset]
erss,Either [Char] RDFFormula
eig,Either [Char] [RDFProofStep]
ests,Either [Char] RDFFormula
erg) of
(Left [Char]
er,Either [Char] RDFFormula
_,Either [Char] [RDFProofStep]
_,Either [Char] RDFFormula
_) -> [Char] -> Either [Char] RDFProof
forall a b. a -> Either a b
Left ([Char]
errmsg1 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
proofname)
(Either [Char] [RDFRuleset]
_,Left [Char]
er,Either [Char] [RDFProofStep]
_,Either [Char] RDFFormula
_) -> [Char] -> Either [Char] RDFProof
forall a b. a -> Either a b
Left ([Char]
errmsg2 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
proofname)
(Either [Char] [RDFRuleset]
_,Either [Char] RDFFormula
_,Left [Char]
er,Either [Char] RDFFormula
_) -> [Char] -> Either [Char] RDFProof
forall a b. a -> Either a b
Left ([Char]
errmsg3 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
proofname)
(Either [Char] [RDFRuleset]
_,Either [Char] RDFFormula
_,Either [Char] [RDFProofStep]
_,Left [Char]
er) -> [Char] -> Either [Char] RDFProof
forall a b. a -> Either a b
Left ([Char]
errmsg4 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
proofname)
(Right [RDFRuleset]
rss, Right RDFFormula
ig, Right [RDFProofStep]
sts, Right RDFFormula
rg) ->
RDFProof -> Either [Char] RDFProof
forall a b. b -> Either a b
Right ([RDFRuleset]
-> RDFFormula -> RDFFormula -> [RDFProofStep] -> RDFProof
makeRDFProof [RDFRuleset]
rss RDFFormula
ig RDFFormula
rg [RDFProofStep]
sts)
; Bool -> SwishStateIO () -> SwishStateIO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
False (SwishStateIO () -> SwishStateIO ())
-> SwishStateIO () -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$ case Either [Char] RDFProof
proof of
(Left [Char]
_) -> () -> SwishStateIO ()
forall a. a -> StateT SwishState IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
(Right RDFProof
pr) -> Maybe URI -> Builder -> SwishStateIO ()
putResourceData Maybe URI
forall a. Maybe a
Nothing (Builder -> SwishStateIO ()) -> Builder -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$
Text -> Builder
B.fromLazyText ([Text] -> Text
L.concat [Text
"Proof ", [Char] -> Text
L.pack (ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
pn), Text
"\n"])
Builder -> Builder -> Builder
forall a. Monoid a => a -> a -> a
`mappend`
[Char] -> Builder
B.fromString ([Char] -> RDFProof -> [Char] -> [Char]
forall ex. ShowLines ex => [Char] -> Proof ex -> [Char] -> [Char]
showsProof [Char]
"\n" RDFProof
pr [Char]
"\n")
; let checkproof :: SwishState -> SwishState
checkproof = case Either [Char] RDFProof
proof of
(Left [Char]
er) -> [Char] -> SwishState -> SwishState
setError [Char]
er
(Right RDFProof
pr) ->
case RDFProof -> Maybe [Char]
forall ex. (Expression ex, Ord ex) => Proof ex -> Maybe [Char]
explainProof RDFProof
pr of
Maybe [Char]
Nothing -> [Char] -> SwishState -> SwishState
setInfo ([Char]
infmsg1 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
pn)
Just [Char]
ex -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg5 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
pn [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
", " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
ex)
; (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify SwishState -> SwishState
checkproof
}
ssCheckStep ::
ScopedName
-> [SwishStateIO (Either String RDFFormula)]
-> SwishStateIO (Either String RDFFormula)
-> Either String [RDFRuleset]
-> SwishStateIO (Either String RDFProofStep)
ssCheckStep :: ScopedName
-> [SwishStateIO (Either [Char] RDFFormula)]
-> SwishStateIO (Either [Char] RDFFormula)
-> Either [Char] [RDFRuleset]
-> SwishStateIO (Either [Char] RDFProofStep)
ssCheckStep ScopedName
_ [SwishStateIO (Either [Char] RDFFormula)]
_ SwishStateIO (Either [Char] RDFFormula)
_ (Left [Char]
er) = Either [Char] RDFProofStep
-> SwishStateIO (Either [Char] RDFProofStep)
forall a. a -> StateT SwishState IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either [Char] RDFProofStep
-> SwishStateIO (Either [Char] RDFProofStep))
-> Either [Char] RDFProofStep
-> SwishStateIO (Either [Char] RDFProofStep)
forall a b. (a -> b) -> a -> b
$ [Char] -> Either [Char] RDFProofStep
forall a b. a -> Either a b
Left [Char]
er
ssCheckStep ScopedName
rn [SwishStateIO (Either [Char] RDFFormula)]
eagf SwishStateIO (Either [Char] RDFFormula)
ecgf (Right [RDFRuleset]
rss) =
let
errmsg1 :: [Char]
errmsg1 = [Char]
"Rule not in proof step ruleset(s): "
errmsg2 :: [Char]
errmsg2 = [Char]
"Error in proof step antecedent graph(s): "
errmsg3 :: [Char]
errmsg3 = [Char]
"Error in proof step consequent graph: "
in
do { let mrul :: Maybe RDFRule
mrul = ScopedName -> [RDFRuleset] -> Maybe RDFRule
forall ex. ScopedName -> [Ruleset ex] -> Maybe (Rule ex)
getMaybeContextRule ScopedName
rn [RDFRuleset]
rss :: Maybe RDFRule
; [Either [Char] RDFFormula]
esag <- [SwishStateIO (Either [Char] RDFFormula)]
-> SwishStateIO [Either [Char] RDFFormula]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [SwishStateIO (Either [Char] RDFFormula)]
eagf
; let eags :: Either [Char] [RDFFormula]
eags = [Either [Char] RDFFormula] -> Either [Char] [RDFFormula]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Either [Char] RDFFormula]
esag :: Either String [RDFFormula]
; Either [Char] RDFFormula
ecg <- SwishStateIO (Either [Char] RDFFormula)
ecgf
; let est :: Either [Char] RDFProofStep
est = case (Maybe RDFRule
mrul,Either [Char] [RDFFormula]
eags,Either [Char] RDFFormula
ecg) of
(Maybe RDFRule
Nothing,Either [Char] [RDFFormula]
_,Either [Char] RDFFormula
_) -> [Char] -> Either [Char] RDFProofStep
forall a b. a -> Either a b
Left ([Char]
errmsg1 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
rn)
(Maybe RDFRule
_,Left [Char]
er,Either [Char] RDFFormula
_) -> [Char] -> Either [Char] RDFProofStep
forall a b. a -> Either a b
Left ([Char]
errmsg2 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Maybe RDFRule
_,Either [Char] [RDFFormula]
_,Left [Char]
er) -> [Char] -> Either [Char] RDFProofStep
forall a b. a -> Either a b
Left ([Char]
errmsg3 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Just RDFRule
rul,Right [RDFFormula]
ags,Right RDFFormula
cg) ->
RDFProofStep -> Either [Char] RDFProofStep
forall a b. b -> Either a b
Right (RDFProofStep -> Either [Char] RDFProofStep)
-> RDFProofStep -> Either [Char] RDFProofStep
forall a b. (a -> b) -> a -> b
$ RDFRule -> [RDFFormula] -> RDFFormula -> RDFProofStep
makeRDFProofStep RDFRule
rul [RDFFormula]
ags RDFFormula
cg
; Either [Char] RDFProofStep
-> SwishStateIO (Either [Char] RDFProofStep)
forall a. a -> StateT SwishState IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Either [Char] RDFProofStep
est
}
ssFwdChain ::
ScopedName
-> ScopedName
-> [SwishStateIO (Either String RDFGraph)]
-> ScopedName
-> NamespaceMap
-> SwishStateIO ()
ssFwdChain :: ScopedName
-> ScopedName
-> [SwishStateIO (Either [Char] RDFGraph)]
-> ScopedName
-> NamespaceMap
-> SwishStateIO ()
ssFwdChain ScopedName
sn ScopedName
rn [SwishStateIO (Either [Char] RDFGraph)]
agfs ScopedName
cn NamespaceMap
prefs =
let
errmsg1 :: [Char]
errmsg1 = [Char]
"FwdChain rule error: "
errmsg2 :: [Char]
errmsg2 = [Char]
"FwdChain antecedent error: "
in
do { Either [Char] RDFRule
erl <- ScopedName
-> ScopedName -> StateT SwishState IO (Either [Char] RDFRule)
ssFindRulesetRule ScopedName
sn ScopedName
rn
; [Either [Char] RDFGraph]
aesg <- [SwishStateIO (Either [Char] RDFGraph)]
-> StateT SwishState IO [Either [Char] RDFGraph]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [SwishStateIO (Either [Char] RDFGraph)]
agfs
; let eags :: Either [Char] [RDFGraph]
eags = [Either [Char] RDFGraph] -> Either [Char] [RDFGraph]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Either [Char] RDFGraph]
aesg :: Either String [RDFGraph]
; let fcr :: SwishState -> SwishState
fcr = case (Either [Char] RDFRule
erl,Either [Char] [RDFGraph]
eags) of
(Left [Char]
er,Either [Char] [RDFGraph]
_) -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg1 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Either [Char] RDFRule
_,Left [Char]
er) -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg2 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Right RDFRule
rl,Right [RDFGraph]
ags) ->
(NamedGraphMap -> NamedGraphMap) -> SwishState -> SwishState
modGraphs (ScopedName -> [RDFGraph] -> NamedGraphMap -> NamedGraphMap
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert ScopedName
cn [RDFGraph
cg])
where
cg :: RDFGraph
cg = case RDFRule -> [RDFGraph] -> [RDFGraph]
forall ex. Rule ex -> [ex] -> [ex]
fwdApply RDFRule
rl [RDFGraph]
ags of
[] -> RDFGraph
forall a. Monoid a => a
mempty
[RDFGraph]
grs -> NamespaceMap -> RDFGraph -> RDFGraph
forall lb. NamespaceMap -> NSGraph lb -> NSGraph lb
setNamespaces NamespaceMap
prefs (RDFGraph -> RDFGraph) -> RDFGraph -> RDFGraph
forall a b. (a -> b) -> a -> b
$ (RDFGraph -> RDFGraph -> RDFGraph) -> [RDFGraph] -> RDFGraph
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 RDFGraph -> RDFGraph -> RDFGraph
forall (lg :: * -> *) lb.
(LDGraph lg lb, Ord lb) =>
lg lb -> lg lb -> lg lb
addGraphs [RDFGraph]
grs
; (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify SwishState -> SwishState
fcr
}
ssFindRulesetRule ::
ScopedName -> ScopedName -> SwishStateIO (Either String RDFRule)
ssFindRulesetRule :: ScopedName
-> ScopedName -> StateT SwishState IO (Either [Char] RDFRule)
ssFindRulesetRule ScopedName
sn ScopedName
rn = (SwishState -> Either [Char] RDFRule)
-> StateT SwishState IO (Either [Char] RDFRule)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets SwishState -> Either [Char] RDFRule
find
where
find :: SwishState -> Either [Char] RDFRule
find SwishState
st = case ScopedName -> SwishState -> Maybe RDFRuleset
findRuleset ScopedName
sn SwishState
st of
Maybe RDFRuleset
Nothing -> [Char] -> Either [Char] RDFRule
forall a b. a -> Either a b
Left ([Char]
"Ruleset not found: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
sn)
Just RDFRuleset
rs -> RDFRuleset -> Either [Char] RDFRule
forall {ex}. Ruleset ex -> Either [Char] (Rule ex)
find1 RDFRuleset
rs
find1 :: Ruleset ex -> Either [Char] (Rule ex)
find1 Ruleset ex
rs = case ScopedName -> Ruleset ex -> Maybe (Rule ex)
forall ex. ScopedName -> Ruleset ex -> Maybe (Rule ex)
getRulesetRule ScopedName
rn Ruleset ex
rs of
Maybe (Rule ex)
Nothing -> [Char] -> Either [Char] (Rule ex)
forall a b. a -> Either a b
Left ([Char]
"Rule not in ruleset: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
sn [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
": " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
rn)
Just Rule ex
rl -> Rule ex -> Either [Char] (Rule ex)
forall a b. b -> Either a b
Right Rule ex
rl
ssFindRuleset ::
ScopedName -> SwishStateIO (Either String RDFRuleset)
ssFindRuleset :: ScopedName -> SwishStateIO (Either [Char] RDFRuleset)
ssFindRuleset ScopedName
sn = (SwishState -> Either [Char] RDFRuleset)
-> SwishStateIO (Either [Char] RDFRuleset)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets SwishState -> Either [Char] RDFRuleset
find
where
find :: SwishState -> Either [Char] RDFRuleset
find SwishState
st = case ScopedName -> SwishState -> Maybe RDFRuleset
findRuleset ScopedName
sn SwishState
st of
Maybe RDFRuleset
Nothing -> [Char] -> Either [Char] RDFRuleset
forall a b. a -> Either a b
Left ([Char]
"Ruleset not found: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ScopedName -> [Char]
forall a. Show a => a -> [Char]
show ScopedName
sn)
Just RDFRuleset
rs -> RDFRuleset -> Either [Char] RDFRuleset
forall a b. b -> Either a b
Right RDFRuleset
rs
ssBwdChain ::
ScopedName
-> ScopedName
-> SwishStateIO (Either String RDFGraph)
-> ScopedName
-> NamespaceMap
-> SwishStateIO ()
ssBwdChain :: ScopedName
-> ScopedName
-> SwishStateIO (Either [Char] RDFGraph)
-> ScopedName
-> NamespaceMap
-> SwishStateIO ()
ssBwdChain ScopedName
sn ScopedName
rn SwishStateIO (Either [Char] RDFGraph)
cgf ScopedName
an NamespaceMap
prefs =
let
errmsg1 :: [Char]
errmsg1 = [Char]
"BwdChain rule error: "
errmsg2 :: [Char]
errmsg2 = [Char]
"BwdChain goal error: "
in
do { Either [Char] RDFRule
erl <- ScopedName
-> ScopedName -> StateT SwishState IO (Either [Char] RDFRule)
ssFindRulesetRule ScopedName
sn ScopedName
rn
; Either [Char] RDFGraph
ecg <- SwishStateIO (Either [Char] RDFGraph)
cgf
; let fcr :: SwishState -> SwishState
fcr = case (Either [Char] RDFRule
erl,Either [Char] RDFGraph
ecg) of
(Left [Char]
er,Either [Char] RDFGraph
_) -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg1 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Either [Char] RDFRule
_,Left [Char]
er) -> [Char] -> SwishState -> SwishState
setError ([Char]
errmsg2 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
er)
(Right RDFRule
rl,Right RDFGraph
cg) ->
(NamedGraphMap -> NamedGraphMap) -> SwishState -> SwishState
modGraphs (ScopedName -> [RDFGraph] -> NamedGraphMap -> NamedGraphMap
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert ScopedName
an [RDFGraph]
ags)
where
ags :: [RDFGraph]
ags = ([RDFGraph] -> RDFGraph) -> [[RDFGraph]] -> [RDFGraph]
forall a b. (a -> b) -> [a] -> [b]
map [RDFGraph] -> RDFGraph
forall {lb}. Label lb => [NSGraph lb] -> NSGraph lb
mergegr (RDFRule -> RDFGraph -> [[RDFGraph]]
forall ex. Rule ex -> ex -> [[ex]]
bwdApply RDFRule
rl RDFGraph
cg)
mergegr :: [NSGraph lb] -> NSGraph lb
mergegr [NSGraph lb]
grs = case [NSGraph lb]
grs of
[] -> NSGraph lb
forall a. Monoid a => a
mempty
[NSGraph lb]
_ -> NamespaceMap -> NSGraph lb -> NSGraph lb
forall lb. NamespaceMap -> NSGraph lb -> NSGraph lb
setNamespaces NamespaceMap
prefs (NSGraph lb -> NSGraph lb) -> NSGraph lb -> NSGraph lb
forall a b. (a -> b) -> a -> b
$ (NSGraph lb -> NSGraph lb -> NSGraph lb)
-> [NSGraph lb] -> NSGraph lb
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 NSGraph lb -> NSGraph lb -> NSGraph lb
forall (lg :: * -> *) lb.
(LDGraph lg lb, Ord lb) =>
lg lb -> lg lb -> lg lb
addGraphs [NSGraph lb]
grs
; (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify SwishState -> SwishState
fcr
}
getResourceData :: Maybe URI -> SwishStateIO (Either String L.Text)
getResourceData :: Maybe URI -> StateT SwishState IO (Either [Char] Text)
getResourceData = StateT SwishState IO (Either [Char] Text)
-> (URI -> StateT SwishState IO (Either [Char] Text))
-> Maybe URI
-> StateT SwishState IO (Either [Char] Text)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe StateT SwishState IO (Either [Char] Text)
forall {a}. StateT SwishState IO (Either a Text)
fromStdin URI -> StateT SwishState IO (Either [Char] Text)
forall {a}. URI -> StateT SwishState IO (Either a Text)
fromUri
where
fromStdin :: StateT SwishState IO (Either a Text)
fromStdin = Text -> Either a Text
forall a b. b -> Either a b
Right (Text -> Either a Text)
-> StateT SwishState IO Text
-> StateT SwishState IO (Either a Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO Text -> StateT SwishState IO Text
forall (m :: * -> *) a. Monad m => m a -> StateT SwishState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift IO Text
LIO.getContents
fromUri :: URI -> StateT SwishState IO (Either a Text)
fromUri = URI -> StateT SwishState IO (Either a Text)
forall {t :: (* -> *) -> * -> *} {a}.
(Functor (t IO), MonadTrans t) =>
URI -> t IO (Either a Text)
fromFile
fromFile :: URI -> t IO (Either a Text)
fromFile URI
uri | URI -> [Char]
uriScheme URI
uri [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"file:" = Text -> Either a Text
forall a b. b -> Either a b
Right (Text -> Either a Text) -> t IO Text -> t IO (Either a Text)
forall a b. (a -> b) -> t IO a -> t IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` IO Text -> t IO Text
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift ([Char] -> IO Text
LIO.readFile ([Char] -> IO Text) -> [Char] -> IO Text
forall a b. (a -> b) -> a -> b
$ URI -> [Char]
uriPath URI
uri)
| Bool
otherwise = [Char] -> t IO (Either a Text)
forall a. HasCallStack => [Char] -> a
error ([Char] -> t IO (Either a Text)) -> [Char] -> t IO (Either a Text)
forall a b. (a -> b) -> a -> b
$ [Char]
"Unsupported file name for read: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ URI -> [Char]
forall a. Show a => a -> [Char]
show URI
uri
putResourceData :: Maybe URI -> B.Builder -> SwishStateIO ()
putResourceData :: Maybe URI -> Builder -> SwishStateIO ()
putResourceData Maybe URI
muri Builder
gsh = do
Either IOError ()
ios <- IO (Either IOError ()) -> StateT SwishState IO (Either IOError ())
forall (m :: * -> *) a. Monad m => m a -> StateT SwishState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO (Either IOError ())
-> StateT SwishState IO (Either IOError ()))
-> (IO () -> IO (Either IOError ()))
-> IO ()
-> StateT SwishState IO (Either IOError ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO () -> IO (Either IOError ())
forall e a. Exception e => IO a -> IO (Either e a)
CE.try (IO () -> StateT SwishState IO (Either IOError ()))
-> IO () -> StateT SwishState IO (Either IOError ())
forall a b. (a -> b) -> a -> b
$ IO () -> (URI -> IO ()) -> Maybe URI -> IO ()
forall b a. b -> (a -> b) -> Maybe a -> b
maybe IO ()
toStdout URI -> IO ()
toUri Maybe URI
muri
case Either IOError ()
ios of
Left IOError
ioe -> (SwishState -> SwishState) -> SwishStateIO ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((SwishState -> SwishState) -> SwishStateIO ())
-> (SwishState -> SwishState) -> SwishStateIO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> SwishState -> SwishState
setError
([Char]
"Error writing graph: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
IOError -> [Char]
IO.ioeGetErrorString IOError
ioe)
Right ()
_ -> () -> SwishStateIO ()
forall a. a -> StateT SwishState IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
where
toStdout :: IO ()
toStdout = Text -> IO ()
LIO.putStrLn Text
gstr
toUri :: URI -> IO ()
toUri URI
uri | URI -> [Char]
uriScheme URI
uri [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"file:" = [Char] -> Text -> IO ()
LIO.writeFile (URI -> [Char]
uriPath URI
uri) Text
gstr
| Bool
otherwise = [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char]
"Unsupported scheme for write: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ URI -> [Char]
forall a. Show a => a -> [Char]
show URI
uri
gstr :: Text
gstr = Builder -> Text
B.toLazyText Builder
gsh