{-# LANGUAGE CPP #-}
{-# LANGUAGE DoAndIfThenElse #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings #-}

-- | An 'RdfParser' implementation for the Turtle format
--  <http://www.w3.org/TeamSubmission/turtle/>.
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)

-- | An 'RdfParser' implementation for parsing RDF in the
--  Turtle format. It is an implementation of W3C Turtle grammar rules at
--  http://www.w3.org/TR/turtle/#sec-grammar-grammar .
--  It takes optional arguments representing the base URL to use
--  for resolving relative URLs in the document (may be overridden in the document
--  itself using the \@base directive), and the URL to use for the document itself
--  for resolving references to <> in the document.
--  To use this parser, pass a 'TurtleParser' value as the first argument to any of
--  the 'parseString', 'parseFile', or 'parseURL' methods of the 'RdfParser' type
--  class.
data TurtleParser = TurtleParser (Maybe BaseUrl) (Maybe T.Text)

data TurtleParserCustom = TurtleParserCustom (Maybe BaseUrl) (Maybe T.Text) Parser

-- | 'TurtleParser' is an instance of 'RdfParser' using a parsec based parser.
instance RdfParser TurtleParser where
  parseString :: 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 :: 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 :: 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

-- | 'TurtleParser' is an instance of 'RdfParser' using either a
--  parsec or an attoparsec based parser.
instance RdfParser TurtleParserCustom where
  parseString :: 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 :: 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 :: 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, -- the current BaseUrl, may be Nothing initially, but not after it is once set
    Maybe T.Text, -- the docUrl, which never changes and is used to resolve <> in the document.
    Integer, -- the id counter, containing the value of the next id to be used
    PrefixMappings, -- the mappings from prefix to URI that are encountered while parsing
    Maybe Subject, -- current subject node, if we have parsed a subject but not finished the triple
    Maybe Predicate, -- current predicate node, if we have parsed a predicate but not finished the triple
    Seq Triple, -- the triples encountered while parsing; always added to on the right side
    Map String Integer -- map blank node names to generated id.
  )

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))
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

-- grammar rule: [1] turtleDoc
t_turtleDoc :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m (Seq Triple, Maybe BaseUrl, PrefixMappings)
t_turtleDoc :: m (Seq Triple, Maybe BaseUrl, PrefixMappings)
t_turtleDoc =
  m () -> m [()]
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 (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (m ()
forall (m :: * -> *). Parsing m => m ()
eof m () -> String -> m ()
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 (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))

-- grammar rule: [2] statement
-- [2] statement ::= directive | triples '.'
t_statement :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m ()
t_statement :: m ()
t_statement = m ()
directive m () -> m () -> m ()
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m ()
triples m () -> m () -> m ()
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 (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
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 (m :: * -> *) a. Parsing m => m a -> m a
try m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m ()
t_directive
            m () -> m [()] -> m [()]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (m () -> m [()]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
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 (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 (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (m () -> m [()]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"triple-whitespace1")
            m [()] -> m Char -> m Char
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 (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"end-of-triple-period")
            m Char -> m [()] -> m [()]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (m () -> m [()]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"triple-whitespace2")
        )

-- grammar rule: [6] triples
-- subject predicateObjectList | blankNodePropertyList predicateObjectList?
t_triples :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m ()
t_triples :: m ()
t_triples = m () -> m ()
forall (m :: * -> *) a. Parsing m => m a -> m a
try m ()
subjectWithPOL m () -> m () -> m ()
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 (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m () -> m [()]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> m () -> m ()
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 (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 (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Subject
bn ->
      m () -> m [()]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws
        m [()] -> m () -> m ()
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 (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 (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m ()
forall (m :: * -> *). MonadState ParseState m => m ()
resetSubjectPredicate

-- [14]	blankNodePropertyList ::= '[' predicateObjectList ']'
t_blankNodePropertyList :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m Node
t_blankNodePropertyList :: 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 (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> m () -> m ()
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 (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m () -> m [()]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws)
    Subject -> m Subject
forall (m :: * -> *) a. Monad m => a -> m a
return Subject
bn

-- grammar rule: [3] directive
t_directive :: (CharParsing m, MonadState ParseState m) => m ()
t_directive :: m ()
t_directive = m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m ()
t_prefixID m () -> m () -> m ()
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 (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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m ()
t_sparql_base

-- grammar rule: [135s] iri ::= IRIREF | PrefixedName
t_iri :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m T.Text
t_iri :: m Text
t_iri = m Text -> m Text
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 (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

-- grammar rule: [136s] PrefixedName ::= PNAME_LN | PNAME_NS
t_prefixedName :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m T.Text
t_prefixedName :: m Text
t_prefixedName = m Text -> m Text
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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Text
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
m Text
t_pname_ns

-- grammar rule: [4] prefixID ::= '@prefix' PNAME_NS IRIREF '.'
t_prefixID :: (CharParsing m, MonadState ParseState m) => m ()
t_prefixID :: m ()
t_prefixID = do
  m String -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m String -> m String
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 (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 (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
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 (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 (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 (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
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 (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
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 (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)

-- grammar rule: [6s] sparqlPrefix ::= "PREFIX" PNAME_NS IRIREF
t_sparql_prefix :: (CharParsing m, MonadState ParseState m) => m ()
t_sparql_prefix :: m ()
t_sparql_prefix = do
  m String -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m String -> m String
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 (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 (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
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 (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 (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 (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
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)

-- grammar rule: [5] base ::= '@base' IRIREF '.'
t_base :: (CharParsing m, MonadState ParseState m) => m ()
t_base :: m ()
t_base = do
  m String -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m String -> m String
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 (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 (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
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 (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
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 (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)

-- grammar rule: [5s] sparqlBase ::= "BASE" IRIREF
t_sparql_base :: (CharParsing m, MonadState ParseState m) => m ()
t_sparql_base :: m ()
t_sparql_base = do
  m String -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m String -> m String
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 (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 (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> String -> m [()]
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 :: m ()
t_verb = m Subject -> m Subject
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 (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 (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Subject -> m ()
forall (m :: * -> *). MonadState ParseState m => Subject -> m ()
setPredicate

-- grammar rule: [11] predicate ::= iri
t_predicate :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m Node
t_predicate :: 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 (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"resource")

-- grammar rules: [139s] PNAME_NS ::= PN_PREFIX? ':'
t_pname_ns :: (CharParsing m, MonadState ParseState m) => m T.Text
t_pname_ns :: 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 (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 (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 (f :: * -> *) a. Applicative f => a -> f a
pure Text
n
    Maybe Text
Nothing -> String -> m Text
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)

-- grammar rules: [168s] PN_LOCAL
-- [168s] PN_LOCAL ::= (PN_CHARS_U | ':' | [0-9] | PLX) ((PN_CHARS | '.' | ':' | PLX)* (PN_CHARS | ':' | PLX))?
t_pn_local :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m T.Text
t_pn_local :: m Text
t_pn_local = do
  String
x <- m String
t_pn_chars_u_str m String -> m String -> m String
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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m String
satisfy_str m String -> m String -> m String
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 (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 (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 (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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (m String
t_pn_chars_str m String -> m String -> m String
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 (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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m String -> m String
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 (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* m String -> m String
forall (m :: * -> *) a. LookAheadParsing m => m a -> m a
lookAhead (m String -> m String
forall (m :: * -> *) a. Parsing m => m a -> m a
try m String
recsve)))
            m String -> m String -> m String
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (m String
t_pn_chars_str m String -> m String -> m String
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 (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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m String -> m String
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 (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m () -> 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 (f :: * -> *) a. Alternative f => f a -> f [a]
many m String
recsve
  Text -> m Text
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 (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 (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 (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

-- PERCENT | PN_LOCAL_ESC
-- grammar rules: [169s] PLX
t_plx :: (CharParsing m, Monad m) => m String
t_plx :: m String
t_plx = m String
forall (m :: * -> *). (CharParsing m, Monad m) => m String
t_percent m String -> m String -> m String
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 (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

--        '%' HEX HEX
-- grammar rules: [170s] PERCENT
t_percent :: (CharParsing m, Monad m) => m String
t_percent :: m String
t_percent = [m Char] -> m String
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t 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]

-- grammar rules: [172s] PN_LOCAL_ESC
t_pn_local_esc :: CharParsing m => m Char
t_pn_local_esc :: 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 (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> String -> m Char
forall (m :: * -> *). CharParsing m => String -> m Char
oneOf String
"_~.-!$&'()*+,;=/?#@%"

-- grammar rules: [140s] PNAME_LN ::= PNAME_NS PN_LOCAL
t_pname_ln :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m T.Text
t_pname_ln :: 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 (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

-- grammar rule: [10] subject
-- [10] subject	::= iri | BlankNode | collection
t_subject :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m ()
t_subject :: m ()
t_subject = m Subject
iri m Subject -> m Subject -> m Subject
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 (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 (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 (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 (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"subject resource")

-- [137s] BlankNode ::= BLANK_NODE_LABEL | ANON
t_blankNode :: (CharParsing m, MonadState ParseState m) => m Node
t_blankNode :: m Subject
t_blankNode = do
  String
genID <- m String -> m String
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 (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 (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 (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

-- TODO replicate the recursion technique from [168s] for ((..)* something)?
-- [141s] BLANK_NODE_LABEL ::= '_:' (PN_CHARS_U | [0-9]) ((PN_CHARS | '.')* PN_CHARS)?
t_blank_node_label :: (CharParsing m, MonadState ParseState m) => m String
t_blank_node_label :: 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 (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 (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 (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 (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 (t :: * -> *) a. Foldable t => t a -> Bool
null String
xs
        then String -> m String
forall (f :: * -> *) a. Applicative f => a -> f a
pure String
xs
        else
          if String -> Char
forall a. [a] -> a
last String
xs Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'.'
            then String -> m String
forall (m :: * -> *) a. Parsing m => String -> m a
unexpected String
"'.' at the end of a blank node label"
            else String -> m String
forall (f :: * -> *) a. Applicative f => a -> f a
pure String
xs

-- [162s] ANON ::= '[' WS* ']'
t_anon :: CharParsing m => m ()
t_anon :: 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 (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws))

-- [7] predicateObjectList ::= verb objectList (';' (verb objectList)?)*
t_predicateObjectList :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m ()
t_predicateObjectList :: 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 (m :: * -> *) a. Parsing m => m a -> m a
try m ()
verbObjectList) (m [[()]] -> m [[()]]
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 (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m () -> m [()]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> m () -> m ()
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 (f :: * -> *) a. Alternative f => f a -> f [a]
some (m () -> m [()]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> m Char -> m Char
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 (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m () -> m [()]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws)

-- grammar rule: [8] objectlist
-- [8] objectList ::= object (',' object)*
t_objectList :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m ()
t_objectList :: 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 (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"object") m Subject -> (Subject -> m ()) -> m ()
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 (f :: * -> *) a. Alternative f => f a -> f [a]
many (m () -> m ()
forall (m :: * -> *) a. Parsing m => m a -> m a
try (m () -> m [()]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> m Char -> m Char
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 (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m () -> m [()]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws m [()] -> m Subject -> m Subject
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 (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Subject -> m ()
forall (m :: * -> *).
(CharParsing m, MonadState ParseState m) =>
Subject -> m ()
addTripleForObject))

-- grammar rule: [12] object
-- [12]	object ::= iri | BlankNode | collection | blankNodePropertyList | literal
t_object :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m Node
t_object :: m Subject
t_object =
  m Subject -> m Subject
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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Subject -> m Subject
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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Subject -> m Subject
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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Subject -> m Subject
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 (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

-- grammar rule: [15] collection
-- [15]	collection ::= '(' object* ')'
t_collection :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m Node
t_collection :: 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 (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws)
    Subject
root <- m Subject -> m Subject
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Subject
empty_list m Subject -> m Subject -> m Subject
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 (f :: * -> *) a. Alternative f => f a -> f [a]
many m ()
forall (m :: * -> *). CharParsing m => m ()
t_ws)
    Subject -> m Subject
forall (m :: * -> *) a. Monad m => a -> m a
return Subject
root
  where
    empty_list :: m Subject
empty_list = m Char -> m Char
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 (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 (m :: * -> *) a. Monad m => a -> m a
return ([Subject] -> Subject
forall a. [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 (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 (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 (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Subject
s

t_literal :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m Node
t_literal :: 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 (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 (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 (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 (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 (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 (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 (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 (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')

-- [128s] RDFLiteral
-- String (LANGTAG | '^^' iri)?
t_rdf_literal :: (MonadState ParseState m, CharParsing m, LookAheadParsing m) => m LValue
t_rdf_literal :: 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 (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 (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 (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 (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)

-- [17] String
-- STRING_LITERAL_QUOTE | STRING_LITERAL_SINGLE_QUOTE | STRING_LITERAL_LONG_SINGLE_QUOTE | STRING_LITERAL_LONG_QUOTE
t_string :: (CharParsing m, Monad m) => m T.Text
t_string :: m Text
t_string =
  m Text -> m Text
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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Text -> m Text
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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Text -> m Text
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 (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

-- [22]	STRING_LITERAL_QUOTE
-- '"' ([^#x22#x5C#xA#xD] | ECHAR | UCHAR)* '"'
t_string_literal_double_quote :: (CharParsing m, Monad m) => m T.Text
t_string_literal_double_quote :: m Text
t_string_literal_double_quote = m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
nt_string_literal_quote

-- [23] STRING_LITERAL_SINGLE_QUOTE
-- "'" ([^#x27#x5C#xA#xD] | ECHAR | UCHAR)* "'"
t_string_literal_single_quote :: (CharParsing m, Monad m) => m T.Text
t_string_literal_single_quote :: m Text
t_string_literal_single_quote = Char -> m Text
forall (m :: * -> *). (CharParsing m, Monad m) => Char -> m Text
string_literal_quote Char
'\''

-- [24] STRING_LITERAL_LONG_SINGLE_QUOTE
-- "'''" (("'" | "''")? ([^'\] | ECHAR | UCHAR))* "'''"
t_string_literal_long_single_quote :: (CharParsing m, Monad m) => m T.Text
t_string_literal_long_single_quote :: 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 (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 (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 (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 (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 (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 (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 (f :: * -> *) a. Applicative f => a -> f a
pure (Text
s1 Text -> Text -> Text
`T.append` Text
s2)
  Text -> m Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Text] -> Text
T.concat [Text]
ss)

-- [25] STRING_LITERAL_LONG_QUOTE
-- '"""' (('"' | '""')? ([^"\] | ECHAR | UCHAR))* '"""'
t_string_literal_long_double_quote :: (CharParsing m, Monad m) => m T.Text
t_string_literal_long_double_quote :: 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 (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 (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 (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 (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 (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 (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 (f :: * -> *) a. Applicative f => a -> f a
pure (Text
s1 Text -> Text -> Text
`T.append` Text
s2)
  Text -> m Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Text] -> Text
T.concat [Text]
ss)

-- [144s] LANGTAG
t_langtag :: (CharParsing m, Monad m) => m T.Text
t_langtag :: m Text
t_langtag = m Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
nt_langtag

-- [159s]	ECHAR
t_echar :: (CharParsing m, Monad m) => m Char
t_echar :: m Char
t_echar = m Char
forall (m :: * -> *). (CharParsing m, Monad m) => m Char
nt_echar

-- [26]	UCHAR
t_uchar :: (CharParsing m, Monad m) => m Char
t_uchar :: m Char
t_uchar = m Char
forall (m :: * -> *). (CharParsing m, Monad m) => m Char
nt_uchar

-- [19] INTEGER ::= [+-]? [0-9]+
t_integer :: (CharParsing m, Monad m) => m T.Text
t_integer :: m Text
t_integer = m Text -> m Text
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 (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"+-"
  String
ds <- m Char -> m String
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 (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"digit")
  Text -> m Text
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)

-- grammar rule: [21] DOUBLE
-- [21] DOUBLE ::= [+-]? ([0-9]+ '.' [0-9]* EXPONENT | '.' [0-9]+ EXPONENT | [0-9]+ EXPONENT)
t_double :: (CharParsing m, Monad m) => m T.Text
t_double :: m Text
t_double = do
  String
sign <- m String
forall (m :: * -> *). CharParsing m => m String
sign_parser m String -> String -> m String
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"+-"
  Text
rest <-
    m Text -> m Text
forall (m :: * -> *) a. Parsing m => m a -> m a
try
      ( do
          String
ds <- (m Char -> m String
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 (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"digit") m String -> m Char -> m String
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 (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 (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 (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"exponent"
          Text -> m Text
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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Text -> m Text
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 (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m Char -> m String
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 (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 (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"exponent"
            Text -> m Text
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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ( do
              String
ds <- m Char -> m String
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 (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 (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"exponent"
              Text -> m Text
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 (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 :: m String
sign_parser = String -> m String -> m String
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option String
"" (Char -> String
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
"-+")

-- [20]	DECIMAL ::= [+-]? [0-9]* '.' [0-9]+
t_decimal :: (CharParsing m, Monad m) => m T.Text
t_decimal :: m Text
t_decimal = m Text -> m Text
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 (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 (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 (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 (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)

-- [154s] EXPONENT ::= [eE] [+-]? [0-9]+
t_exponent :: (CharParsing m, Monad m) => m T.Text
t_exponent :: 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 (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 (f :: * -> *) a. Alternative f => f a -> f [a]
some m Char
forall (m :: * -> *). CharParsing m => m Char
digit
  Text -> m Text
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))

-- [133s] BooleanLiteral ::= 'true' | 'false'
t_boolean :: CharParsing m => m T.Text
t_boolean :: 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 (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 (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 ()
t_comment :: m ()
t_comment = 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 (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m Char -> m String
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (String -> m Char
forall (m :: * -> *). CharParsing m => String -> m Char
noneOf String
"\n\r"))

--[TODO] t_comment = nt_comment

-- [161s] WS ::= #x20 | #x9 | #xD | #xA
t_ws :: CharParsing m => m ()
t_ws :: m ()
t_ws =
  (m Char -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m Char -> m Char
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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m () -> m ()
forall (m :: * -> *) a. Parsing m => m a -> m a
try m ()
forall (m :: * -> *). CharParsing m => m ()
t_comment
    m () -> String -> m ()
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"whitespace-or-comment"

-- [167s] PN_PREFIX ::= PN_CHARS_BASE ((PN_CHARS | '.')* PN_CHARS)?
t_pn_prefix :: (CharParsing m, MonadState ParseState m) => m T.Text
t_pn_prefix :: m Text
t_pn_prefix = do
  Char
i <- m Char -> m Char
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 (f :: * -> *) a. Alternative f => f a -> f [a]
many (m Char -> m Char
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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'.')) -- TODO: ensure t_pn_chars is last char
  Text -> m Text
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))

-- [18] IRIREF ::= '<' ([^#x00-#x20<>"{}|^`\] | UCHAR)* '>'
t_iriref :: (CharParsing m, MonadState ParseState m) => m T.Text
t_iriref :: 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

-- [163s] PN_CHARS_BASE
t_pn_chars_base :: CharParsing m => m Char
t_pn_chars_base :: m Char
t_pn_chars_base = m Char
forall (m :: * -> *). CharParsing m => m Char
nt_pn_chars_base

-- [164s] PN_CHARS_U ::= PN_CHARS_BASE | '_'
t_pn_chars_u :: CharParsing m => m Char
t_pn_chars_u :: 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 (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'_'

-- [166s] PN_CHARS ::= PN_CHARS_U | '-' | [0-9] | #x00B7 | [#x0300-#x036F] | [#x203F-#x2040]
t_pn_chars :: CharParsing m => m Char
t_pn_chars :: m Char
t_pn_chars = m Char
forall (m :: * -> *). CharParsing m => m Char
t_pn_chars_u m Char -> m Char -> m Char
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 (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 (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')]

-- grammar rules: [171s] HEX
t_hex :: CharParsing m => m Char
t_hex :: 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 (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 :: 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 :: 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 :: 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 :: 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 :: 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

-- combines get_current and increment into a single function
nextIdCounter :: MonadState ParseState m => m Integer
nextIdCounter :: m Integer
nextIdCounter = m ParseState
forall s (m :: * -> *). MonadState s m => m s
get m ParseState -> (ParseState -> m Integer) -> m Integer
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 :: 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 :: 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

-- Alias for Nothing for use with _modifyState calls, which can get very long with
-- many Nothing values.
no :: Maybe a
no :: Maybe a
no = Maybe a
forall a. Maybe a
Nothing

withConstantSubjectPredicate :: MonadState ParseState m => m a -> m a
withConstantSubjectPredicate :: 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 (m :: * -> *) a. Monad m => a -> m a
return a
a'

-- Update the subject and predicate values of the ParseState
setSubjectPredicate :: MonadState ParseState m => Maybe Subject -> Maybe Predicate -> m ()
setSubjectPredicate :: 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 :: 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 :: 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)

-- Update the subject and predicate values of the ParseState to Nothing.
resetSubjectPredicate :: MonadState ParseState m => m ()
resetSubjectPredicate :: 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

-- Modifies the current parser state by updating any state values among the parameters
-- that have non-Nothing values.
_modifyState ::
  MonadState ParseState m =>
  Maybe (Maybe BaseUrl) ->
  Maybe (Integer -> Integer) ->
  Maybe PrefixMappings ->
  Maybe (Maybe Subject) ->
  Maybe (Maybe Predicate) ->
  Maybe (Seq Triple) ->
  m ()
_modifyState :: 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 :: 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 (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 (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 (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

---------------------------------
-- parsec based parsers

-- | Parse the document at the given location URL as a Turtle document, using an optional @BaseUrl@
--  as the base URI, and using the given document URL as the URI of the Turtle document itself.
--
--  The @BaseUrl@ is used as the base URI within the document for resolving any relative URI references.
--  It may be changed within the document using the @\@base@ directive. At any given point, the current
--  base URI is the most recent @\@base@ directive, or if none, the @BaseUrl@ given to @parseURL@, or
--  if none given, the document URL given to @parseURL@. For example, if the @BaseUrl@ were
--  @http:\/\/example.org\/@ and a relative URI of @\<b>@ were encountered (with no preceding @\@base@
--  directive), then the relative URI would expand to @http:\/\/example.org\/b@.
--
--  The document URL is for the purpose of resolving references to 'this document' within the document,
--  and may be different than the actual location URL from which the document is retrieved. Any reference
--  to @\<>@ within the document is expanded to the value given here. Additionally, if no @BaseUrl@ is
--  given and no @\@base@ directive has appeared before a relative URI occurs, this value is used as the
--  base URI against which the relative URI is resolved.
--
--  Returns either a @ParseFailure@ or a new RDF containing the parsed triples.
parseURLParsec ::
  (Rdf a) =>
  -- | The optional base URI of the document.
  Maybe BaseUrl ->
  -- | The document URI (i.e., the URI of the document itself); if Nothing, use location URI.
  Maybe T.Text ->
  -- | The location URI from which to retrieve the Turtle document.
  String ->
  -- | The parse result, which is either a @ParseFailure@ or the RDF
  --   corresponding to the Turtle document.
  IO (Either ParseFailure (RDF a))
parseURLParsec :: 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)

-- | Parse the given file as a Turtle document. The arguments and return type have the same semantics
--  as 'parseURL', except that the last @String@ argument corresponds to a filesystem location rather
--  than a location URI.
--
--  Note: it does not relies on OS specificities (encoding, newline convention).
--
--  Returns either a @ParseFailure@ or a new RDF containing the parsed triples.
parseFileParsec :: (Rdf a) => Maybe BaseUrl -> Maybe T.Text -> String -> IO (Either ParseFailure (RDF a))
parseFileParsec :: 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 (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
c -> Either ParseFailure (RDF a) -> IO (Either ParseFailure (RDF 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)

-- | Parse the given string as a Turtle document. The arguments and return type have the same semantics
--  as <parseURL>, except that the last @String@ argument corresponds to the Turtle document itself as
--  a string rather than a location URI.
parseStringParsec :: (Rdf a) => Maybe BaseUrl -> Maybe T.Text -> T.Text -> Either ParseFailure (RDF a)
parseStringParsec :: 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)

---------------------------------
-- attoparsec based parsers

parseStringAttoparsec :: (Rdf a) => Maybe BaseUrl -> Maybe T.Text -> T.Text -> Either ParseFailure (RDF a)
parseStringAttoparsec :: 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 (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 :: 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) =>
  -- | The optional base URI of the document.
  Maybe BaseUrl ->
  -- | The document URI (i.e., the URI of the document itself); if Nothing, use location URI.
  Maybe T.Text ->
  -- | The location URI from which to retrieve the Turtle document.
  String ->
  -- | The parse result, which is either a @ParseFailure@ or the RDF
  --   corresponding to the Turtle document.
  IO (Either ParseFailure (RDF a))
parseURLAttoparsec :: 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 (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 :: 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)) ->
    -- the base URL may have been overwritten by a @base statement.
    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 (t :: * -> *) a. Foldable t => t a -> [a]
F.toList Seq Triple
ts) Maybe BaseUrl
chosenBaseUrl PrefixMappings
pms

--------------
-- auxiliary parsing functions

-- Match the lowercase or uppercase form of 'c'
caseInsensitiveChar :: CharParsing m => Char -> m Char
caseInsensitiveChar :: 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 (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)

-- Match the string 's', accepting either lowercase or uppercase form of each character
caseInsensitiveString :: (CharParsing m, Monad m) => String -> m String
caseInsensitiveString :: String -> m String
caseInsensitiveString String
s = m String -> m String
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)
mapM Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
caseInsensitiveChar String
s) m String -> String -> m String
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 :: 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 (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 (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 (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 (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)]