{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TypeFamilies #-}
module Data.RDF.Types
(
LValue (PlainL, PlainLL, TypedL),
Node (UNode, BNode, BNodeGen, LNode),
Subject,
Predicate,
Object,
Triple (Triple),
Triples,
View (view),
plainL,
plainLL,
typedL,
unode,
bnode,
bnodeUnsafe,
lnode,
triple,
unodeValidate,
uriValidate,
uriValidateString,
isUNode,
isLNode,
isBNode,
resolveQName,
isAbsoluteUri,
mkAbsoluteUrl,
escapeRDFSyntax,
unescapeUnicode,
fileSchemeToFilePath,
filePathToUri,
iriFragment,
uchar,
RDF,
Rdf (baseUrl, prefixMappings, addPrefixMappings, empty, mkRdf, addTriple, removeTriple, triplesOf, uniqTriplesOf, select, query, showGraph),
RdfParser (parseString, parseFile, parseURL),
RdfSerializer (hWriteRdf, writeRdf, hWriteH, writeH, hWriteTs, hWriteT, writeT, writeTs, hWriteN, writeN),
Namespace (PrefixedNS, PlainNS),
PrefixMappings (PrefixMappings),
PrefixMapping (PrefixMapping),
BaseUrl (..),
NodeSelector,
ParseFailure (ParseFailure),
)
where
#if MIN_VERSION_base(4,9,0)
#if !MIN_VERSION_base(4,11,0)
import Data.Semigroup
#else
#endif
#else
#endif
import Control.Applicative
import qualified Control.Applicative as A
import Control.DeepSeq (NFData, rnf)
import Control.Monad (guard, (<=<))
import Data.Binary
import Data.Char (chr, ord)
import Data.Either (isRight)
import Data.Hashable (Hashable)
import qualified Data.List as List
import Data.Map (Map)
import qualified Data.Map as Map
import Data.RDF.BlankNode
import Data.RDF.IRI
import Data.String (IsString (..))
import Data.Text (Text)
import qualified Data.Text as T
import GHC.Generics (Generic)
import Network.URI
import qualified Network.URI as Network (parseURI, uriPath)
import qualified System.FilePath as FP
import System.IO
import Text.Parsec (ParseError, parse)
import Text.Parser.Char
import Text.Parser.Combinators
import Text.Printf
import Prelude hiding (pred)
data LValue
=
PlainL !Text
|
PlainLL !Text !Text
|
TypedL !Text !Text
deriving ((forall x. LValue -> Rep LValue x)
-> (forall x. Rep LValue x -> LValue) -> Generic LValue
forall x. Rep LValue x -> LValue
forall x. LValue -> Rep LValue x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LValue x -> LValue
$cfrom :: forall x. LValue -> Rep LValue x
Generic, Int -> LValue -> ShowS
[LValue] -> ShowS
LValue -> String
(Int -> LValue -> ShowS)
-> (LValue -> String) -> ([LValue] -> ShowS) -> Show LValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LValue] -> ShowS
$cshowList :: [LValue] -> ShowS
show :: LValue -> String
$cshow :: LValue -> String
showsPrec :: Int -> LValue -> ShowS
$cshowsPrec :: Int -> LValue -> ShowS
Show)
instance Binary LValue
instance NFData LValue where
rnf :: LValue -> ()
rnf (PlainL Text
t) = Text -> ()
forall a. NFData a => a -> ()
rnf Text
t
rnf (PlainLL Text
t1 Text
t2) = Text -> ()
forall a. NFData a => a -> ()
rnf Text
t1 () -> () -> ()
`seq` Text -> ()
forall a. NFData a => a -> ()
rnf Text
t2
rnf (TypedL Text
t1 Text
t2) = Text -> ()
forall a. NFData a => a -> ()
rnf Text
t1 () -> () -> ()
`seq` Text -> ()
forall a. NFData a => a -> ()
rnf Text
t2
{-# INLINE plainL #-}
plainL :: Text -> LValue
plainL :: Text -> LValue
plainL = Text -> LValue
PlainL
{-# INLINE plainLL #-}
plainLL :: Text -> Text -> LValue
plainLL :: Text -> Text -> LValue
plainLL = Text -> Text -> LValue
PlainLL
{-# INLINE typedL #-}
typedL :: Text -> Text -> LValue
typedL :: Text -> Text -> LValue
typedL Text
val Text
dtype = Text -> Text -> LValue
TypedL (Text -> Text -> Text
canonicalize Text
dtype Text
val) Text
dtype
data Node
=
UNode !Text
|
BNode !Text
|
BNodeGen !Int
|
LNode !LValue
deriving ((forall x. Node -> Rep Node x)
-> (forall x. Rep Node x -> Node) -> Generic Node
forall x. Rep Node x -> Node
forall x. Node -> Rep Node x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Node x -> Node
$cfrom :: forall x. Node -> Rep Node x
Generic, Int -> Node -> ShowS
[Node] -> ShowS
Node -> String
(Int -> Node -> ShowS)
-> (Node -> String) -> ([Node] -> ShowS) -> Show Node
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Node] -> ShowS
$cshowList :: [Node] -> ShowS
show :: Node -> String
$cshow :: Node -> String
showsPrec :: Int -> Node -> ShowS
$cshowsPrec :: Int -> Node -> ShowS
Show)
instance Binary Node
instance NFData Node where
rnf :: Node -> ()
rnf (UNode Text
t) = Text -> ()
forall a. NFData a => a -> ()
rnf Text
t
rnf (BNode Text
b) = Text -> ()
forall a. NFData a => a -> ()
rnf Text
b
rnf (BNodeGen Int
bgen) = Int -> ()
forall a. NFData a => a -> ()
rnf Int
bgen
rnf (LNode LValue
lvalue) = LValue -> ()
forall a. NFData a => a -> ()
rnf LValue
lvalue
type Subject = Node
type Predicate = Node
type Object = Node
{-# INLINE unode #-}
unode :: Text -> Node
unode :: Text -> Node
unode = Text -> Node
UNode
unodeValidate :: Text -> Maybe Node
unodeValidate :: Text -> Maybe Node
unodeValidate Text
t = Text -> Node
UNode (Text -> Node) -> Maybe Text -> Maybe Node
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Maybe Text
uriValidate Text
t
uriValidate :: Text -> Maybe Text
uriValidate :: Text -> Maybe Text
uriValidate = (ParseError -> Maybe Text)
-> (Text -> Maybe Text) -> Either ParseError Text -> Maybe Text
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe Text -> ParseError -> Maybe Text
forall a b. a -> b -> a
const Maybe Text
forall a. Maybe a
Nothing) Text -> Maybe Text
forall a. a -> Maybe a
Just (Either ParseError Text -> Maybe Text)
-> (Text -> Either ParseError Text) -> Text -> Maybe Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either ParseError Text
isRdfURI
uriValidateString :: String -> Maybe String
uriValidateString :: String -> Maybe String
uriValidateString = (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> String
T.unpack (Maybe Text -> Maybe String)
-> (String -> Maybe Text) -> String -> Maybe String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Maybe Text
uriValidate (Text -> Maybe Text) -> (String -> Text) -> String -> Maybe Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
forall a. IsString a => String -> a
fromString
isRdfURI :: Text -> Either ParseError Text
isRdfURI :: Text -> Either ParseError Text
isRdfURI Text
t = Parsec Text () Text -> String -> Text -> Either ParseError Text
forall s t a.
Stream s Identity t =>
Parsec s () a -> String -> s -> Either ParseError a
parse (Parsec Text () Text
forall (m :: * -> *). (CharParsing m, Monad m) => m Text
iriFragment Parsec Text () Text
-> ParsecT Text () Identity () -> Parsec Text () Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Text () Identity ()
forall (m :: * -> *). Parsing m => m ()
eof) (String
"Invalid URI: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Text -> String
T.unpack Text
t) Text
t
iriFragment :: (CharParsing m, Monad m) => m Text
iriFragment :: m Text
iriFragment = String -> Text
T.pack (String -> Text) -> m String -> m Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Char -> m String
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many m Char
validUriChar
where
validUriChar :: m Char
validUriChar = m Char -> m Char
forall (m :: * -> *) a. Parsing m => m a -> m a
try ((Char -> Bool) -> m Char
forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m Char
satisfy Char -> Bool
isValidUriChar) m Char -> m Char -> m Char
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Char
validUnicodeEscaped
validUnicodeEscaped :: m Char
validUnicodeEscaped = do
Char
c <- m Char
forall (m :: * -> *). (CharParsing m, Monad m) => m Char
uchar
Bool -> m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Char -> Bool
isValidUriChar Char
c)
Char -> m Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
c
isValidUriChar :: Char -> Bool
isValidUriChar Char
c =
Bool -> Bool
not (Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
'\x00' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'\x20')
Bool -> Bool -> Bool
&& Char
c Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` (String
"<>\"{}|^`\\" :: String)
uchar :: (CharParsing m, Monad m) => m Char
uchar :: m Char
uchar = m Char -> m Char
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Char
shortUnicode m Char -> m Char -> m Char
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m Char -> m Char
forall (m :: * -> *) a. Parsing m => m a -> m a
try m Char
longUnicode
where
shortUnicode :: m Char
shortUnicode = String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"\\u" m String -> m Char -> m Char
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Int -> m Char
forall (m :: * -> *). (CharParsing m, Monad m) => Int -> m Char
unescapeUnicodeParser Int
4
longUnicode :: m Char
longUnicode = String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
string String
"\\U" m String -> m Char -> m Char
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Int -> m Char
forall (m :: * -> *). (CharParsing m, Monad m) => Int -> m Char
unescapeUnicodeParser Int
8
unescapeUnicodeParser :: (CharParsing m, Monad m) => Int -> m Char
unescapeUnicodeParser :: Int -> m Char
unescapeUnicodeParser Int
n = do
Int
c <- Int -> Int -> m Int
forall t (f :: * -> *).
(Eq t, Num t, Monad f, CharParsing f) =>
t -> Int -> f Int
go Int
n Int
0
Bool -> m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Int
c Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x10FFFF)
Char -> m Char
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> m Char) -> Char -> m Char
forall a b. (a -> b) -> a -> b
$ Int -> Char
chr Int
c
where
{-# INLINE go #-}
go :: t -> Int -> f Int
go t
0 Int
t = Int -> f Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
t
go t
k Int
t = do
Int
h <- f Char
forall (m :: * -> *). CharParsing m => m Char
anyChar f Char -> (Char -> f Int) -> f Int
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Char -> f Int
forall (f :: * -> *). Alternative f => Char -> f Int
getHex
let t' :: Int
t' = Int
t Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
16 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
h
Int -> Int -> Int
seq Int
t' (Int -> Int) -> f Int -> f Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> t -> Int -> f Int
go (t
k t -> t -> t
forall a. Num a => a -> a -> a
- t
1) Int
t'
{-# INLINE getHex #-}
getHex :: Char -> f Int
getHex Char
c
| Char
'0' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'9' = Int -> f Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Char -> Int
ord Char
c Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
ord Char
'0')
| Char
'A' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'F' = Int -> f Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Char -> Int
ord Char
c Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
ord Char
'A' Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
10)
| Char
'a' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'f' = Int -> f Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Char -> Int
ord Char
c Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
ord Char
'a' Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
10)
| Bool
otherwise = f Int
forall (f :: * -> *) a. Alternative f => f a
A.empty
unescapeUnicode, escapeRDFSyntax :: Text -> Either ParseError Text
unescapeUnicode :: Text -> Either ParseError Text
unescapeUnicode Text
t = String -> Text
T.pack (String -> Text)
-> Either ParseError String -> Either ParseError Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Text () String -> String -> Text -> Either ParseError String
forall s t a.
Stream s Identity t =>
Parsec s () a -> String -> s -> Either ParseError a
parse (ParsecT Text () Identity Char -> Parsec Text () String
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many ParsecT Text () Identity Char
unicodeEsc) String
"" Text
t
where
unicodeEsc :: ParsecT Text () Identity Char
unicodeEsc = ParsecT Text () Identity Char
forall (m :: * -> *). (CharParsing m, Monad m) => m Char
uchar ParsecT Text () Identity Char
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT Text () Identity Char
forall (m :: * -> *). CharParsing m => m Char
anyChar
{-# DEPRECATED escapeRDFSyntax "Use unescapeUnicode instead" #-}
escapeRDFSyntax :: Text -> Either ParseError Text
escapeRDFSyntax = Text -> Either ParseError Text
unescapeUnicode
{-# INLINE bnode #-}
bnode :: Text -> Maybe Node
bnode :: Text -> Maybe Node
bnode Text
t =
case Text -> Maybe String
mkBNode Text
t of
Maybe String
Nothing -> Maybe Node
forall a. Maybe a
Nothing
Just String
bString -> Node -> Maybe Node
forall a. a -> Maybe a
Just (Text -> Node
BNode (String -> Text
T.pack String
bString))
{-# INLINE bnodeUnsafe #-}
bnodeUnsafe :: Text -> Node
bnodeUnsafe :: Text -> Node
bnodeUnsafe = Text -> Node
BNode
{-# INLINE lnode #-}
lnode :: LValue -> Node
lnode :: LValue -> Node
lnode = LValue -> Node
LNode
data Triple = Triple !Node !Node !Node
deriving ((forall x. Triple -> Rep Triple x)
-> (forall x. Rep Triple x -> Triple) -> Generic Triple
forall x. Rep Triple x -> Triple
forall x. Triple -> Rep Triple x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Triple x -> Triple
$cfrom :: forall x. Triple -> Rep Triple x
Generic, Int -> Triple -> ShowS
[Triple] -> ShowS
Triple -> String
(Int -> Triple -> ShowS)
-> (Triple -> String) -> ([Triple] -> ShowS) -> Show Triple
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Triple] -> ShowS
$cshowList :: [Triple] -> ShowS
show :: Triple -> String
$cshow :: Triple -> String
showsPrec :: Int -> Triple -> ShowS
$cshowsPrec :: Int -> Triple -> ShowS
Show)
instance Binary Triple
instance NFData Triple where
rnf :: Triple -> ()
rnf (Triple Node
s Node
p Node
o) = Node -> ()
forall a. NFData a => a -> ()
rnf Node
s () -> () -> ()
`seq` Node -> ()
forall a. NFData a => a -> ()
rnf Node
p () -> () -> ()
`seq` Node -> ()
forall a. NFData a => a -> ()
rnf Node
o
type Triples = [Triple]
triple :: Subject -> Predicate -> Object -> Triple
triple :: Node -> Node -> Node -> Triple
triple Node
s Node
p Node
o
| Node -> Bool
isLNode Node
s = String -> Triple
forall a. HasCallStack => String -> a
error (String -> Triple) -> String -> Triple
forall a b. (a -> b) -> a -> b
$ String
"subject must be UNode or BNode: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Node -> String
forall a. Show a => a -> String
show Node
s
| Node -> Bool
isLNode Node
p = String -> Triple
forall a. HasCallStack => String -> a
error (String -> Triple) -> String -> Triple
forall a b. (a -> b) -> a -> b
$ String
"predicate must be UNode, not LNode: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Node -> String
forall a. Show a => a -> String
show Node
p
| Node -> Bool
isBNode Node
p = String -> Triple
forall a. HasCallStack => String -> a
error (String -> Triple) -> String -> Triple
forall a b. (a -> b) -> a -> b
$ String
"predicate must be UNode, not BNode: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Node -> String
forall a. Show a => a -> String
show Node
p
| Bool
otherwise = Node -> Node -> Node -> Triple
Triple Node
s Node
p Node
o
{-# INLINE isUNode #-}
isUNode :: Node -> Bool
isUNode :: Node -> Bool
isUNode (UNode Text
_) = Bool
True
isUNode Node
_ = Bool
False
{-# INLINE isBNode #-}
isBNode :: Node -> Bool
isBNode :: Node -> Bool
isBNode (BNode Text
_) = Bool
True
isBNode (BNodeGen Int
_) = Bool
True
isBNode Node
_ = Bool
False
{-# INLINE isLNode #-}
isLNode :: Node -> Bool
isLNode :: Node -> Bool
isLNode (LNode LValue
_) = Bool
True
isLNode Node
_ = Bool
False
{-# INLINE isAbsoluteUri #-}
isAbsoluteUri :: Text -> Bool
isAbsoluteUri :: Text -> Bool
isAbsoluteUri = Either String IRIRef -> Bool
forall a b. Either a b -> Bool
isRight (Either String IRIRef -> Bool)
-> (Text -> Either String IRIRef) -> Text -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either String IRIRef
parseIRI
class View a b where
view :: a -> b
data family RDF a
class (Generic rdfImpl, NFData rdfImpl) => Rdf rdfImpl where
baseUrl :: RDF rdfImpl -> Maybe BaseUrl
prefixMappings :: RDF rdfImpl -> PrefixMappings
addPrefixMappings :: RDF rdfImpl -> PrefixMappings -> Bool -> RDF rdfImpl
empty :: RDF rdfImpl
mkRdf :: Triples -> Maybe BaseUrl -> PrefixMappings -> RDF rdfImpl
addTriple :: RDF rdfImpl -> Triple -> RDF rdfImpl
removeTriple :: RDF rdfImpl -> Triple -> RDF rdfImpl
triplesOf :: RDF rdfImpl -> Triples
uniqTriplesOf :: RDF rdfImpl -> Triples
select :: RDF rdfImpl -> NodeSelector -> NodeSelector -> NodeSelector -> Triples
query :: RDF rdfImpl -> Maybe Node -> Maybe Node -> Maybe Node -> Triples
showGraph :: RDF rdfImpl -> String
instance (Rdf a) => Show (RDF a) where
show :: RDF a -> String
show = RDF a -> String
forall a. Rdf a => RDF a -> String
showGraph
class RdfParser p where
parseString :: (Rdf a) => p -> Text -> Either ParseFailure (RDF a)
parseFile :: (Rdf a) => p -> String -> IO (Either ParseFailure (RDF a))
parseURL :: (Rdf a) => p -> String -> IO (Either ParseFailure (RDF a))
class RdfSerializer s where
hWriteRdf :: (Rdf a) => s -> Handle -> RDF a -> IO ()
writeRdf :: (Rdf a) => s -> RDF a -> IO ()
hWriteH :: (Rdf a) => s -> Handle -> RDF a -> IO ()
writeH :: (Rdf a) => s -> RDF a -> IO ()
hWriteTs :: s -> Handle -> Triples -> IO ()
writeTs :: s -> Triples -> IO ()
hWriteT :: s -> Handle -> Triple -> IO ()
writeT :: s -> Triple -> IO ()
hWriteN :: s -> Handle -> Node -> IO ()
writeN :: s -> Node -> IO ()
newtype BaseUrl = BaseUrl {BaseUrl -> Text
unBaseUrl :: Text}
deriving (BaseUrl -> BaseUrl -> Bool
(BaseUrl -> BaseUrl -> Bool)
-> (BaseUrl -> BaseUrl -> Bool) -> Eq BaseUrl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BaseUrl -> BaseUrl -> Bool
$c/= :: BaseUrl -> BaseUrl -> Bool
== :: BaseUrl -> BaseUrl -> Bool
$c== :: BaseUrl -> BaseUrl -> Bool
Eq, Eq BaseUrl
Eq BaseUrl
-> (BaseUrl -> BaseUrl -> Ordering)
-> (BaseUrl -> BaseUrl -> Bool)
-> (BaseUrl -> BaseUrl -> Bool)
-> (BaseUrl -> BaseUrl -> Bool)
-> (BaseUrl -> BaseUrl -> Bool)
-> (BaseUrl -> BaseUrl -> BaseUrl)
-> (BaseUrl -> BaseUrl -> BaseUrl)
-> Ord BaseUrl
BaseUrl -> BaseUrl -> Bool
BaseUrl -> BaseUrl -> Ordering
BaseUrl -> BaseUrl -> BaseUrl
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BaseUrl -> BaseUrl -> BaseUrl
$cmin :: BaseUrl -> BaseUrl -> BaseUrl
max :: BaseUrl -> BaseUrl -> BaseUrl
$cmax :: BaseUrl -> BaseUrl -> BaseUrl
>= :: BaseUrl -> BaseUrl -> Bool
$c>= :: BaseUrl -> BaseUrl -> Bool
> :: BaseUrl -> BaseUrl -> Bool
$c> :: BaseUrl -> BaseUrl -> Bool
<= :: BaseUrl -> BaseUrl -> Bool
$c<= :: BaseUrl -> BaseUrl -> Bool
< :: BaseUrl -> BaseUrl -> Bool
$c< :: BaseUrl -> BaseUrl -> Bool
compare :: BaseUrl -> BaseUrl -> Ordering
$ccompare :: BaseUrl -> BaseUrl -> Ordering
$cp1Ord :: Eq BaseUrl
Ord, Int -> BaseUrl -> ShowS
[BaseUrl] -> ShowS
BaseUrl -> String
(Int -> BaseUrl -> ShowS)
-> (BaseUrl -> String) -> ([BaseUrl] -> ShowS) -> Show BaseUrl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BaseUrl] -> ShowS
$cshowList :: [BaseUrl] -> ShowS
show :: BaseUrl -> String
$cshow :: BaseUrl -> String
showsPrec :: Int -> BaseUrl -> ShowS
$cshowsPrec :: Int -> BaseUrl -> ShowS
Show, BaseUrl -> ()
(BaseUrl -> ()) -> NFData BaseUrl
forall a. (a -> ()) -> NFData a
rnf :: BaseUrl -> ()
$crnf :: BaseUrl -> ()
NFData, b -> BaseUrl -> BaseUrl
NonEmpty BaseUrl -> BaseUrl
BaseUrl -> BaseUrl -> BaseUrl
(BaseUrl -> BaseUrl -> BaseUrl)
-> (NonEmpty BaseUrl -> BaseUrl)
-> (forall b. Integral b => b -> BaseUrl -> BaseUrl)
-> Semigroup BaseUrl
forall b. Integral b => b -> BaseUrl -> BaseUrl
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> BaseUrl -> BaseUrl
$cstimes :: forall b. Integral b => b -> BaseUrl -> BaseUrl
sconcat :: NonEmpty BaseUrl -> BaseUrl
$csconcat :: NonEmpty BaseUrl -> BaseUrl
<> :: BaseUrl -> BaseUrl -> BaseUrl
$c<> :: BaseUrl -> BaseUrl -> BaseUrl
Semigroup, (forall x. BaseUrl -> Rep BaseUrl x)
-> (forall x. Rep BaseUrl x -> BaseUrl) -> Generic BaseUrl
forall x. Rep BaseUrl x -> BaseUrl
forall x. BaseUrl -> Rep BaseUrl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BaseUrl x -> BaseUrl
$cfrom :: forall x. BaseUrl -> Rep BaseUrl x
Generic)
instance Binary BaseUrl
instance Monoid BaseUrl where
mempty :: BaseUrl
mempty = Text -> BaseUrl
BaseUrl Text
T.empty
type NodeSelector = Maybe (Node -> Bool)
newtype ParseFailure = ParseFailure String
deriving (ParseFailure -> ParseFailure -> Bool
(ParseFailure -> ParseFailure -> Bool)
-> (ParseFailure -> ParseFailure -> Bool) -> Eq ParseFailure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ParseFailure -> ParseFailure -> Bool
$c/= :: ParseFailure -> ParseFailure -> Bool
== :: ParseFailure -> ParseFailure -> Bool
$c== :: ParseFailure -> ParseFailure -> Bool
Eq, Int -> ParseFailure -> ShowS
[ParseFailure] -> ShowS
ParseFailure -> String
(Int -> ParseFailure -> ShowS)
-> (ParseFailure -> String)
-> ([ParseFailure] -> ShowS)
-> Show ParseFailure
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ParseFailure] -> ShowS
$cshowList :: [ParseFailure] -> ShowS
show :: ParseFailure -> String
$cshow :: ParseFailure -> String
showsPrec :: Int -> ParseFailure -> ShowS
$cshowsPrec :: Int -> ParseFailure -> ShowS
Show)
instance Eq Node where
(UNode Text
bs1) == :: Node -> Node -> Bool
== (UNode Text
bs2) = Text
bs1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
bs2
(BNode Text
bs1) == (BNode Text
bs2) = Text
bs1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
bs2
(BNodeGen Int
i1) == (BNodeGen Int
i2) = Int
i1 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
i2
(LNode LValue
l1) == (LNode LValue
l2) = LValue
l1 LValue -> LValue -> Bool
forall a. Eq a => a -> a -> Bool
== LValue
l2
Node
_ == Node
_ = Bool
False
instance Ord Node where
compare :: Node -> Node -> Ordering
compare (UNode Text
bs1) (UNode Text
bs2) = Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
bs1 Text
bs2
compare (UNode Text
_) Node
_ = Ordering
LT
compare Node
_ (UNode Text
_) = Ordering
GT
compare (BNode Text
bs1) (BNode Text
bs2) = Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
bs1 Text
bs2
compare (BNode Text
_) Node
_ = Ordering
LT
compare Node
_ (BNode Text
_) = Ordering
GT
compare (BNodeGen Int
i1) (BNodeGen Int
i2) = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
i1 Int
i2
compare (BNodeGen Int
_) Node
_ = Ordering
LT
compare Node
_ (BNodeGen Int
_) = Ordering
GT
compare (LNode LValue
lv1) (LNode LValue
lv2) = LValue -> LValue -> Ordering
forall a. Ord a => a -> a -> Ordering
compare LValue
lv1 LValue
lv2
instance Hashable Node
instance Eq Triple where
(Triple Node
s1 Node
p1 Node
o1) == :: Triple -> Triple -> Bool
== (Triple Node
s2 Node
p2 Node
o2) = Node
s1 Node -> Node -> Bool
forall a. Eq a => a -> a -> Bool
== Node
s2 Bool -> Bool -> Bool
&& Node
p1 Node -> Node -> Bool
forall a. Eq a => a -> a -> Bool
== Node
p2 Bool -> Bool -> Bool
&& Node
o1 Node -> Node -> Bool
forall a. Eq a => a -> a -> Bool
== Node
o2
instance Ord Triple where
{-# INLINE compare #-}
(Triple Node
s1 Node
p1 Node
o1) compare :: Triple -> Triple -> Ordering
`compare` (Triple Node
s2 Node
p2 Node
o2) =
Node -> Node -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Node
s1 Node
s2 Ordering -> Ordering -> Ordering
forall a. Monoid a => a -> a -> a
`mappend` Node -> Node -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Node
p1 Node
p2 Ordering -> Ordering -> Ordering
forall a. Monoid a => a -> a -> a
`mappend` Node -> Node -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Node
o1 Node
o2
instance Eq LValue where
(PlainL Text
v1) == :: LValue -> LValue -> Bool
== (PlainL Text
v2) = Text
v1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
v2
(PlainLL Text
v1 Text
lt1) == (PlainLL Text
v2 Text
lt2) = Text -> Text
T.toLower Text
lt1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text -> Text
T.toLower Text
lt2 Bool -> Bool -> Bool
&& Text
v1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
v2
(TypedL Text
v1 Text
dt1) == (TypedL Text
v2 Text
dt2) = Text
v1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
v2 Bool -> Bool -> Bool
&& Text
dt1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
dt2
LValue
_ == LValue
_ = Bool
False
instance Ord LValue where
{-# INLINE compare #-}
compare :: LValue -> LValue -> Ordering
compare (PlainL Text
v1) (PlainL Text
v2) = Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
v1 Text
v2
compare (PlainL Text
_) LValue
_ = Ordering
LT
compare LValue
_ (PlainL Text
_) = Ordering
GT
compare (PlainLL Text
v1 Text
lt1) (PlainLL Text
v2 Text
lt2) = Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
lt1 Text
lt2 Ordering -> Ordering -> Ordering
forall a. Monoid a => a -> a -> a
`mappend` Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
v1 Text
v2
compare (PlainLL Text
_ Text
_) LValue
_ = Ordering
LT
compare LValue
_ (PlainLL Text
_ Text
_) = Ordering
GT
compare (TypedL Text
v1 Text
dt1) (TypedL Text
v2 Text
dt2) = Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
dt1 Text
dt2 Ordering -> Ordering -> Ordering
forall a. Monoid a => a -> a -> a
`mappend` Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
v1 Text
v2
instance Hashable LValue
data Namespace
= PrefixedNS Text Text
| PlainNS Text
instance Eq Namespace where
(PrefixedNS Text
_ Text
u1) == :: Namespace -> Namespace -> Bool
== (PrefixedNS Text
_ Text
u2) = Text
u1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
u2
(PlainNS Text
u1) == (PlainNS Text
u2) = Text
u1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
u2
(PrefixedNS Text
_ Text
u1) == (PlainNS Text
u2) = Text
u1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
u2
(PlainNS Text
u1) == (PrefixedNS Text
_ Text
u2) = Text
u1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
u2
instance Show Namespace where
show :: Namespace -> String
show (PlainNS Text
uri) = Text -> String
T.unpack Text
uri
show (PrefixedNS Text
prefix Text
uri) = String -> String -> ShowS
forall r. PrintfType r => String -> r
printf String
"(PrefixNS %s %s)" (Text -> String
T.unpack Text
prefix) (Text -> String
T.unpack Text
uri)
newtype PrefixMappings = PrefixMappings (Map Text Text)
deriving (PrefixMappings -> PrefixMappings -> Bool
(PrefixMappings -> PrefixMappings -> Bool)
-> (PrefixMappings -> PrefixMappings -> Bool) -> Eq PrefixMappings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrefixMappings -> PrefixMappings -> Bool
$c/= :: PrefixMappings -> PrefixMappings -> Bool
== :: PrefixMappings -> PrefixMappings -> Bool
$c== :: PrefixMappings -> PrefixMappings -> Bool
Eq, Eq PrefixMappings
Eq PrefixMappings
-> (PrefixMappings -> PrefixMappings -> Ordering)
-> (PrefixMappings -> PrefixMappings -> Bool)
-> (PrefixMappings -> PrefixMappings -> Bool)
-> (PrefixMappings -> PrefixMappings -> Bool)
-> (PrefixMappings -> PrefixMappings -> Bool)
-> (PrefixMappings -> PrefixMappings -> PrefixMappings)
-> (PrefixMappings -> PrefixMappings -> PrefixMappings)
-> Ord PrefixMappings
PrefixMappings -> PrefixMappings -> Bool
PrefixMappings -> PrefixMappings -> Ordering
PrefixMappings -> PrefixMappings -> PrefixMappings
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PrefixMappings -> PrefixMappings -> PrefixMappings
$cmin :: PrefixMappings -> PrefixMappings -> PrefixMappings
max :: PrefixMappings -> PrefixMappings -> PrefixMappings
$cmax :: PrefixMappings -> PrefixMappings -> PrefixMappings
>= :: PrefixMappings -> PrefixMappings -> Bool
$c>= :: PrefixMappings -> PrefixMappings -> Bool
> :: PrefixMappings -> PrefixMappings -> Bool
$c> :: PrefixMappings -> PrefixMappings -> Bool
<= :: PrefixMappings -> PrefixMappings -> Bool
$c<= :: PrefixMappings -> PrefixMappings -> Bool
< :: PrefixMappings -> PrefixMappings -> Bool
$c< :: PrefixMappings -> PrefixMappings -> Bool
compare :: PrefixMappings -> PrefixMappings -> Ordering
$ccompare :: PrefixMappings -> PrefixMappings -> Ordering
$cp1Ord :: Eq PrefixMappings
Ord, PrefixMappings -> ()
(PrefixMappings -> ()) -> NFData PrefixMappings
forall a. (a -> ()) -> NFData a
rnf :: PrefixMappings -> ()
$crnf :: PrefixMappings -> ()
NFData, b -> PrefixMappings -> PrefixMappings
NonEmpty PrefixMappings -> PrefixMappings
PrefixMappings -> PrefixMappings -> PrefixMappings
(PrefixMappings -> PrefixMappings -> PrefixMappings)
-> (NonEmpty PrefixMappings -> PrefixMappings)
-> (forall b. Integral b => b -> PrefixMappings -> PrefixMappings)
-> Semigroup PrefixMappings
forall b. Integral b => b -> PrefixMappings -> PrefixMappings
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> PrefixMappings -> PrefixMappings
$cstimes :: forall b. Integral b => b -> PrefixMappings -> PrefixMappings
sconcat :: NonEmpty PrefixMappings -> PrefixMappings
$csconcat :: NonEmpty PrefixMappings -> PrefixMappings
<> :: PrefixMappings -> PrefixMappings -> PrefixMappings
$c<> :: PrefixMappings -> PrefixMappings -> PrefixMappings
Semigroup, Semigroup PrefixMappings
PrefixMappings
Semigroup PrefixMappings
-> PrefixMappings
-> (PrefixMappings -> PrefixMappings -> PrefixMappings)
-> ([PrefixMappings] -> PrefixMappings)
-> Monoid PrefixMappings
[PrefixMappings] -> PrefixMappings
PrefixMappings -> PrefixMappings -> PrefixMappings
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [PrefixMappings] -> PrefixMappings
$cmconcat :: [PrefixMappings] -> PrefixMappings
mappend :: PrefixMappings -> PrefixMappings -> PrefixMappings
$cmappend :: PrefixMappings -> PrefixMappings -> PrefixMappings
mempty :: PrefixMappings
$cmempty :: PrefixMappings
$cp1Monoid :: Semigroup PrefixMappings
Monoid, (forall x. PrefixMappings -> Rep PrefixMappings x)
-> (forall x. Rep PrefixMappings x -> PrefixMappings)
-> Generic PrefixMappings
forall x. Rep PrefixMappings x -> PrefixMappings
forall x. PrefixMappings -> Rep PrefixMappings x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PrefixMappings x -> PrefixMappings
$cfrom :: forall x. PrefixMappings -> Rep PrefixMappings x
Generic)
instance Binary PrefixMappings
instance Show PrefixMappings where
show :: PrefixMappings -> String
show (PrefixMappings Map Text Text
pmap) = String -> ShowS
forall r. PrintfType r => String -> r
printf String
"PrefixMappings [%s]" String
mappingsStr
where
showPM :: (Text, Text) -> String
showPM = PrefixMapping -> String
forall a. Show a => a -> String
show (PrefixMapping -> String)
-> ((Text, Text) -> PrefixMapping) -> (Text, Text) -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text, Text) -> PrefixMapping
PrefixMapping
mappingsStr :: String
mappingsStr = String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
List.intercalate String
", " (((Text, Text) -> String) -> [(Text, Text)] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Text, Text) -> String
showPM (Map Text Text -> [(Text, Text)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Text Text
pmap))
newtype PrefixMapping = PrefixMapping (Text, Text)
deriving (PrefixMapping -> PrefixMapping -> Bool
(PrefixMapping -> PrefixMapping -> Bool)
-> (PrefixMapping -> PrefixMapping -> Bool) -> Eq PrefixMapping
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrefixMapping -> PrefixMapping -> Bool
$c/= :: PrefixMapping -> PrefixMapping -> Bool
== :: PrefixMapping -> PrefixMapping -> Bool
$c== :: PrefixMapping -> PrefixMapping -> Bool
Eq, Eq PrefixMapping
Eq PrefixMapping
-> (PrefixMapping -> PrefixMapping -> Ordering)
-> (PrefixMapping -> PrefixMapping -> Bool)
-> (PrefixMapping -> PrefixMapping -> Bool)
-> (PrefixMapping -> PrefixMapping -> Bool)
-> (PrefixMapping -> PrefixMapping -> Bool)
-> (PrefixMapping -> PrefixMapping -> PrefixMapping)
-> (PrefixMapping -> PrefixMapping -> PrefixMapping)
-> Ord PrefixMapping
PrefixMapping -> PrefixMapping -> Bool
PrefixMapping -> PrefixMapping -> Ordering
PrefixMapping -> PrefixMapping -> PrefixMapping
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PrefixMapping -> PrefixMapping -> PrefixMapping
$cmin :: PrefixMapping -> PrefixMapping -> PrefixMapping
max :: PrefixMapping -> PrefixMapping -> PrefixMapping
$cmax :: PrefixMapping -> PrefixMapping -> PrefixMapping
>= :: PrefixMapping -> PrefixMapping -> Bool
$c>= :: PrefixMapping -> PrefixMapping -> Bool
> :: PrefixMapping -> PrefixMapping -> Bool
$c> :: PrefixMapping -> PrefixMapping -> Bool
<= :: PrefixMapping -> PrefixMapping -> Bool
$c<= :: PrefixMapping -> PrefixMapping -> Bool
< :: PrefixMapping -> PrefixMapping -> Bool
$c< :: PrefixMapping -> PrefixMapping -> Bool
compare :: PrefixMapping -> PrefixMapping -> Ordering
$ccompare :: PrefixMapping -> PrefixMapping -> Ordering
$cp1Ord :: Eq PrefixMapping
Ord)
instance Show PrefixMapping where
show :: PrefixMapping -> String
show (PrefixMapping (Text
prefix, Text
uri)) = String -> String -> ShowS
forall r. PrintfType r => String -> r
printf String
"PrefixMapping (%s, %s)" (Text -> String
forall a. Show a => a -> String
show Text
prefix) (Text -> String
forall a. Show a => a -> String
show Text
uri)
resolveQName :: Text -> PrefixMappings -> Maybe Text
resolveQName :: Text -> PrefixMappings -> Maybe Text
resolveQName Text
prefix (PrefixMappings Map Text Text
pms) = Text -> Map Text Text -> Maybe Text
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Text
prefix Map Text Text
pms
{-# INLINE mkAbsoluteUrl #-}
{-# DEPRECATED mkAbsoluteUrl "Use resolveIRI instead, because mkAbsoluteUrl is a partial function" #-}
mkAbsoluteUrl :: Text -> Text -> Text
mkAbsoluteUrl :: Text -> Text -> Text
mkAbsoluteUrl Text
base Text
iri = (String -> Text) -> (Text -> Text) -> Either String Text -> Text
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either String -> Text
forall a. HasCallStack => String -> a
error Text -> Text
forall a. a -> a
id (Text -> Text -> Either String Text
resolveIRI Text
base Text
iri)
{-# NOINLINE canonicalize #-}
canonicalize :: Text -> Text -> Text
canonicalize :: Text -> Text -> Text
canonicalize Text
typeTxt Text
litValue =
Text -> ((Text -> Text) -> Text) -> Maybe (Text -> Text) -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
litValue ((Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Text
litValue) (Text -> Map Text (Text -> Text) -> Maybe (Text -> Text)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Text
typeTxt Map Text (Text -> Text)
canonicalizerTable)
{-# NOINLINE canonicalizerTable #-}
canonicalizerTable :: Map Text (Text -> Text)
canonicalizerTable :: Map Text (Text -> Text)
canonicalizerTable =
[(Text
integerUri, Text -> Text
_integerStr), (Text
doubleUri, Text -> Text
_doubleStr), (Text
decimalUri, Text -> Text
_decimalStr)]
where
integerUri :: Text
integerUri = Text
"http://www.w3.org/2001/XMLSchema#integer"
decimalUri :: Text
decimalUri = Text
"http://www.w3.org/2001/XMLSchema#decimal"
doubleUri :: Text
doubleUri = Text
"http://www.w3.org/2001/XMLSchema#double"
_integerStr, _decimalStr, _doubleStr :: Text -> Text
_integerStr :: Text -> Text
_integerStr Text
t
| Text -> Int
T.length Text
t Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 = Text
t
| Text -> Char
T.head Text
t Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'0' = Text -> Text
_integerStr (Text -> Text
T.tail Text
t)
| Bool
otherwise = Text
t
_doubleStr :: Text -> Text
_doubleStr Text
s = String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Double -> String
forall a. Show a => a -> String
show (String -> Double
forall a. Read a => String -> a
read (String -> Double) -> String -> Double
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack Text
s :: Double)
_decimalStr :: Text -> Text
_decimalStr Text
s =
case Text -> Char
T.last Text
s of
Char
'.' -> Text -> Text
f (Text
s Text -> Char -> Text
`T.snoc` Char
'0')
Char
_ -> Text -> Text
f Text
s
where
f :: Text -> Text
f Text
s' = String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Double -> String
forall a. Show a => a -> String
show (String -> Double
forall a. Read a => String -> a
read (String -> Double) -> String -> Double
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack Text
s' :: Double)
fileSchemeToFilePath :: (IsString s) => Node -> Maybe s
fileSchemeToFilePath :: Node -> Maybe s
fileSchemeToFilePath (UNode Text
fileScheme)
| Text
"file://" Text -> Text -> Bool
`T.isPrefixOf` Text
fileScheme = Text -> Maybe s
textToFilePath Text
fileScheme
| Bool
otherwise = Maybe s
forall a. Maybe a
Nothing
where
textToFilePath :: Text -> Maybe s
textToFilePath = s -> Maybe s
forall (f :: * -> *) a. Applicative f => a -> f a
pure (s -> Maybe s) -> (String -> s) -> String -> Maybe s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> s
forall a. IsString a => String -> a
fromString (String -> Maybe s) -> (Text -> Maybe String) -> Text -> Maybe s
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< String -> Maybe String
stringToFilePath (String -> Maybe String)
-> (Text -> String) -> Text -> Maybe String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack
stringToFilePath :: String -> Maybe String
stringToFilePath = String -> Maybe String
fixPrefix (String -> Maybe String)
-> (String -> Maybe String) -> String -> Maybe String
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< String -> Maybe String
forall (f :: * -> *) a. Applicative f => a -> f a
pure (String -> Maybe String) -> (URI -> String) -> URI -> Maybe String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
unEscapeString ShowS -> (URI -> String) -> URI -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. URI -> String
Network.uriPath (URI -> Maybe String)
-> (String -> Maybe URI) -> String -> Maybe String
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< String -> Maybe URI
Network.parseURI
fixPrefix :: String -> Maybe String
fixPrefix String
"" = Maybe String
forall a. Maybe a
Nothing
fixPrefix p :: String
p@(Char
p' : String
p'')
| Char
p' Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
FP.pathSeparator = String -> Maybe String
forall a. a -> Maybe a
Just (ShowS
FP.normalise String
p)
| Char
p' Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'/' = String -> Maybe String
forall a. a -> Maybe a
Just (ShowS
FP.normalise String
p'')
| Bool
otherwise = String -> Maybe String
forall a. a -> Maybe a
Just (String
"\\\\" String -> ShowS
forall a. Semigroup a => a -> a -> a
<> ShowS
FP.normalise String
p)
fileSchemeToFilePath Node
_ = Maybe s
forall a. Maybe a
Nothing
filePathToUri :: (IsString s) => FilePath -> Maybe s
filePathToUri :: String -> Maybe s
filePathToUri String
p
| String -> Bool
FP.isRelative String
p = Maybe s
forall a. Maybe a
Nothing
| Bool
otherwise = s -> Maybe s
forall a. a -> Maybe a
Just (s -> Maybe s) -> (String -> s) -> String -> Maybe s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> s
forall a. IsString a => String -> a
fromString (String -> s) -> ShowS -> String -> s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
as_uri ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
FP.normalise (String -> Maybe s) -> String -> Maybe s
forall a b. (a -> b) -> a -> b
$ String
p
where
as_uri :: ShowS
as_uri = (String
"file://" String -> ShowS
forall a. Semigroup a => a -> a -> a
<>) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ShowS
escapeURIString Char -> Bool
isAllowedInURI ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
as_posix ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
fix_prefix
fix_prefix :: ShowS
fix_prefix String
p' = case (ShowS
FP.takeDrive String
p') of
String
"/" -> String
p'
Char
'\\' : Char
'\\' : String
_ -> Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
2 String
p'
String
_ -> Char
'/' Char -> ShowS
forall a. a -> [a] -> [a]
: String
p'
as_posix :: ShowS
as_posix = (Char -> Char) -> ShowS
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Char -> Char
repl
repl :: Char -> Char
repl Char
'\\' = Char
'/'
repl Char
c = Char
c