{-# LANGUAGE CPP #-}
{-# LANGUAGE DoAndIfThenElse #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings #-}
module Text.RDF.RDF4H.TurtleParser
( TurtleParser (TurtleParser),
TurtleParserCustom (TurtleParserCustom),
parseTurtleDebug,
)
where
import Control.Applicative hiding (empty)
import Control.Monad
import Control.Monad.State.Class
import Control.Monad.State.Strict
import Data.Attoparsec.Text (IResult (..), parse)
import Data.Char (isDigit, isHexDigit, toLower, toUpper)
import Data.Either
import qualified Data.Foldable as F
import Data.Functor (($>))
import qualified Data.Map as Map
import Data.Map (Map)
import Data.Maybe
import Data.RDF.Graph.TList
import Data.RDF.IRI
import Data.RDF.Types
#if MIN_VERSION_base(4,9,0)
#if !MIN_VERSION_base(4,11,0)
import Data.Semigroup ((<>))
#else
#endif
#else
#endif
import Data.Sequence (Seq, (|>))
import qualified Data.Text as T
import Text.Parsec (ParseError, runParser)
import Text.Parser.Char
import Text.Parser.Combinators
import Text.Parser.LookAhead
import Text.RDF.RDF4H.NTriplesParser
import Text.RDF.RDF4H.ParserUtils
import Prelude hiding (readFile)
data TurtleParser = TurtleParser (Maybe BaseUrl) (Maybe T.Text)
data TurtleParserCustom = TurtleParserCustom (Maybe BaseUrl) (Maybe T.Text) Parser
instance RdfParser TurtleParser where
parseString :: forall a.
Rdf a =>
TurtleParser -> Text -> Either ParseFailure (RDF a)
parseString (TurtleParser Maybe BaseUrl
bUrl Maybe Text
dUrl) = Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
forall a.
Rdf a =>
Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
parseStringParsec Maybe BaseUrl
bUrl Maybe Text
dUrl
parseFile :: forall a.
Rdf a =>
TurtleParser -> String -> IO (Either ParseFailure (RDF a))
parseFile (TurtleParser Maybe BaseUrl
bUrl Maybe Text
dUrl) = Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
forall a.
Rdf a =>
Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
parseFileParsec Maybe BaseUrl
bUrl Maybe Text
dUrl
parseURL :: forall a.
Rdf a =>
TurtleParser -> String -> IO (Either ParseFailure (RDF a))
parseURL (TurtleParser Maybe BaseUrl
bUrl Maybe Text
dUrl) = Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
forall a.
Rdf a =>
Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
parseURLParsec Maybe BaseUrl
bUrl Maybe Text
dUrl
instance RdfParser TurtleParserCustom where
parseString :: forall a.
Rdf a =>
TurtleParserCustom -> Text -> Either ParseFailure (RDF a)
parseString (TurtleParserCustom Maybe BaseUrl
bUrl Maybe Text
dUrl Parser
Parsec) = Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
forall a.
Rdf a =>
Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
parseStringParsec Maybe BaseUrl
bUrl Maybe Text
dUrl
parseString (TurtleParserCustom Maybe BaseUrl
bUrl Maybe Text
dUrl Parser
Attoparsec) = Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
forall a.
Rdf a =>
Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
parseStringAttoparsec Maybe BaseUrl
bUrl Maybe Text
dUrl
parseFile :: forall a.
Rdf a =>
TurtleParserCustom -> String -> IO (Either ParseFailure (RDF a))
parseFile (TurtleParserCustom Maybe BaseUrl
bUrl Maybe Text
dUrl Parser
Parsec) = Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
forall a.
Rdf a =>
Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
parseFileParsec Maybe BaseUrl
bUrl Maybe Text
dUrl
parseFile (TurtleParserCustom Maybe BaseUrl
bUrl Maybe Text
dUrl Parser
Attoparsec) = Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
forall a.
Rdf a =>
Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
parseFileAttoparsec Maybe BaseUrl
bUrl Maybe Text
dUrl
parseURL :: forall a.
Rdf a =>
TurtleParserCustom -> String -> IO (Either ParseFailure (RDF a))
parseURL (TurtleParserCustom Maybe BaseUrl
bUrl Maybe Text
dUrl Parser
Parsec) = Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
forall a.
Rdf a =>
Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
parseURLParsec Maybe BaseUrl
bUrl Maybe Text
dUrl
parseURL (TurtleParserCustom Maybe BaseUrl
bUrl Maybe Text
dUrl Parser
Attoparsec) = Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
forall a.
Rdf a =>
Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
parseURLAttoparsec Maybe BaseUrl
bUrl Maybe Text
dUrl
type ParseState =
( Maybe BaseUrl,
Maybe T.Text,
Integer,
PrefixMappings,
Maybe Subject,
Maybe Predicate,
Seq Triple,
Map String Integer
)
parseTurtleDebug :: String -> IO (RDF TList)
parseTurtleDebug :: String -> IO (RDF TList)
parseTurtleDebug String
f = RDF TList -> Either ParseFailure (RDF TList) -> RDF TList
forall b a. b -> Either a b -> b
fromRight RDF TList
forall rdfImpl. Rdf rdfImpl => RDF rdfImpl
empty (Either ParseFailure (RDF TList) -> RDF TList)
-> IO (Either ParseFailure (RDF TList)) -> IO (RDF TList)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TurtleParserCustom
-> String -> IO (Either ParseFailure (RDF TList))
forall p a.
(RdfParser p, Rdf a) =>
p -> String -> IO (Either ParseFailure (RDF a))
forall a.
Rdf a =>
TurtleParserCustom -> String -> IO (Either ParseFailure (RDF a))
parseFile (Maybe BaseUrl -> Maybe Text -> Parser -> TurtleParserCustom
TurtleParserCustom (BaseUrl -> Maybe BaseUrl
forall a. a -> Maybe a
Just (BaseUrl -> Maybe BaseUrl)
-> (Text -> BaseUrl) -> Text -> Maybe BaseUrl
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> BaseUrl
BaseUrl (Text -> Maybe BaseUrl) -> Text -> Maybe BaseUrl
forall a b. (a -> b) -> a -> b
$ Text
"http://base-url.com/") (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"http://doc-url.com/") Parser
Attoparsec) String
f
t_turtleDoc :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m (Seq Triple, Maybe BaseUrl, PrefixMappings)
t_turtleDoc :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m (Seq Triple, Maybe BaseUrl, PrefixMappings)
t_turtleDoc =
m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_statement m [()] -> m () -> m ()
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (m ()
forall (m :: * -> *). Parsing m => m ()
eof m () -> String -> m ()
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"eof") m ()
-> m (Seq Triple, Maybe BaseUrl, PrefixMappings)
-> m (Seq Triple, Maybe BaseUrl, PrefixMappings)
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (ParseState -> (Seq Triple, Maybe BaseUrl, PrefixMappings))
-> m (Seq Triple, Maybe BaseUrl, PrefixMappings)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets (\(Maybe BaseUrl
mb_bUrl, Maybe Text
_, Integer
_, PrefixMappings
pms, Maybe Subject
_, Maybe Subject
_, Seq Triple
ts, Map String Integer
_) -> (Seq Triple
ts, Maybe BaseUrl
mb_bUrl, PrefixMappings
pms))
t_statement :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m ()
t_statement :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_statement = m ()
directive m () -> m () -> m ()
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m ()
triples m () -> m () -> m ()
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"blankline-whitespace")
where
directive :: m ()
directive =
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void
( m () -> m ()
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m ()
t_directive
m () -> m [()] -> m [()]
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"directive-whitespace2")
)
triples :: m ()
triples =
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void
( m () -> m ()
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m ()
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_triples
m () -> m [()] -> m [()]
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"triple-whitespace1")
m [()] -> m Char -> m Char
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'.' m Char -> String -> m Char
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"end-of-triple-period")
m Char -> m [()] -> m [()]
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"triple-whitespace2")
)
t_triples :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m ()
t_triples :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_triples = m () -> m ()
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m ()
subjectWithPOL m () -> m () -> m ()
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m ()
blankNodePropertyListWithPOL
where
subjectWithPOL :: m ()
subjectWithPOL = m ()
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_subject m () -> m [()] -> m [()]
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> m () -> m ()
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m ()
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_predicateObjectList m () -> m () -> m ()
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m ()
forall (m :: * -> *). MonadState ParseState m => m ()
resetSubjectPredicate
blankNodePropertyListWithPOL :: m ()
blankNodePropertyListWithPOL = m Subject
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_blankNodePropertyList m Subject -> (Subject -> m ()) -> m ()
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Subject
bn ->
m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws
m [()] -> m () -> m ()
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Maybe Subject -> Maybe Subject -> m ()
forall (m :: * -> *).
MonadState ParseState m =>
Maybe Subject -> Maybe Subject -> m ()
setSubjectPredicate (Subject -> Maybe Subject
forall a. a -> Maybe a
Just Subject
bn) Maybe Subject
forall a. Maybe a
Nothing
m () -> m (Maybe ()) -> m (Maybe ())
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m () -> m (Maybe ())
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional m ()
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_predicateObjectList
m (Maybe ()) -> m () -> m ()
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m ()
forall (m :: * -> *). MonadState ParseState m => m ()
resetSubjectPredicate
t_blankNodePropertyList :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m Node
t_blankNodePropertyList :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_blankNodePropertyList = m Subject -> m Subject
forall (m :: * -> *) a. MonadState ParseState m => m a -> m a
withConstantSubjectPredicate
(m Subject -> m Subject) -> m Subject -> m Subject
forall a b. (a -> b) -> a -> b
$ m Char -> m Char -> m Subject -> m Subject
forall (m :: * -> *) bra ket a.
Applicative m =>
m bra -> m ket -> m a -> m a
between (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'[') (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
']')
(m Subject -> m Subject) -> m Subject -> m Subject
forall a b. (a -> b) -> a -> b
$ do
Subject
bn <- m Subject
forall (m :: * -> *). MonadState ParseState m => m Subject
nextBlankNode
Maybe Subject -> Maybe Subject -> m ()
forall (m :: * -> *).
MonadState ParseState m =>
Maybe Subject -> Maybe Subject -> m ()
setSubjectPredicate (Subject -> Maybe Subject
forall a. a -> Maybe a
Just Subject
bn) Maybe Subject
forall a. Maybe a
Nothing
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> m () -> m ()
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m ()
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_predicateObjectList m () -> m [()] -> m [()]
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws)
Subject -> m Subject
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Subject
bn
t_directive :: (CharParsing m, MonadState ParseState m) => m ()
t_directive :: forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m ()
t_directive = m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m ()
t_prefixID m () -> m () -> m ()
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m ()
t_base m () -> m () -> m ()
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m ()
t_sparql_prefix m () -> m () -> m ()
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m ()
t_sparql_base
t_iri :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m T.Text
t_iri :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Text
t_iri = m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Text
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_iriref m Text -> m Text -> m Text
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Text
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Text
t_prefixedName
t_prefixedName :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m T.Text
t_prefixedName :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Text
t_prefixedName = m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Text
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Text
t_pname_ln m Text -> m Text -> m Text
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Text
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_pname_ns
t_prefixID :: (CharParsing m, MonadState ParseState m) => m ()
t_prefixID :: forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m ()
t_prefixID = do
m String -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"@prefix" m String -> String -> m String
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"@prefix-directive"))
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"whitespace-after-@prefix")
Text
pre <- Text -> m Text -> m Text
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Text
forall a. Monoid a => a
mempty (m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Text
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_pn_prefix) m Text -> m Char -> m Text
forall a b. m a -> m b -> m a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
':'
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"whitespace-after-@prefix-colon")
Text
iriFrag <- m Text
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_iriref
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"prefixID-whitespace")
m Char -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'.' m Char -> String -> m Char
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"end-of-prefixID-period")
(Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
_, PrefixMappings Map Text Text
pms, Maybe Subject
_, Maybe Subject
_, Seq Triple
_, Map String Integer
_) <- m ParseState
forall s (m :: * -> *). MonadState s m => m s
get
Text
iri <- Maybe BaseUrl -> Maybe Text -> Text -> m Text
forall (m :: * -> *).
CharParsing m =>
Maybe BaseUrl -> Maybe Text -> Text -> m Text
tryIriResolution Maybe BaseUrl
bUrl Maybe Text
dUrl Text
iriFrag
Maybe PrefixMappings -> m ()
forall (m :: * -> *).
MonadState ParseState m =>
Maybe PrefixMappings -> m ()
updatePMs (Maybe PrefixMappings -> m ()) -> Maybe PrefixMappings -> m ()
forall a b. (a -> b) -> a -> b
$ PrefixMappings -> Maybe PrefixMappings
forall a. a -> Maybe a
Just (Map Text Text -> PrefixMappings
PrefixMappings (Map Text Text -> PrefixMappings)
-> Map Text Text -> PrefixMappings
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Map Text Text -> Map Text Text
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Text
pre Text
iri Map Text Text
pms)
t_sparql_prefix :: (CharParsing m, MonadState ParseState m) => m ()
t_sparql_prefix :: forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m ()
t_sparql_prefix = do
m String -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (String -> m String
forall (m :: * -> *).
(CharParsing m, Monad m) =>
String -> m String
caseInsensitiveString String
"PREFIX" m String -> String -> m String
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"@prefix-directive"))
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"whitespace-after-PREFIX")
Text
pre <- Text -> m Text -> m Text
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Text
forall a. Monoid a => a
mempty (m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Text
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_pn_prefix) m Text -> m Char -> m Text
forall a b. m a -> m b -> m a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
':'
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"whitespace-after-PREFIX-colon")
Text
iriFrag <- m Text
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_iriref
(Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
_, PrefixMappings Map Text Text
pms, Maybe Subject
_, Maybe Subject
_, Seq Triple
_, Map String Integer
_) <- m ParseState
forall s (m :: * -> *). MonadState s m => m s
get
Text
iri <- Maybe BaseUrl -> Maybe Text -> Text -> m Text
forall (m :: * -> *).
CharParsing m =>
Maybe BaseUrl -> Maybe Text -> Text -> m Text
tryIriResolution Maybe BaseUrl
bUrl Maybe Text
dUrl Text
iriFrag
Maybe PrefixMappings -> m ()
forall (m :: * -> *).
MonadState ParseState m =>
Maybe PrefixMappings -> m ()
updatePMs (Maybe PrefixMappings -> m ()) -> Maybe PrefixMappings -> m ()
forall a b. (a -> b) -> a -> b
$ PrefixMappings -> Maybe PrefixMappings
forall a. a -> Maybe a
Just (Map Text Text -> PrefixMappings
PrefixMappings (Map Text Text -> PrefixMappings)
-> Map Text Text -> PrefixMappings
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Map Text Text -> Map Text Text
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Text
pre Text
iri Map Text Text
pms)
t_base :: (CharParsing m, MonadState ParseState m) => m ()
t_base :: forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m ()
t_base = do
m String -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"@base" m String -> String -> m String
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"@base-directive"))
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"whitespace-after-@base")
Text
iriFrag <- m Text
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_iriref
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"base-whitespace")
m Char -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'.') m () -> String -> m ()
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"end-of-base-period"
Maybe BaseUrl
bUrl <- m (Maybe BaseUrl)
forall (m :: * -> *). MonadState ParseState m => m (Maybe BaseUrl)
currBaseUrl
Maybe Text
dUrl <- m (Maybe Text)
forall (m :: * -> *). MonadState ParseState m => m (Maybe Text)
currDocUrl
BaseUrl
newBaseIri <- Text -> BaseUrl
BaseUrl (Text -> BaseUrl) -> m Text -> m BaseUrl
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe BaseUrl -> Maybe Text -> Text -> m Text
forall (m :: * -> *).
CharParsing m =>
Maybe BaseUrl -> Maybe Text -> Text -> m Text
tryIriResolution Maybe BaseUrl
bUrl Maybe Text
dUrl Text
iriFrag
Maybe (Maybe BaseUrl) -> m ()
forall (m :: * -> *).
MonadState ParseState m =>
Maybe (Maybe BaseUrl) -> m ()
updateBaseUrl (Maybe BaseUrl -> Maybe (Maybe BaseUrl)
forall a. a -> Maybe a
Just (Maybe BaseUrl -> Maybe (Maybe BaseUrl))
-> Maybe BaseUrl -> Maybe (Maybe BaseUrl)
forall a b. (a -> b) -> a -> b
$ BaseUrl -> Maybe BaseUrl
forall a. a -> Maybe a
Just BaseUrl
newBaseIri)
t_sparql_base :: (CharParsing m, MonadState ParseState m) => m ()
t_sparql_base :: forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m ()
t_sparql_base = do
m String -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (String -> m String
forall (m :: * -> *).
(CharParsing m, Monad m) =>
String -> m String
caseInsensitiveString String
"BASE" m String -> String -> m String
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"@sparql-base-directive"))
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"whitespace-after-BASE")
Text
iriFrag <- m Text
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_iriref
Maybe BaseUrl
bUrl <- m (Maybe BaseUrl)
forall (m :: * -> *). MonadState ParseState m => m (Maybe BaseUrl)
currBaseUrl
Maybe Text
dUrl <- m (Maybe Text)
forall (m :: * -> *). MonadState ParseState m => m (Maybe Text)
currDocUrl
BaseUrl
newBaseIri <- Text -> BaseUrl
BaseUrl (Text -> BaseUrl) -> m Text -> m BaseUrl
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe BaseUrl -> Maybe Text -> Text -> m Text
forall (m :: * -> *).
CharParsing m =>
Maybe BaseUrl -> Maybe Text -> Text -> m Text
tryIriResolution Maybe BaseUrl
bUrl Maybe Text
dUrl Text
iriFrag
Maybe (Maybe BaseUrl) -> m ()
forall (m :: * -> *).
MonadState ParseState m =>
Maybe (Maybe BaseUrl) -> m ()
updateBaseUrl (Maybe BaseUrl -> Maybe (Maybe BaseUrl)
forall a. a -> Maybe a
Just (Maybe BaseUrl -> Maybe (Maybe BaseUrl))
-> Maybe BaseUrl -> Maybe (Maybe BaseUrl)
forall a b. (a -> b) -> a -> b
$ BaseUrl -> Maybe BaseUrl
forall a. a -> Maybe a
Just BaseUrl
newBaseIri)
t_verb :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m ()
t_verb :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_verb = m Subject -> m Subject
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Subject
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_predicate m Subject -> m Subject -> m Subject
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'a' m Char -> Subject -> m Subject
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Subject
rdfTypeNode) m Subject -> (Subject -> m ()) -> m ()
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Subject -> m ()
forall (m :: * -> *). MonadState ParseState m => Subject -> m ()
setPredicate
t_predicate :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m Node
t_predicate :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_predicate = Text -> Subject
UNode (Text -> Subject) -> m Text -> m Subject
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (m Text
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Text
t_iri m Text -> String -> m Text
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"resource")
t_pname_ns :: (CharParsing m, MonadState ParseState m) => m T.Text
t_pname_ns :: forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_pname_ns = do
Text
pre <- Text -> m Text -> m Text
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Text
forall a. Monoid a => a
mempty (m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Text
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_pn_prefix) m Text -> m Char -> m Text
forall a b. m a -> m b -> m a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
':'
(Maybe BaseUrl
_, Maybe Text
_, Integer
_, PrefixMappings
pms, Maybe Subject
_, Maybe Subject
_, Seq Triple
_, Map String Integer
_) <- m ParseState
forall s (m :: * -> *). MonadState s m => m s
get
case Text -> PrefixMappings -> Maybe Text
resolveQName Text
pre PrefixMappings
pms of
Just Text
n -> Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
n
Maybe Text
Nothing -> String -> m Text
forall a. String -> m a
forall (m :: * -> *) a. Parsing m => String -> m a
unexpected (String
"Cannot resolve QName prefix: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Text -> String
T.unpack Text
pre)
t_pn_local :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m T.Text
t_pn_local :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Text
t_pn_local = do
String
x <- m String
t_pn_chars_u_str m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
":" m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m String
satisfy_str m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m String
forall (m :: * -> *). (CharParsing m, Monad m) => m String
t_plx
String
xs <- String -> m String -> m String
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option String
"" (m String -> m String) -> m String -> m String
forall a b. (a -> b) -> a -> b
$ m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (m String -> m String) -> m String -> m String
forall a b. (a -> b) -> a -> b
$ do
let recsve :: m String
recsve =
(m String
t_pn_chars_str m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
":" m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m String
forall (m :: * -> *). (CharParsing m, Monad m) => m String
t_plx)
m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (m String
t_pn_chars_str m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
":" m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m String
forall (m :: * -> *). (CharParsing m, Monad m) => m String
t_plx m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"." m String -> m String -> m String
forall a b. m a -> m b -> m a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead (m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m String
recsve)))
m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (m String
t_pn_chars_str m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
":" m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m String
forall (m :: * -> *). (CharParsing m, Monad m) => m String
t_plx m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"." m String -> m () -> m ()
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m () -> m ()
forall a. Show a => m a -> m ()
forall (m :: * -> *) a. (Parsing m, Show a) => m a -> m ()
notFollowedBy m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m () -> String -> m String
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> String
"."))
[String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([String] -> String) -> m [String] -> m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m String -> m [String]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m String
recsve
Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (String -> Text
T.pack (String
x String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
xs))
where
satisfy_str :: m String
satisfy_str = Char -> String
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Char -> String) -> m Char -> m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Char -> Bool) -> m Char
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m Char
satisfy Char -> Bool
isDigit
t_pn_chars_str :: m String
t_pn_chars_str = Char -> String
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Char -> String) -> m Char -> m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Char
forall (m :: * -> *). CharParsing m => m Char
t_pn_chars
t_pn_chars_u_str :: m String
t_pn_chars_u_str = Char -> String
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Char -> String) -> m Char -> m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Char
forall (m :: * -> *). CharParsing m => m Char
t_pn_chars_u
t_plx :: (CharParsing m, Monad m) => m String
t_plx :: forall (m :: * -> *). (CharParsing m, Monad m) => m String
t_plx = m String
forall (m :: * -> *). (CharParsing m, Monad m) => m String
t_percent m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m String
t_pn_local_esc_str
where
t_pn_local_esc_str :: m String
t_pn_local_esc_str = Char -> String
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Char -> String) -> m Char -> m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Char
forall (m :: * -> *). CharParsing m => m Char
t_pn_local_esc
t_percent :: (CharParsing m, Monad m) => m String
t_percent :: forall (m :: * -> *). (CharParsing m, Monad m) => m String
t_percent = [m Char] -> m String
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'%', m Char
forall (m :: * -> *). CharParsing m => m Char
t_hex, m Char
forall (m :: * -> *). CharParsing m => m Char
t_hex]
t_pn_local_esc :: CharParsing m => m Char
t_pn_local_esc :: forall (m :: * -> *). CharParsing m => m Char
t_pn_local_esc = Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'\\' m Char -> m Char -> m Char
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> String -> m Char
forall (m :: * -> *). CharParsing m => String -> m Char
oneOf String
"_~.-!$&'()*+,;=/?#@%"
t_pname_ln :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m T.Text
t_pname_ln :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Text
t_pname_ln = Text -> Text -> Text
T.append (Text -> Text -> Text) -> m Text -> m (Text -> Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Text
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_pname_ns m (Text -> Text) -> m Text -> m Text
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Text
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Text
t_pn_local
t_subject :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m ()
t_subject :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_subject = m Subject
iri m Subject -> m Subject -> m Subject
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Subject
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Subject
t_blankNode m Subject -> m Subject -> m Subject
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Subject
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_collection m Subject -> (Subject -> m ()) -> m ()
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Subject -> m ()
forall (m :: * -> *). MonadState ParseState m => Subject -> m ()
setSubject
where
iri :: m Subject
iri = Text -> Subject
unode (Text -> Subject) -> m Text -> m Subject
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Text
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Text
t_iri m Text -> String -> m Text
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"subject resource")
t_blankNode :: (CharParsing m, MonadState ParseState m) => m Node
t_blankNode :: forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Subject
t_blankNode = do
String
genID <- m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m String
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m String
t_blank_node_label m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (m ()
forall (m :: * -> *). CharParsing m => m ()
t_anon m () -> String -> m String
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> String
forall a. Monoid a => a
mempty)
Map String Integer
mp <- m (Map String Integer)
forall (m :: * -> *).
MonadState ParseState m =>
m (Map String Integer)
currGenIdLookup
m Subject -> (Integer -> m Subject) -> Maybe Integer -> m Subject
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> m Subject
forall {m :: * -> *}.
MonadState ParseState m =>
String -> m Subject
newBN String
genID) Integer -> m Subject
getExistingBN (String -> Map String Integer -> Maybe Integer
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup String
genID Map String Integer
mp)
where
newBN :: String -> m Subject
newBN String
genID = do
Integer
i <- m Integer
forall (m :: * -> *). MonadState ParseState m => m Integer
nextIdCounter
Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (String
genID String -> String -> Bool
forall a. Eq a => a -> a -> Bool
/= String
forall a. Monoid a => a
mempty) (String -> Integer -> m ()
forall (m :: * -> *).
MonadState ParseState m =>
String -> Integer -> m ()
addGenIdLookup String
genID Integer
i)
Subject -> m Subject
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Subject -> m Subject) -> Subject -> m Subject
forall a b. (a -> b) -> a -> b
$ Int -> Subject
BNodeGen (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i)
getExistingBN :: Integer -> m Subject
getExistingBN = Subject -> m Subject
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Subject -> m Subject)
-> (Integer -> Subject) -> Integer -> m Subject
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Subject
BNodeGen (Int -> Subject) -> (Integer -> Int) -> Integer -> Subject
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
t_blank_node_label :: (CharParsing m, MonadState ParseState m) => m String
t_blank_node_label :: forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m String
t_blank_node_label = do
m String -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"_:")
Char
firstChar <- m Char
forall (m :: * -> *). CharParsing m => m Char
t_pn_chars_u m Char -> m Char -> m Char
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Char -> Bool) -> m Char
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m Char
satisfy Char -> Bool
isDigit
m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (m String -> m String) -> m String -> m String
forall a b. (a -> b) -> a -> b
$ (Char
firstChar Char -> String -> String
forall a. a -> [a] -> [a]
:) (String -> String) -> m String -> m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m String
otherChars
where
otherChars :: m String
otherChars = String -> m String -> m String
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option String
"" (m String -> m String) -> m String -> m String
forall a b. (a -> b) -> a -> b
$ do
String
xs <- m Char -> m String
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (m Char
forall (m :: * -> *). CharParsing m => m Char
t_pn_chars m Char -> m Char -> m Char
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'.')
if String -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
xs
then String -> m String
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure String
xs
else
if String -> Char
forall a. HasCallStack => [a] -> a
last String
xs Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'.'
then String -> m String
forall a. String -> m a
forall (m :: * -> *) a. Parsing m => String -> m a
unexpected String
"'.' at the end of a blank node label"
else String -> m String
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure String
xs
t_anon :: CharParsing m => m ()
t_anon :: forall (m :: * -> *). CharParsing m => m ()
t_anon = m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m Char -> m Char -> m [()] -> m [()]
forall (m :: * -> *) bra ket a.
Applicative m =>
m bra -> m ket -> m a -> m a
between (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'[') (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
']') (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws))
t_predicateObjectList :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m ()
t_predicateObjectList :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_predicateObjectList = m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m [()] -> m ()) -> m [()] -> m ()
forall a b. (a -> b) -> a -> b
$ m () -> m [[()]] -> m [()]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepEndBy1 (m () -> m ()
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m ()
verbObjectList) (m [[()]] -> m [[()]]
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m [[()]]
separator)
where
verbObjectList :: m ()
verbObjectList = m ()
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_verb m () -> m [()] -> m [()]
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> m () -> m ()
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m ()
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_objectList
separator :: m [[()]]
separator = m [()] -> m [[()]]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> m Char -> m Char
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
';' m Char -> m [()] -> m [()]
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws)
t_objectList :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m ()
t_objectList :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m ()
t_objectList = do
(m Subject
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_object m Subject -> String -> m Subject
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"object") m Subject -> (Subject -> m ()) -> m ()
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Subject -> m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
Subject -> m ()
addTripleForObject
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m [()] -> m ()) -> m [()] -> m ()
forall a b. (a -> b) -> a -> b
$ m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (m () -> m ()
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> m Char -> m Char
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
',' m Char -> m [()] -> m [()]
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> m Subject -> m Subject
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m Subject
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_object m Subject -> (Subject -> m ()) -> m ()
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Subject -> m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
Subject -> m ()
addTripleForObject))
t_object :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m Node
t_object :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_object =
m Subject -> m Subject
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (Text -> Subject
UNode (Text -> Subject) -> m Text -> m Subject
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Text
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Text
t_iri)
m Subject -> m Subject -> m Subject
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Subject -> m Subject
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Subject
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Subject
t_blankNode
m Subject -> m Subject -> m Subject
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Subject -> m Subject
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Subject
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_collection
m Subject -> m Subject -> m Subject
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Subject -> m Subject
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Subject
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_blankNodePropertyList
m Subject -> m Subject -> m Subject
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Subject
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_literal
t_collection :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m Node
t_collection :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_collection = m Subject -> m Subject
forall (m :: * -> *) a. MonadState ParseState m => m a -> m a
withConstantSubjectPredicate
(m Subject -> m Subject) -> m Subject -> m Subject
forall a b. (a -> b) -> a -> b
$ m Char -> m Char -> m Subject -> m Subject
forall (m :: * -> *) bra ket a.
Applicative m =>
m bra -> m ket -> m a -> m a
between (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'(') (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
')')
(m Subject -> m Subject) -> m Subject -> m Subject
forall a b. (a -> b) -> a -> b
$ do
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws)
Subject
root <- m Subject -> m Subject
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Subject
empty_list m Subject -> m Subject -> m Subject
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Subject
non_empty_list
m [()] -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws)
Subject -> m Subject
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Subject
root
where
empty_list :: m Subject
empty_list = m Char -> m Char
forall a. m a -> m a
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
')') m Char -> Subject -> m Subject
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Subject
rdfNilNode
non_empty_list :: m Subject
non_empty_list = do
[Subject]
ns <- m Subject -> m [()] -> m [Subject]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepEndBy1 m Subject
element (m () -> m [()]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws)
Subject -> m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
Subject -> m ()
addTripleForObject Subject
rdfNilNode
Subject -> m Subject
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Subject] -> Subject
forall a. HasCallStack => [a] -> a
head [Subject]
ns)
element :: m Subject
element = do
Subject
o <- m Subject
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_object
Subject
bn <- m Subject
forall (m :: * -> *). MonadState ParseState m => m Subject
nextBlankNode
Maybe Subject
s <- m (Maybe Subject)
getSubject
Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Maybe Subject -> Bool
forall a. Maybe a -> Bool
isJust Maybe Subject
s) (Subject -> m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
Subject -> m ()
addTripleForObject Subject
bn)
Maybe Subject -> Maybe Subject -> m ()
forall (m :: * -> *).
MonadState ParseState m =>
Maybe Subject -> Maybe Subject -> m ()
setSubjectPredicate (Subject -> Maybe Subject
forall a. a -> Maybe a
Just Subject
bn) (Subject -> Maybe Subject
forall a. a -> Maybe a
Just Subject
rdfFirstNode)
Subject -> m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
Subject -> m ()
addTripleForObject Subject
o
Subject -> m ()
forall (m :: * -> *). MonadState ParseState m => Subject -> m ()
setPredicate Subject
rdfRestNode
Subject -> m Subject
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Subject
bn
getSubject :: m (Maybe Subject)
getSubject = m ParseState
forall s (m :: * -> *). MonadState s m => m s
get m ParseState
-> (ParseState -> m (Maybe Subject)) -> m (Maybe Subject)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \(Maybe BaseUrl
_, Maybe Text
_, Integer
_, PrefixMappings
_, Maybe Subject
s, Maybe Subject
_, Seq Triple
_, Map String Integer
_) -> Maybe Subject -> m (Maybe Subject)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Subject
s
t_literal :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m Node
t_literal :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Subject
t_literal =
LValue -> Subject
LNode (LValue -> Subject) -> m LValue -> m Subject
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m LValue -> m LValue
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m LValue
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m LValue
t_rdf_literal
m Subject -> m Subject -> m Subject
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Text -> Text -> Subject
`mkLNode` Text
xsdDoubleUri) (Text -> Subject) -> m Text -> m Subject
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_double
m Subject -> m Subject -> m Subject
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Text -> Text -> Subject
`mkLNode` Text
xsdDecimalUri) (Text -> Subject) -> m Text -> m Subject
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_decimal
m Subject -> m Subject -> m Subject
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Text -> Text -> Subject
`mkLNode` Text
xsdIntUri) (Text -> Subject) -> m Text -> m Subject
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_integer
m Subject -> m Subject -> m Subject
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Text -> Text -> Subject
`mkLNode` Text
xsdBooleanUri) (Text -> Subject) -> m Text -> m Subject
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Text
forall (m :: * -> *). CharParsing m => m Text
t_boolean
where
mkLNode :: T.Text -> T.Text -> Node
mkLNode :: Text -> Text -> Subject
mkLNode Text
bsType Text
bs' = LValue -> Subject
LNode (Text -> Text -> LValue
typedL Text
bsType Text
bs')
t_rdf_literal :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m LValue
t_rdf_literal :: forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m LValue
t_rdf_literal = do
Text
str <- m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_string
LValue -> m LValue -> m LValue
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option (Text -> LValue
plainL Text
str) (Text -> m LValue
forall {f :: * -> *}. (CharParsing f, Monad f) => Text -> f LValue
langTag Text
str m LValue -> m LValue -> m LValue
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Text -> m LValue
forall {f :: * -> *}.
(CharParsing f, MonadState ParseState f, LookAheadParsing f) =>
Text -> f LValue
typeIRI Text
str)
where
langTag :: Text -> f LValue
langTag Text
str = Text -> Text -> LValue
plainLL Text
str (Text -> LValue) -> f Text -> f LValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f Text -> f Text
forall a. f a -> f a
forall (m :: * -> *) a. Parsing m => m a -> m a
try f Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_langtag
typeIRI :: Text -> f LValue
typeIRI Text
str = Text -> Text -> LValue
typedL Text
str (Text -> LValue) -> f Text -> f LValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f Text -> f Text
forall a. f a -> f a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (Int -> f Char -> f String
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
count Int
2 (Char -> f Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'^') f String -> f Text -> f Text
forall a b. f a -> f b -> f b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> f Text
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m Text
t_iri)
t_string :: (CharParsing m, Monad m) => m T.Text
t_string :: forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_string =
m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_string_literal_long_double_quote
m Text -> m Text -> m Text
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_string_literal_long_single_quote
m Text -> m Text -> m Text
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_string_literal_double_quote
m Text -> m Text -> m Text
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_string_literal_single_quote
t_string_literal_double_quote :: (CharParsing m, Monad m) => m T.Text
t_string_literal_double_quote :: forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_string_literal_double_quote = m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
nt_string_literal_quote
t_string_literal_single_quote :: (CharParsing m, Monad m) => m T.Text
t_string_literal_single_quote :: forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_string_literal_single_quote = Char -> m Text
forall (m :: * -> *). (CharParsing m, Monad m) => Char -> m Text
string_literal_quote Char
'\''
t_string_literal_long_single_quote :: (CharParsing m, Monad m) => m T.Text
t_string_literal_long_single_quote :: forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_string_literal_long_single_quote = m String -> m String -> m Text -> m Text
forall (m :: * -> *) bra ket a.
Applicative m =>
m bra -> m ket -> m a -> m a
between (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"'''") (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"'''") (m Text -> m Text) -> m Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
[Text]
ss <- m Text -> m [Text]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (m Text -> m [Text]) -> m Text -> m [Text]
forall a b. (a -> b) -> a -> b
$ m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (m Text -> m Text) -> m Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Text
s1 <- String -> Text
T.pack (String -> Text) -> m String -> m Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> m String -> m String
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option String
"" (m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"''") m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"'")
Text
s2 <- Char -> Text
T.singleton (Char -> Text) -> m Char -> m Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (String -> m Char
forall (m :: * -> *). CharParsing m => String -> m Char
noneOf [Char
'\'', Char
'\\'] m Char -> m Char -> m Char
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Char
forall (m :: * -> *). (CharParsing m, Monad m) => m Char
t_echar m Char -> m Char -> m Char
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Char
forall (m :: * -> *). (CharParsing m, Monad m) => m Char
t_uchar)
Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text
s1 Text -> Text -> Text
`T.append` Text
s2)
Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Text] -> Text
T.concat [Text]
ss)
t_string_literal_long_double_quote :: (CharParsing m, Monad m) => m T.Text
t_string_literal_long_double_quote :: forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_string_literal_long_double_quote = m String -> m String -> m Text -> m Text
forall (m :: * -> *) bra ket a.
Applicative m =>
m bra -> m ket -> m a -> m a
between (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"\"\"\"") (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"\"\"\"") (m Text -> m Text) -> m Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
[Text]
ss <- m Text -> m [Text]
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (m Text -> m [Text]) -> m Text -> m [Text]
forall a b. (a -> b) -> a -> b
$ m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (m Text -> m Text) -> m Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Text
s1 <- String -> Text
T.pack (String -> Text) -> m String -> m Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> m String -> m String
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option String
"" (m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"\"\"") m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"\"")
Text
s2 <- Char -> Text
T.singleton (Char -> Text) -> m Char -> m Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (String -> m Char
forall (m :: * -> *). CharParsing m => String -> m Char
noneOf [Char
'"', Char
'\\'] m Char -> m Char -> m Char
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Char
forall (m :: * -> *). (CharParsing m, Monad m) => m Char
t_echar m Char -> m Char -> m Char
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Char
forall (m :: * -> *). (CharParsing m, Monad m) => m Char
t_uchar)
Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text
s1 Text -> Text -> Text
`T.append` Text
s2)
Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Text] -> Text
T.concat [Text]
ss)
t_langtag :: (CharParsing m, Monad m) => m T.Text
t_langtag :: forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_langtag = m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
nt_langtag
t_echar :: (CharParsing m, Monad m) => m Char
t_echar :: forall (m :: * -> *). (CharParsing m, Monad m) => m Char
t_echar = m Char
forall (m :: * -> *). (CharParsing m, Monad m) => m Char
nt_echar
t_uchar :: (CharParsing m, Monad m) => m Char
t_uchar :: forall (m :: * -> *). (CharParsing m, Monad m) => m Char
t_uchar = m Char
forall (m :: * -> *). (CharParsing m, Monad m) => m Char
nt_uchar
t_integer :: (CharParsing m, Monad m) => m T.Text
t_integer :: forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_integer = m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (m Text -> m Text) -> m Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
String
sign <- m String
forall (m :: * -> *). CharParsing m => m String
sign_parser m String -> String -> m String
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"+-"
String
ds <- m Char -> m String
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some ((Char -> Bool) -> m Char
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m Char
satisfy Char -> Bool
isDigit m Char -> String -> m Char
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"digit")
Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> m Text) -> Text -> m Text
forall a b. (a -> b) -> a -> b
$! (String -> Text
T.pack String
sign Text -> Text -> Text
`T.append` String -> Text
T.pack String
ds)
t_double :: (CharParsing m, Monad m) => m T.Text
t_double :: forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_double = do
String
sign <- m String
forall (m :: * -> *). CharParsing m => m String
sign_parser m String -> String -> m String
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"+-"
Text
rest <-
m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try
( do
String
ds <- (m Char -> m String
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some ((Char -> Bool) -> m Char
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m Char
satisfy Char -> Bool
isDigit) m String -> String -> m String
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"digit") m String -> m Char -> m String
forall a b. m a -> m b -> m a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'.'
String
ds' <- m Char -> m String
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many ((Char -> Bool) -> m Char
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m Char
satisfy Char -> Bool
isDigit) m String -> String -> m String
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"digit"
Text
e <- m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_exponent m Text -> String -> m Text
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"exponent"
Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (String -> Text
T.pack String
ds Text -> Char -> Text
`T.snoc` Char
'.' Text -> Text -> Text
`T.append` String -> Text
T.pack String
ds' Text -> Text -> Text
`T.append` Text
e)
)
m Text -> m Text -> m Text
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try
( do
String
ds <- Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'.' m Char -> m String -> m String
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m Char -> m String
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some ((Char -> Bool) -> m Char
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m Char
satisfy Char -> Bool
isDigit) m String -> String -> m String
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"digit"
Text
e <- m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_exponent m Text -> String -> m Text
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"exponent"
Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Char
'.' Char -> Text -> Text
`T.cons` String -> Text
T.pack String
ds Text -> Text -> Text
`T.append` Text
e)
)
m Text -> m Text -> m Text
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ( do
String
ds <- m Char -> m String
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some ((Char -> Bool) -> m Char
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m Char
satisfy Char -> Bool
isDigit) m String -> String -> m String
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"digit"
Text
e <- m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_exponent m Text -> String -> m Text
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"exponent"
Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (String -> Text
T.pack String
ds Text -> Text -> Text
`T.append` Text
e)
)
Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> m Text) -> Text -> m Text
forall a b. (a -> b) -> a -> b
$! String -> Text
T.pack String
sign Text -> Text -> Text
`T.append` Text
rest
sign_parser :: CharParsing m => m String
sign_parser :: forall (m :: * -> *). CharParsing m => m String
sign_parser = String -> m String -> m String
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option String
"" (Char -> String
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Char -> String) -> m Char -> m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> m Char
forall (m :: * -> *). CharParsing m => String -> m Char
oneOf String
"-+")
t_decimal :: (CharParsing m, Monad m) => m T.Text
t_decimal :: forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_decimal = m Text -> m Text
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (m Text -> m Text) -> m Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
String
sign <- m String
forall (m :: * -> *). CharParsing m => m String
sign_parser
String
dig1 <- m Char -> m String
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many ((Char -> Bool) -> m Char
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m Char
satisfy Char -> Bool
isDigit) m String -> m Char -> m String
forall a b. m a -> m b -> m a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'.'
String
dig2 <- m Char -> m String
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some ((Char -> Bool) -> m Char
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m Char
satisfy Char -> Bool
isDigit)
Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (String -> Text
T.pack String
sign Text -> Text -> Text
`T.append` String -> Text
T.pack String
dig1 Text -> Text -> Text
`T.append` String -> Text
T.pack String
"." Text -> Text -> Text
`T.append` String -> Text
T.pack String
dig2)
t_exponent :: (CharParsing m, Monad m) => m T.Text
t_exponent :: forall (m :: * -> *). (CharParsing m, Monad m) => m Text
t_exponent = do
Char
e <- String -> m Char
forall (m :: * -> *). CharParsing m => String -> m Char
oneOf String
"eE"
String
s <- String -> m String -> m String
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option String
"" (Char -> String
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Char -> String) -> m Char -> m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> m Char
forall (m :: * -> *). CharParsing m => String -> m Char
oneOf String
"-+")
String
ds <- m Char -> m String
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some m Char
forall (m :: * -> *). CharParsing m => m Char
digit
Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> m Text) -> Text -> m Text
forall a b. (a -> b) -> a -> b
$! (Char
e Char -> Text -> Text
`T.cons` (String -> Text
T.pack String
s Text -> Text -> Text
`T.append` String -> Text
T.pack String
ds))
t_boolean :: CharParsing m => m T.Text
t_boolean :: forall (m :: * -> *). CharParsing m => m Text
t_boolean = String -> Text
T.pack (String -> Text) -> m String -> m Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"true" m String -> m String -> m String
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"false")
t_comment :: CharParsing m => m ()
= m String -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'#' m Char -> m String -> m String
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m Char -> m String
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (String -> m Char
forall (m :: * -> *). CharParsing m => String -> m Char
noneOf String
"\n\r"))
t_ws :: CharParsing m => m ()
t_ws :: forall (m :: * -> *). CharParsing m => m ()
t_ws =
(m Char -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m Char -> m Char
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try (String -> m Char
forall (m :: * -> *). CharParsing m => String -> m Char
oneOf String
"\t\n\r "))) m () -> m () -> m ()
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m () -> m ()
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m ()
forall (m :: * -> *). CharParsing m => m ()
t_comment
m () -> String -> m ()
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"whitespace-or-comment"
t_pn_prefix :: (CharParsing m, MonadState ParseState m) => m T.Text
t_pn_prefix :: forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_pn_prefix = do
Char
i <- m Char -> m Char
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Char
forall (m :: * -> *). CharParsing m => m Char
t_pn_chars_base
String
r <- String -> m String -> m String
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option String
"" (m Char -> m String
forall a. m a -> m [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (m Char -> m Char
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Char
forall (m :: * -> *). CharParsing m => m Char
t_pn_chars m Char -> m Char -> m Char
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'.'))
Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (String -> Text
T.pack (Char
i Char -> String -> String
forall a. a -> [a] -> [a]
: String
r))
t_iriref :: (CharParsing m, MonadState ParseState m) => m T.Text
t_iriref :: forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_iriref = m Char -> m Char -> m Text -> m Text
forall (m :: * -> *) bra ket a.
Applicative m =>
m bra -> m ket -> m a -> m a
between (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'<') (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'>') (m Text -> m Text) -> m Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Text
iriFrag <- m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
iriFragment
Maybe BaseUrl
bUrl <- m (Maybe BaseUrl)
forall (m :: * -> *). MonadState ParseState m => m (Maybe BaseUrl)
currBaseUrl
Maybe Text
dUrl <- m (Maybe Text)
forall (m :: * -> *). MonadState ParseState m => m (Maybe Text)
currDocUrl
Maybe BaseUrl -> Maybe Text -> Text -> m Text
forall (m :: * -> *).
CharParsing m =>
Maybe BaseUrl -> Maybe Text -> Text -> m Text
tryIriResolution Maybe BaseUrl
bUrl Maybe Text
dUrl Text
iriFrag
t_pn_chars_base :: CharParsing m => m Char
t_pn_chars_base :: forall (m :: * -> *). CharParsing m => m Char
t_pn_chars_base = m Char
forall (m :: * -> *). CharParsing m => m Char
nt_pn_chars_base
t_pn_chars_u :: CharParsing m => m Char
t_pn_chars_u :: forall (m :: * -> *). CharParsing m => m Char
t_pn_chars_u = m Char
forall (m :: * -> *). CharParsing m => m Char
t_pn_chars_base m Char -> m Char -> m Char
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'_'
t_pn_chars :: CharParsing m => m Char
t_pn_chars :: forall (m :: * -> *). CharParsing m => m Char
t_pn_chars = m Char
forall (m :: * -> *). CharParsing m => m Char
t_pn_chars_u m Char -> m Char -> m Char
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'-' m Char -> m Char -> m Char
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'\x00B7' m Char -> m Char -> m Char
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Char -> Bool) -> m Char
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m Char
satisfy Char -> Bool
f
where
f :: Char -> Bool
f = (Char -> [(Char, Char)] -> Bool) -> [(Char, Char)] -> Char -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip Char -> [(Char, Char)] -> Bool
in_range [(Char
'0', Char
'9'), (Char
'\x0300', Char
'\x036F'), (Char
'\x203F', Char
'\x2040')]
t_hex :: CharParsing m => m Char
t_hex :: forall (m :: * -> *). CharParsing m => m Char
t_hex = (Char -> Bool) -> m Char
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m Char
satisfy Char -> Bool
isHexDigit m Char -> String -> m Char
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"hexadecimal digit"
{-# INLINE in_range #-}
in_range :: Char -> [(Char, Char)] -> Bool
in_range :: Char -> [(Char, Char)] -> Bool
in_range Char
c = ((Char, Char) -> Bool) -> [(Char, Char)] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (\(Char
c1, Char
c2) -> Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
c1 Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c2)
currGenIdLookup :: MonadState ParseState m => m (Map String Integer)
currGenIdLookup :: forall (m :: * -> *).
MonadState ParseState m =>
m (Map String Integer)
currGenIdLookup = (ParseState -> Map String Integer) -> m (Map String Integer)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ((ParseState -> Map String Integer) -> m (Map String Integer))
-> (ParseState -> Map String Integer) -> m (Map String Integer)
forall a b. (a -> b) -> a -> b
$ \(Maybe BaseUrl
_, Maybe Text
_, Integer
_, PrefixMappings
_, Maybe Subject
_, Maybe Subject
_, Seq Triple
_, Map String Integer
genMap) -> Map String Integer
genMap
addGenIdLookup :: MonadState ParseState m => String -> Integer -> m ()
addGenIdLookup :: forall (m :: * -> *).
MonadState ParseState m =>
String -> Integer -> m ()
addGenIdLookup String
genId Integer
counter =
(ParseState -> ParseState) -> m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((ParseState -> ParseState) -> m ())
-> (ParseState -> ParseState) -> m ()
forall a b. (a -> b) -> a -> b
$ \(Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
i, PrefixMappings
pms, Maybe Subject
s, Maybe Subject
p, Seq Triple
ts, Map String Integer
genMap) ->
(Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
i, PrefixMappings
pms, Maybe Subject
s, Maybe Subject
p, Seq Triple
ts, String -> Integer -> Map String Integer -> Map String Integer
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert String
genId Integer
counter Map String Integer
genMap)
currBaseUrl :: MonadState ParseState m => m (Maybe BaseUrl)
currBaseUrl :: forall (m :: * -> *). MonadState ParseState m => m (Maybe BaseUrl)
currBaseUrl = (ParseState -> Maybe BaseUrl) -> m (Maybe BaseUrl)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ((ParseState -> Maybe BaseUrl) -> m (Maybe BaseUrl))
-> (ParseState -> Maybe BaseUrl) -> m (Maybe BaseUrl)
forall a b. (a -> b) -> a -> b
$ \(Maybe BaseUrl
bUrl, Maybe Text
_, Integer
_, PrefixMappings
_, Maybe Subject
_, Maybe Subject
_, Seq Triple
_, Map String Integer
_) -> Maybe BaseUrl
bUrl
currDocUrl :: MonadState ParseState m => m (Maybe T.Text)
currDocUrl :: forall (m :: * -> *). MonadState ParseState m => m (Maybe Text)
currDocUrl = (ParseState -> Maybe Text) -> m (Maybe Text)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ((ParseState -> Maybe Text) -> m (Maybe Text))
-> (ParseState -> Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \(Maybe BaseUrl
_, Maybe Text
dUrl, Integer
_, PrefixMappings
_, Maybe Subject
_, Maybe Subject
_, Seq Triple
_, Map String Integer
_) -> Maybe Text
dUrl
updateBaseUrl :: MonadState ParseState m => Maybe (Maybe BaseUrl) -> m ()
updateBaseUrl :: forall (m :: * -> *).
MonadState ParseState m =>
Maybe (Maybe BaseUrl) -> m ()
updateBaseUrl Maybe (Maybe BaseUrl)
val = Maybe (Maybe BaseUrl)
-> Maybe (Integer -> Integer)
-> Maybe PrefixMappings
-> Maybe (Maybe Subject)
-> Maybe (Maybe Subject)
-> Maybe (Seq Triple)
-> m ()
forall (m :: * -> *).
MonadState ParseState m =>
Maybe (Maybe BaseUrl)
-> Maybe (Integer -> Integer)
-> Maybe PrefixMappings
-> Maybe (Maybe Subject)
-> Maybe (Maybe Subject)
-> Maybe (Seq Triple)
-> m ()
_modifyState Maybe (Maybe BaseUrl)
val Maybe (Integer -> Integer)
forall a. Maybe a
no Maybe PrefixMappings
forall a. Maybe a
no Maybe (Maybe Subject)
forall a. Maybe a
no Maybe (Maybe Subject)
forall a. Maybe a
no Maybe (Seq Triple)
forall a. Maybe a
no
nextIdCounter :: MonadState ParseState m => m Integer
nextIdCounter :: forall (m :: * -> *). MonadState ParseState m => m Integer
nextIdCounter = m ParseState
forall s (m :: * -> *). MonadState s m => m s
get m ParseState -> (ParseState -> m Integer) -> m Integer
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \(Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
i, PrefixMappings
pms, Maybe Subject
s, Maybe Subject
p, Seq Triple
ts, Map String Integer
genMap) ->
ParseState -> m ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
i Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
1, PrefixMappings
pms, Maybe Subject
s, Maybe Subject
p, Seq Triple
ts, Map String Integer
genMap) m () -> Integer -> m Integer
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Integer
i
nextBlankNode :: MonadState ParseState m => m Node
nextBlankNode :: forall (m :: * -> *). MonadState ParseState m => m Subject
nextBlankNode = Int -> Subject
BNodeGen (Int -> Subject) -> (Integer -> Int) -> Integer -> Subject
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Subject) -> m Integer -> m Subject
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Integer
forall (m :: * -> *). MonadState ParseState m => m Integer
nextIdCounter
updatePMs :: MonadState ParseState m => Maybe PrefixMappings -> m ()
updatePMs :: forall (m :: * -> *).
MonadState ParseState m =>
Maybe PrefixMappings -> m ()
updatePMs Maybe PrefixMappings
val = Maybe (Maybe BaseUrl)
-> Maybe (Integer -> Integer)
-> Maybe PrefixMappings
-> Maybe (Maybe Subject)
-> Maybe (Maybe Subject)
-> Maybe (Seq Triple)
-> m ()
forall (m :: * -> *).
MonadState ParseState m =>
Maybe (Maybe BaseUrl)
-> Maybe (Integer -> Integer)
-> Maybe PrefixMappings
-> Maybe (Maybe Subject)
-> Maybe (Maybe Subject)
-> Maybe (Seq Triple)
-> m ()
_modifyState Maybe (Maybe BaseUrl)
forall a. Maybe a
no Maybe (Integer -> Integer)
forall a. Maybe a
no Maybe PrefixMappings
val Maybe (Maybe Subject)
forall a. Maybe a
no Maybe (Maybe Subject)
forall a. Maybe a
no Maybe (Seq Triple)
forall a. Maybe a
no
no :: Maybe a
no :: forall a. Maybe a
no = Maybe a
forall a. Maybe a
Nothing
withConstantSubjectPredicate :: MonadState ParseState m => m a -> m a
withConstantSubjectPredicate :: forall (m :: * -> *) a. MonadState ParseState m => m a -> m a
withConstantSubjectPredicate m a
a = do
(Maybe BaseUrl
_, Maybe Text
_, Integer
_, PrefixMappings
_, Maybe Subject
s, Maybe Subject
p, Seq Triple
_, Map String Integer
_) <- m ParseState
forall s (m :: * -> *). MonadState s m => m s
get
a
a' <- m a
a
(Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
n, PrefixMappings
pms, Maybe Subject
_, Maybe Subject
_, Seq Triple
ts, Map String Integer
genMap) <- m ParseState
forall s (m :: * -> *). MonadState s m => m s
get
ParseState -> m ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
n, PrefixMappings
pms, Maybe Subject
s, Maybe Subject
p, Seq Triple
ts, Map String Integer
genMap)
a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
a'
setSubjectPredicate :: MonadState ParseState m => Maybe Subject -> Maybe Predicate -> m ()
setSubjectPredicate :: forall (m :: * -> *).
MonadState ParseState m =>
Maybe Subject -> Maybe Subject -> m ()
setSubjectPredicate Maybe Subject
s Maybe Subject
p =
(ParseState -> ParseState) -> m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((ParseState -> ParseState) -> m ())
-> (ParseState -> ParseState) -> m ()
forall a b. (a -> b) -> a -> b
$ \(Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
n, PrefixMappings
pms, Maybe Subject
_, Maybe Subject
_, Seq Triple
ts, Map String Integer
genMap) ->
(Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
n, PrefixMappings
pms, Maybe Subject
s, Maybe Subject
p, Seq Triple
ts, Map String Integer
genMap)
setSubject :: MonadState ParseState m => Subject -> m ()
setSubject :: forall (m :: * -> *). MonadState ParseState m => Subject -> m ()
setSubject Subject
s =
(ParseState -> ParseState) -> m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((ParseState -> ParseState) -> m ())
-> (ParseState -> ParseState) -> m ()
forall a b. (a -> b) -> a -> b
$ \(Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
n, PrefixMappings
pms, Maybe Subject
_, Maybe Subject
p, Seq Triple
ts, Map String Integer
genMap) ->
(Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
n, PrefixMappings
pms, Subject -> Maybe Subject
forall a. a -> Maybe a
Just Subject
s, Maybe Subject
p, Seq Triple
ts, Map String Integer
genMap)
setPredicate :: MonadState ParseState m => Predicate -> m ()
setPredicate :: forall (m :: * -> *). MonadState ParseState m => Subject -> m ()
setPredicate Subject
p =
(ParseState -> ParseState) -> m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((ParseState -> ParseState) -> m ())
-> (ParseState -> ParseState) -> m ()
forall a b. (a -> b) -> a -> b
$ \(Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
n, PrefixMappings
pms, Maybe Subject
s, Maybe Subject
_, Seq Triple
ts, Map String Integer
genMap) ->
(Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
n, PrefixMappings
pms, Maybe Subject
s, Subject -> Maybe Subject
forall a. a -> Maybe a
Just Subject
p, Seq Triple
ts, Map String Integer
genMap)
resetSubjectPredicate :: MonadState ParseState m => m ()
resetSubjectPredicate :: forall (m :: * -> *). MonadState ParseState m => m ()
resetSubjectPredicate = Maybe Subject -> Maybe Subject -> m ()
forall (m :: * -> *).
MonadState ParseState m =>
Maybe Subject -> Maybe Subject -> m ()
setSubjectPredicate Maybe Subject
forall a. Maybe a
Nothing Maybe Subject
forall a. Maybe a
Nothing
_modifyState ::
MonadState ParseState m =>
Maybe (Maybe BaseUrl) ->
Maybe (Integer -> Integer) ->
Maybe PrefixMappings ->
Maybe (Maybe Subject) ->
Maybe (Maybe Predicate) ->
Maybe (Seq Triple) ->
m ()
_modifyState :: forall (m :: * -> *).
MonadState ParseState m =>
Maybe (Maybe BaseUrl)
-> Maybe (Integer -> Integer)
-> Maybe PrefixMappings
-> Maybe (Maybe Subject)
-> Maybe (Maybe Subject)
-> Maybe (Seq Triple)
-> m ()
_modifyState Maybe (Maybe BaseUrl)
mb_bUrl Maybe (Integer -> Integer)
mb_n Maybe PrefixMappings
mb_pms Maybe (Maybe Subject)
mb_subj Maybe (Maybe Subject)
mb_pred Maybe (Seq Triple)
mb_trps = do
(Maybe BaseUrl
_bUrl, Maybe Text
_dUrl, Integer
_n, PrefixMappings
_pms, Maybe Subject
_s, Maybe Subject
_p, Seq Triple
_ts, Map String Integer
genMap) <- m ParseState
forall s (m :: * -> *). MonadState s m => m s
get
ParseState -> m ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put
( Maybe BaseUrl -> Maybe (Maybe BaseUrl) -> Maybe BaseUrl
forall a. a -> Maybe a -> a
fromMaybe Maybe BaseUrl
_bUrl Maybe (Maybe BaseUrl)
mb_bUrl,
Maybe Text
_dUrl,
Integer
-> ((Integer -> Integer) -> Integer)
-> Maybe (Integer -> Integer)
-> Integer
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Integer
_n (Integer -> (Integer -> Integer) -> Integer
forall a b. a -> b -> a
const Integer
_n) Maybe (Integer -> Integer)
mb_n,
PrefixMappings -> Maybe PrefixMappings -> PrefixMappings
forall a. a -> Maybe a -> a
fromMaybe PrefixMappings
_pms Maybe PrefixMappings
mb_pms,
Maybe Subject
-> (Maybe Subject -> Maybe Subject)
-> Maybe (Maybe Subject)
-> Maybe Subject
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Maybe Subject
_s (Maybe Subject -> Maybe Subject -> Maybe Subject
forall a b. a -> b -> a
const Maybe Subject
_s) Maybe (Maybe Subject)
mb_subj,
Maybe Subject
-> (Maybe Subject -> Maybe Subject)
-> Maybe (Maybe Subject)
-> Maybe Subject
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Maybe Subject
_p (Maybe Subject -> Maybe Subject -> Maybe Subject
forall a b. a -> b -> a
const Maybe Subject
_p) Maybe (Maybe Subject)
mb_pred,
Seq Triple -> Maybe (Seq Triple) -> Seq Triple
forall a. a -> Maybe a -> a
fromMaybe Seq Triple
_ts Maybe (Seq Triple)
mb_trps,
Map String Integer
genMap
)
addTripleForObject :: (CharParsing m, MonadState ParseState m) => Object -> m ()
addTripleForObject :: forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
Subject -> m ()
addTripleForObject Subject
obj = do
(Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
i, PrefixMappings
pms, Maybe Subject
s, Maybe Subject
p, Seq Triple
ts, Map String Integer
genMap) <- m ParseState
forall s (m :: * -> *). MonadState s m => m s
get
Triple
t <- Maybe Subject -> Maybe Subject -> m Triple
forall {m :: * -> *}.
Parsing m =>
Maybe Subject -> Maybe Subject -> m Triple
getTriple Maybe Subject
s Maybe Subject
p
ParseState -> m ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Maybe BaseUrl
bUrl, Maybe Text
dUrl, Integer
i, PrefixMappings
pms, Maybe Subject
s, Maybe Subject
p, Seq Triple
ts Seq Triple -> Triple -> Seq Triple
forall a. Seq a -> a -> Seq a
|> Triple
t, Map String Integer
genMap)
where
getTriple :: Maybe Subject -> Maybe Subject -> m Triple
getTriple Maybe Subject
Nothing Maybe Subject
_ = String -> m Triple
forall a. String -> m a
forall (m :: * -> *) a. Parsing m => String -> m a
unexpected (String -> m Triple) -> String -> m Triple
forall a b. (a -> b) -> a -> b
$ String
"No Subject with which to create triple for: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Subject -> String
forall a. Show a => a -> String
show Subject
obj
getTriple Maybe Subject
_ Maybe Subject
Nothing = String -> m Triple
forall a. String -> m a
forall (m :: * -> *) a. Parsing m => String -> m a
unexpected (String -> m Triple) -> String -> m Triple
forall a b. (a -> b) -> a -> b
$ String
"No Predicate with which to create triple for: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Subject -> String
forall a. Show a => a -> String
show Subject
obj
getTriple (Just Subject
s') (Just Subject
p') = Triple -> m Triple
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Triple -> m Triple) -> Triple -> m Triple
forall a b. (a -> b) -> a -> b
$ Subject -> Subject -> Subject -> Triple
Triple Subject
s' Subject
p' Subject
obj
parseURLParsec ::
(Rdf a) =>
Maybe BaseUrl ->
Maybe T.Text ->
String ->
IO (Either ParseFailure (RDF a))
parseURLParsec :: forall a.
Rdf a =>
Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
parseURLParsec Maybe BaseUrl
bUrl Maybe Text
docUrl = (Text -> Either ParseFailure (RDF a))
-> String -> IO (Either ParseFailure (RDF a))
forall rdfImpl.
(Text -> Either ParseFailure (RDF rdfImpl))
-> String -> IO (Either ParseFailure (RDF rdfImpl))
parseFromURL (Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
forall a.
Rdf a =>
Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
parseStringParsec Maybe BaseUrl
bUrl Maybe Text
docUrl)
parseFileParsec :: (Rdf a) => Maybe BaseUrl -> Maybe T.Text -> String -> IO (Either ParseFailure (RDF a))
parseFileParsec :: forall a.
Rdf a =>
Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
parseFileParsec Maybe BaseUrl
bUrl Maybe Text
docUrl String
fpath =
String -> IO Text
readFile String
fpath IO Text
-> (Text -> IO (Either ParseFailure (RDF a)))
-> IO (Either ParseFailure (RDF a))
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
c -> Either ParseFailure (RDF a) -> IO (Either ParseFailure (RDF a))
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either ParseFailure (RDF a) -> IO (Either ParseFailure (RDF a)))
-> Either ParseFailure (RDF a) -> IO (Either ParseFailure (RDF a))
forall a b. (a -> b) -> a -> b
$ Maybe BaseUrl
-> Either ParseError (Seq Triple, Maybe BaseUrl, PrefixMappings)
-> Either ParseFailure (RDF a)
forall a.
Rdf a =>
Maybe BaseUrl
-> Either ParseError (Seq Triple, Maybe BaseUrl, PrefixMappings)
-> Either ParseFailure (RDF a)
handleResult Maybe BaseUrl
bUrl (Parsec Text () (Seq Triple, Maybe BaseUrl, PrefixMappings)
-> ()
-> String
-> Text
-> Either ParseError (Seq Triple, Maybe BaseUrl, PrefixMappings)
forall s t u a.
Stream s Identity t =>
Parsec s u a -> u -> String -> s -> Either ParseError a
runParser (StateT
ParseState
(ParsecT Text () Identity)
(Seq Triple, Maybe BaseUrl, PrefixMappings)
-> ParseState
-> Parsec Text () (Seq Triple, Maybe BaseUrl, PrefixMappings)
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT StateT
ParseState
(ParsecT Text () Identity)
(Seq Triple, Maybe BaseUrl, PrefixMappings)
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m (Seq Triple, Maybe BaseUrl, PrefixMappings)
t_turtleDoc (Maybe BaseUrl -> Maybe Text -> ParseState
initialState Maybe BaseUrl
bUrl Maybe Text
docUrl)) () (String -> (Text -> String) -> Maybe Text -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe String
"" Text -> String
T.unpack Maybe Text
docUrl) Text
c)
parseStringParsec :: (Rdf a) => Maybe BaseUrl -> Maybe T.Text -> T.Text -> Either ParseFailure (RDF a)
parseStringParsec :: forall a.
Rdf a =>
Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
parseStringParsec Maybe BaseUrl
bUrl Maybe Text
docUrl Text
ttlStr = Maybe BaseUrl
-> Either ParseError (Seq Triple, Maybe BaseUrl, PrefixMappings)
-> Either ParseFailure (RDF a)
forall a.
Rdf a =>
Maybe BaseUrl
-> Either ParseError (Seq Triple, Maybe BaseUrl, PrefixMappings)
-> Either ParseFailure (RDF a)
handleResult Maybe BaseUrl
bUrl (Parsec Text () (Seq Triple, Maybe BaseUrl, PrefixMappings)
-> ()
-> String
-> Text
-> Either ParseError (Seq Triple, Maybe BaseUrl, PrefixMappings)
forall s t u a.
Stream s Identity t =>
Parsec s u a -> u -> String -> s -> Either ParseError a
runParser (StateT
ParseState
(ParsecT Text () Identity)
(Seq Triple, Maybe BaseUrl, PrefixMappings)
-> ParseState
-> Parsec Text () (Seq Triple, Maybe BaseUrl, PrefixMappings)
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT StateT
ParseState
(ParsecT Text () Identity)
(Seq Triple, Maybe BaseUrl, PrefixMappings)
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m (Seq Triple, Maybe BaseUrl, PrefixMappings)
t_turtleDoc (Maybe BaseUrl -> Maybe Text -> ParseState
initialState Maybe BaseUrl
bUrl Maybe Text
docUrl)) () String
"" Text
ttlStr)
parseStringAttoparsec :: (Rdf a) => Maybe BaseUrl -> Maybe T.Text -> T.Text -> Either ParseFailure (RDF a)
parseStringAttoparsec :: forall a.
Rdf a =>
Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
parseStringAttoparsec Maybe BaseUrl
bUrl Maybe Text
docUrl Text
t = IResult Text (Seq Triple, Maybe BaseUrl, PrefixMappings)
-> Either ParseFailure (RDF a)
forall {i} {rdfImpl} {t :: * -> *}.
(Monoid i, Rdf rdfImpl, Foldable t) =>
IResult i (t Triple, Maybe BaseUrl, PrefixMappings)
-> Either ParseFailure (RDF rdfImpl)
handleResult' (IResult Text (Seq Triple, Maybe BaseUrl, PrefixMappings)
-> Either ParseFailure (RDF a))
-> IResult Text (Seq Triple, Maybe BaseUrl, PrefixMappings)
-> Either ParseFailure (RDF a)
forall a b. (a -> b) -> a -> b
$ Parser (Seq Triple, Maybe BaseUrl, PrefixMappings)
-> Text -> IResult Text (Seq Triple, Maybe BaseUrl, PrefixMappings)
forall a. Parser a -> Text -> Result a
parse (StateT
ParseState
(Parser Text)
(Seq Triple, Maybe BaseUrl, PrefixMappings)
-> ParseState -> Parser (Seq Triple, Maybe BaseUrl, PrefixMappings)
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT StateT
ParseState
(Parser Text)
(Seq Triple, Maybe BaseUrl, PrefixMappings)
forall (m :: * -> *).
(MonadState ParseState m, CharParsing m, LookAheadParsing m) =>
m (Seq Triple, Maybe BaseUrl, PrefixMappings)
t_turtleDoc (Maybe BaseUrl -> Maybe Text -> ParseState
initialState Maybe BaseUrl
bUrl Maybe Text
docUrl)) Text
t
where
handleResult' :: IResult i (t Triple, Maybe BaseUrl, PrefixMappings)
-> Either ParseFailure (RDF rdfImpl)
handleResult' IResult i (t Triple, Maybe BaseUrl, PrefixMappings)
res = case IResult i (t Triple, Maybe BaseUrl, PrefixMappings)
res of
Fail i
_ [String]
_ String
err ->
ParseFailure -> Either ParseFailure (RDF rdfImpl)
forall a b. a -> Either a b
Left (ParseFailure -> Either ParseFailure (RDF rdfImpl))
-> ParseFailure -> Either ParseFailure (RDF rdfImpl)
forall a b. (a -> b) -> a -> b
$ String -> ParseFailure
ParseFailure (String -> ParseFailure) -> String -> ParseFailure
forall a b. (a -> b) -> a -> b
$ String
"Parse failure: \n" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String -> String
forall a. Show a => a -> String
show String
err
Partial i -> IResult i (t Triple, Maybe BaseUrl, PrefixMappings)
f -> IResult i (t Triple, Maybe BaseUrl, PrefixMappings)
-> Either ParseFailure (RDF rdfImpl)
handleResult' (i -> IResult i (t Triple, Maybe BaseUrl, PrefixMappings)
f i
forall a. Monoid a => a
mempty)
Done i
_ (t Triple
ts, Maybe BaseUrl
mb_bUrl, PrefixMappings
pms) ->
let chosenBaseUrl :: Maybe BaseUrl
chosenBaseUrl =
if Maybe BaseUrl -> Bool
forall a. Maybe a -> Bool
isJust Maybe BaseUrl
mb_bUrl
then Maybe BaseUrl
mb_bUrl
else Maybe BaseUrl
bUrl
in RDF rdfImpl -> Either ParseFailure (RDF rdfImpl)
forall a b. b -> Either a b
Right (RDF rdfImpl -> Either ParseFailure (RDF rdfImpl))
-> RDF rdfImpl -> Either ParseFailure (RDF rdfImpl)
forall a b. (a -> b) -> a -> b
$! Triples -> Maybe BaseUrl -> PrefixMappings -> RDF rdfImpl
forall rdfImpl.
Rdf rdfImpl =>
Triples -> Maybe BaseUrl -> PrefixMappings -> RDF rdfImpl
mkRdf (t Triple -> Triples
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList t Triple
ts) Maybe BaseUrl
chosenBaseUrl PrefixMappings
pms
parseFileAttoparsec :: (Rdf a) => Maybe BaseUrl -> Maybe T.Text -> String -> IO (Either ParseFailure (RDF a))
parseFileAttoparsec :: forall a.
Rdf a =>
Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
parseFileAttoparsec Maybe BaseUrl
bUrl Maybe Text
docUrl String
path = Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
forall a.
Rdf a =>
Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
parseStringAttoparsec Maybe BaseUrl
bUrl Maybe Text
docUrl (Text -> Either ParseFailure (RDF a))
-> IO Text -> IO (Either ParseFailure (RDF a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> IO Text
readFile String
path
parseURLAttoparsec ::
(Rdf a) =>
Maybe BaseUrl ->
Maybe T.Text ->
String ->
IO (Either ParseFailure (RDF a))
parseURLAttoparsec :: forall a.
Rdf a =>
Maybe BaseUrl
-> Maybe Text -> String -> IO (Either ParseFailure (RDF a))
parseURLAttoparsec Maybe BaseUrl
bUrl Maybe Text
docUrl = (Text -> Either ParseFailure (RDF a))
-> String -> IO (Either ParseFailure (RDF a))
forall rdfImpl.
(Text -> Either ParseFailure (RDF rdfImpl))
-> String -> IO (Either ParseFailure (RDF rdfImpl))
parseFromURL (Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
forall a.
Rdf a =>
Maybe BaseUrl -> Maybe Text -> Text -> Either ParseFailure (RDF a)
parseStringAttoparsec Maybe BaseUrl
bUrl Maybe Text
docUrl)
initialState :: Maybe BaseUrl -> Maybe T.Text -> ParseState
initialState :: Maybe BaseUrl -> Maybe Text -> ParseState
initialState Maybe BaseUrl
bUrl Maybe Text
docUrl = (Text -> BaseUrl
BaseUrl (Text -> BaseUrl) -> Maybe Text -> Maybe BaseUrl
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
docUrl Maybe BaseUrl -> Maybe BaseUrl -> Maybe BaseUrl
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe BaseUrl
bUrl, Maybe Text
docUrl, Integer
1, Map Text Text -> PrefixMappings
PrefixMappings Map Text Text
forall a. Monoid a => a
mempty, Maybe Subject
forall a. Maybe a
Nothing, Maybe Subject
forall a. Maybe a
Nothing, Seq Triple
forall a. Monoid a => a
mempty, Map String Integer
forall a. Monoid a => a
mempty)
handleResult :: Rdf a => Maybe BaseUrl -> Either ParseError (Seq Triple, Maybe BaseUrl, PrefixMappings) -> Either ParseFailure (RDF a)
handleResult :: forall a.
Rdf a =>
Maybe BaseUrl
-> Either ParseError (Seq Triple, Maybe BaseUrl, PrefixMappings)
-> Either ParseFailure (RDF a)
handleResult Maybe BaseUrl
bUrl Either ParseError (Seq Triple, Maybe BaseUrl, PrefixMappings)
result = case Either ParseError (Seq Triple, Maybe BaseUrl, PrefixMappings)
result of
(Left ParseError
err) -> ParseFailure -> Either ParseFailure (RDF a)
forall a b. a -> Either a b
Left (String -> ParseFailure
ParseFailure (String -> ParseFailure) -> String -> ParseFailure
forall a b. (a -> b) -> a -> b
$ String
"Parse failure: \n" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> ParseError -> String
forall a. Show a => a -> String
show ParseError
err)
(Right (Seq Triple
ts, Maybe BaseUrl
mb_bUrl, PrefixMappings
pms)) ->
let chosenBaseUrl :: Maybe BaseUrl
chosenBaseUrl =
if Maybe BaseUrl -> Bool
forall a. Maybe a -> Bool
isJust Maybe BaseUrl
mb_bUrl
then Maybe BaseUrl
mb_bUrl
else Maybe BaseUrl
bUrl
in RDF a -> Either ParseFailure (RDF a)
forall a b. b -> Either a b
Right (RDF a -> Either ParseFailure (RDF a))
-> RDF a -> Either ParseFailure (RDF a)
forall a b. (a -> b) -> a -> b
$! Triples -> Maybe BaseUrl -> PrefixMappings -> RDF a
forall rdfImpl.
Rdf rdfImpl =>
Triples -> Maybe BaseUrl -> PrefixMappings -> RDF rdfImpl
mkRdf (Seq Triple -> Triples
forall a. Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList Seq Triple
ts) Maybe BaseUrl
chosenBaseUrl PrefixMappings
pms
caseInsensitiveChar :: CharParsing m => Char -> m Char
caseInsensitiveChar :: forall (m :: * -> *). CharParsing m => Char -> m Char
caseInsensitiveChar Char
c = Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char (Char -> Char
toLower Char
c) m Char -> m Char -> m Char
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char (Char -> Char
toUpper Char
c)
caseInsensitiveString :: (CharParsing m, Monad m) => String -> m String
caseInsensitiveString :: forall (m :: * -> *).
(CharParsing m, Monad m) =>
String -> m String
caseInsensitiveString String
s = m String -> m String
forall a. m a -> m a
forall (m :: * -> *) a. Parsing m => m a -> m a
try ((Char -> m Char) -> String -> m String
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 Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
caseInsensitiveChar String
s) m String -> String -> m String
forall a. m a -> String -> m a
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"\"" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
s String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"\""
tryIriResolution :: (CharParsing m) => Maybe BaseUrl -> Maybe T.Text -> T.Text -> m T.Text
tryIriResolution :: forall (m :: * -> *).
CharParsing m =>
Maybe BaseUrl -> Maybe Text -> Text -> m Text
tryIriResolution Maybe BaseUrl
mbUrl Maybe Text
mdUrl Text
iriFrag = Maybe BaseUrl -> Maybe Text -> m Text
forall {m :: * -> *}.
Parsing m =>
Maybe BaseUrl -> Maybe Text -> m Text
tryIriResolution' Maybe BaseUrl
mbUrl Maybe Text
mdUrl
where
tryIriResolution' :: Maybe BaseUrl -> Maybe Text -> m Text
tryIriResolution' (Just (BaseUrl Text
bIri)) Maybe Text
_ = (String -> m Text)
-> (Text -> m Text) -> Either String Text -> m Text
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either String -> m Text
forall {m :: * -> *} {a}. Parsing m => String -> m a
err Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> Text -> Either String Text
resolveIRI Text
bIri Text
iriFrag)
tryIriResolution' Maybe BaseUrl
_ (Just Text
dIri) = (String -> m Text)
-> (Text -> m Text) -> Either String Text -> m Text
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either String -> m Text
forall {m :: * -> *} {a}. Parsing m => String -> m a
err Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> Text -> Either String Text
resolveIRI Text
dIri Text
iriFrag)
tryIriResolution' Maybe BaseUrl
_ Maybe Text
_ = (String -> m Text)
-> (Text -> m Text) -> Either String Text -> m Text
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either String -> m Text
forall {m :: * -> *} {a}. Parsing m => String -> m a
err Text -> m Text
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> Text -> Either String Text
resolveIRI Text
forall a. Monoid a => a
mempty Text
iriFrag)
err :: String -> m a
err String
m = String -> m a
forall a. String -> m a
forall (m :: * -> *) a. Parsing m => String -> m a
unexpected (String -> m a) -> String -> m a
forall a b. (a -> b) -> a -> b
$ [String] -> String
forall a. Monoid a => [a] -> a
mconcat [String
"Cannot resolve IRI: ", String
m, String
" ", (Maybe BaseUrl, Maybe Text, Text) -> String
forall a. Show a => a -> String
show (Maybe BaseUrl
mbUrl, Maybe Text
mdUrl, Text
iriFrag)]