{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE TypeFamilies, DeriveGeneric #-}
module Text.Gigaparsec (
Parsec, Result(..), result, parse, parseFromFile, parseRepl,
atomic, lookAhead, notFollowedBy, eof,
unit,
pure, empty,
($>),
(<$>), (<$), void,
(<~>), (<:>),
(<*>), liftA2, (*>), (<*), (<**>),
(<+>),
(<|>),
select, branch,
filterS, mapMaybeS,
many, some, manyl, manyr, somel, somer, manyMap, someMap,
) where
import Text.Gigaparsec.Internal (Parsec(Parsec), emptyState, manyr, somer)
import Text.Gigaparsec.Internal qualified as Internal (State(..), useHints, expectedErr)
import Text.Gigaparsec.Internal.RT qualified as Internal (RT, runRT, rtToIO)
import Text.Gigaparsec.Internal.Errors qualified as Internal (ParseError, ExpectItem(ExpectEndOfInput), fromParseError)
import Text.Gigaparsec.Errors.ErrorBuilder (ErrorBuilder)
import Text.Gigaparsec.Errors.Combinator (filterSWith, mapMaybeSWith)
import Text.Gigaparsec.Errors.ErrorGen (vanillaGen)
import Data.Functor (void)
import Control.Applicative (liftA2, (<|>), empty, many, some, (<**>))
import Control.Selective (select, branch)
import Data.Set qualified as Set (singleton, empty)
import GHC.Generics (Generic)
type Result :: * -> * -> *
data Result e a = Success a | Failure e deriving stock (Int -> Result e a -> ShowS
[Result e a] -> ShowS
Result e a -> String
(Int -> Result e a -> ShowS)
-> (Result e a -> String)
-> ([Result e a] -> ShowS)
-> Show (Result e a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall e a. (Show a, Show e) => Int -> Result e a -> ShowS
forall e a. (Show a, Show e) => [Result e a] -> ShowS
forall e a. (Show a, Show e) => Result e a -> String
$cshowsPrec :: forall e a. (Show a, Show e) => Int -> Result e a -> ShowS
showsPrec :: Int -> Result e a -> ShowS
$cshow :: forall e a. (Show a, Show e) => Result e a -> String
show :: Result e a -> String
$cshowList :: forall e a. (Show a, Show e) => [Result e a] -> ShowS
showList :: [Result e a] -> ShowS
Show, Result e a -> Result e a -> Bool
(Result e a -> Result e a -> Bool)
-> (Result e a -> Result e a -> Bool) -> Eq (Result e a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall e a. (Eq a, Eq e) => Result e a -> Result e a -> Bool
$c== :: forall e a. (Eq a, Eq e) => Result e a -> Result e a -> Bool
== :: Result e a -> Result e a -> Bool
$c/= :: forall e a. (Eq a, Eq e) => Result e a -> Result e a -> Bool
/= :: Result e a -> Result e a -> Bool
Eq, (forall x. Result e a -> Rep (Result e a) x)
-> (forall x. Rep (Result e a) x -> Result e a)
-> Generic (Result e a)
forall x. Rep (Result e a) x -> Result e a
forall x. Result e a -> Rep (Result e a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall e a x. Rep (Result e a) x -> Result e a
forall e a x. Result e a -> Rep (Result e a) x
$cfrom :: forall e a x. Result e a -> Rep (Result e a) x
from :: forall x. Result e a -> Rep (Result e a) x
$cto :: forall e a x. Rep (Result e a) x -> Result e a
to :: forall x. Rep (Result e a) x -> Result e a
Generic)
result :: (e -> b) -> (a -> b) -> Result e a -> b
result :: forall e b a. (e -> b) -> (a -> b) -> Result e a -> b
result e -> b
_ a -> b
success (Success a
x) = a -> b
success a
x
result e -> b
failure a -> b
_ (Failure e
err) = e -> b
failure e
err
{-# SPECIALISE parse :: Parsec a -> String -> Result String a #-}
{-# INLINABLE parse #-}
parse :: forall err a. ErrorBuilder err
=> Parsec a
-> String
-> Result err a
parse :: forall err a.
ErrorBuilder err =>
Parsec a -> String -> Result err a
parse Parsec a
p String
inp = RT (Result err a) -> Result err a
forall a. RT a -> a
Internal.runRT (RT (Result err a) -> Result err a)
-> RT (Result err a) -> Result err a
forall a b. (a -> b) -> a -> b
$ Maybe String -> Parsec a -> String -> RT (Result err a)
forall err a.
ErrorBuilder err =>
Maybe String -> Parsec a -> String -> RT (Result err a)
_parse Maybe String
forall a. Maybe a
Nothing Parsec a
p String
inp
parseRepl :: Show a
=> Parsec a
-> String
-> IO ()
parseRepl :: forall a. Show a => Parsec a -> String -> IO ()
parseRepl Parsec a
p String
inp =
do Result String a
res <- RT (Result String a) -> IO (Result String a)
forall a. RT a -> IO a
Internal.rtToIO (RT (Result String a) -> IO (Result String a))
-> RT (Result String a) -> IO (Result String a)
forall a b. (a -> b) -> a -> b
$ Maybe String -> Parsec a -> String -> RT (Result String a)
forall err a.
ErrorBuilder err =>
Maybe String -> Parsec a -> String -> RT (Result err a)
_parse Maybe String
forall a. Maybe a
Nothing Parsec a
p String
inp
(String -> IO ()) -> (a -> IO ()) -> Result String a -> IO ()
forall e b a. (e -> b) -> (a -> b) -> Result e a -> b
result String -> IO ()
putStrLn a -> IO ()
forall a. Show a => a -> IO ()
print Result String a
res
{-# SPECIALISE parseFromFile :: Parsec a -> String -> IO (Result String a) #-}
{-# INLINABLE parseFromFile #-}
parseFromFile :: forall err a. ErrorBuilder err
=> Parsec a
-> FilePath
-> IO (Result err a)
parseFromFile :: forall err a.
ErrorBuilder err =>
Parsec a -> String -> IO (Result err a)
parseFromFile Parsec a
p String
f =
do String
inp <- String -> IO String
readFile String
f
RT (Result err a) -> IO (Result err a)
forall a. RT a -> IO a
Internal.rtToIO (RT (Result err a) -> IO (Result err a))
-> RT (Result err a) -> IO (Result err a)
forall a b. (a -> b) -> a -> b
$ Maybe String -> Parsec a -> String -> RT (Result err a)
forall err a.
ErrorBuilder err =>
Maybe String -> Parsec a -> String -> RT (Result err a)
_parse (String -> Maybe String
forall a. a -> Maybe a
Just String
f) Parsec a
p String
inp
{-# INLINE _parse #-}
_parse :: forall err a. ErrorBuilder err => Maybe FilePath -> Parsec a -> String -> Internal.RT (Result err a)
_parse :: forall err a.
ErrorBuilder err =>
Maybe String -> Parsec a -> String -> RT (Result err a)
_parse Maybe String
file (Parsec forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r
p) String
inp = State
-> (a -> State -> RT (Result err a))
-> (ParseError -> State -> RT (Result err a))
-> RT (Result err a)
forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r
p (String -> State
emptyState String
inp) a -> State -> RT (Result err a)
good ParseError -> State -> RT (Result err a)
bad
where good :: a -> Internal.State -> Internal.RT (Result err a)
good :: a -> State -> RT (Result err a)
good a
x State
_ = Result err a -> RT (Result err a)
forall a. a -> RT a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> Result err a
forall e a. a -> Result e a
Success a
x)
bad :: Internal.ParseError -> Internal.State -> Internal.RT (Result err a)
bad :: ParseError -> State -> RT (Result err a)
bad ParseError
err State
_ = Result err a -> RT (Result err a)
forall a. a -> RT a
forall (m :: * -> *) a. Monad m => a -> m a
return (err -> Result err a
forall e a. e -> Result e a
Failure (Maybe String -> String -> ParseError -> err
forall err.
ErrorBuilder err =>
Maybe String -> String -> ParseError -> err
Internal.fromParseError Maybe String
file String
inp ParseError
err))
atomic :: Parsec a
-> Parsec a
atomic :: forall a. Parsec a -> Parsec a
atomic (Parsec forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r
p) = (forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec a
forall a.
(forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec a
Parsec ((forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec a)
-> (forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec a
forall a b. (a -> b) -> a -> b
$ \State
st a -> State -> RT r
ok ParseError -> State -> RT r
bad -> State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r
forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r
p State
st a -> State -> RT r
ok (\ParseError
err State
_ -> ParseError -> State -> RT r
bad ParseError
err State
st)
lookAhead :: Parsec a
-> Parsec a
lookAhead :: forall a. Parsec a -> Parsec a
lookAhead (Parsec forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r
p) = (forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec a
forall a.
(forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec a
Parsec ((forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec a)
-> (forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec a
forall a b. (a -> b) -> a -> b
$ \State
st a -> State -> RT r
ok ParseError -> State -> RT r
err -> State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r
forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r
p State
st (\a
x State
_ -> a -> State -> RT r
ok a
x State
st) ParseError -> State -> RT r
err
notFollowedBy :: Parsec a
-> Parsec ()
notFollowedBy :: forall a. Parsec a -> Parsec ()
notFollowedBy (Parsec forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r
p) = (forall r.
State
-> (() -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec ()
forall a.
(forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec a
Parsec ((forall r.
State
-> (() -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec ())
-> (forall r.
State
-> (() -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec ()
forall a b. (a -> b) -> a -> b
$ \State
st () -> State -> RT r
ok ParseError -> State -> RT r
bad ->
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r
forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r
p State
st (\a
_ State
st' -> let !width :: Word
width = State -> Word
Internal.consumed State
st' Word -> Word -> Word
forall a. Num a => a -> a -> a
- State -> Word
Internal.consumed State
st
in (ParseError -> State -> RT r) -> ParseError -> State -> RT r
forall r.
(ParseError -> State -> RT r) -> ParseError -> State -> RT r
Internal.useHints ParseError -> State -> RT r
bad (State -> Set ExpectItem -> Word -> ParseError
Internal.expectedErr State
st Set ExpectItem
forall a. Set a
Set.empty Word
width) State
st)
(\ParseError
_ State
_ -> () -> State -> RT r
ok () State
st)
eof :: Parsec ()
eof :: Parsec ()
eof = (forall r.
State
-> (() -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec ()
forall a.
(forall r.
State
-> (a -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec a
Parsec ((forall r.
State
-> (() -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec ())
-> (forall r.
State
-> (() -> State -> RT r) -> (ParseError -> State -> RT r) -> RT r)
-> Parsec ()
forall a b. (a -> b) -> a -> b
$ \State
st () -> State -> RT r
good ParseError -> State -> RT r
bad -> case State -> String
Internal.input State
st of
(:){} -> (ParseError -> State -> RT r) -> ParseError -> State -> RT r
forall r.
(ParseError -> State -> RT r) -> ParseError -> State -> RT r
Internal.useHints ParseError -> State -> RT r
bad
(State -> Set ExpectItem -> Word -> ParseError
Internal.expectedErr State
st (ExpectItem -> Set ExpectItem
forall a. a -> Set a
Set.singleton ExpectItem
Internal.ExpectEndOfInput) Word
1) State
st
[] -> () -> State -> RT r
good () State
st
unit :: Parsec ()
unit :: Parsec ()
unit = () -> Parsec ()
forall a. a -> Parsec a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
infixl 4 <~>
(<~>) :: Parsec a -> Parsec b -> Parsec (a, b)
<~> :: forall a b. Parsec a -> Parsec b -> Parsec (a, b)
(<~>) = (a -> b -> (a, b)) -> Parsec a -> Parsec b -> Parsec (a, b)
forall a b c. (a -> b -> c) -> Parsec a -> Parsec b -> Parsec c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (,)
infixl 4 $>
($>) :: Parsec a -> b -> Parsec b
$> :: forall a b. Parsec a -> b -> Parsec b
($>) = (b -> Parsec a -> Parsec b) -> Parsec a -> b -> Parsec b
forall a b c. (a -> b -> c) -> b -> a -> c
flip b -> Parsec a -> Parsec b
forall a b. a -> Parsec b -> Parsec a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
(<$)
infixl 4 <:>
(<:>) :: Parsec a -> Parsec [a] -> Parsec [a]
<:> :: forall a. Parsec a -> Parsec [a] -> Parsec [a]
(<:>) = (a -> [a] -> [a]) -> Parsec a -> Parsec [a] -> Parsec [a]
forall a b c. (a -> b -> c) -> Parsec a -> Parsec b -> Parsec c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (:)
infixl 3 <+>
(<+>) :: Parsec a -> Parsec b -> Parsec (Either a b)
Parsec a
p <+> :: forall a b. Parsec a -> Parsec b -> Parsec (Either a b)
<+> Parsec b
q = a -> Either a b
forall a b. a -> Either a b
Left (a -> Either a b) -> Parsec a -> Parsec (Either a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec a
p Parsec (Either a b) -> Parsec (Either a b) -> Parsec (Either a b)
forall a. Parsec a -> Parsec a -> Parsec a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> b -> Either a b
forall a b. b -> Either a b
Right (b -> Either a b) -> Parsec b -> Parsec (Either a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec b
q
manyl :: (b -> a -> b) -> b -> Parsec a -> Parsec b
manyl :: forall b a. (b -> a -> b) -> b -> Parsec a -> Parsec b
manyl b -> a -> b
f b
k = (b -> a -> b) -> Parsec b -> Parsec a -> Parsec b
forall b a. (b -> a -> b) -> Parsec b -> Parsec a -> Parsec b
_repl b -> a -> b
f (b -> Parsec b
forall a. a -> Parsec a
forall (f :: * -> *) a. Applicative f => a -> f a
pure b
k)
somel :: (b -> a -> b) -> b -> Parsec a -> Parsec b
somel :: forall b a. (b -> a -> b) -> b -> Parsec a -> Parsec b
somel b -> a -> b
f b
k Parsec a
p = (b -> a -> b) -> Parsec b -> Parsec a -> Parsec b
forall b a. (b -> a -> b) -> Parsec b -> Parsec a -> Parsec b
_repl b -> a -> b
f (b -> a -> b
f b
k (a -> b) -> Parsec a -> Parsec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec a
p) Parsec a
p
manyMap :: Monoid m
=> (a -> m)
-> Parsec a
-> Parsec m
manyMap :: forall m a. Monoid m => (a -> m) -> Parsec a -> Parsec m
manyMap a -> m
f = (m -> m -> m) -> m -> Parsec m -> Parsec m
forall a b. (a -> b -> b) -> b -> Parsec a -> Parsec b
manyr m -> m -> m
forall a. Semigroup a => a -> a -> a
(<>) m
forall a. Monoid a => a
mempty (Parsec m -> Parsec m)
-> (Parsec a -> Parsec m) -> Parsec a -> Parsec m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> m) -> Parsec a -> Parsec m
forall a b. (a -> b) -> Parsec a -> Parsec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m
f
someMap :: Semigroup s
=> (a -> s)
-> Parsec a
-> Parsec s
someMap :: forall s a. Semigroup s => (a -> s) -> Parsec a -> Parsec s
someMap a -> s
f Parsec a
p = (s -> s -> s) -> Parsec s -> Parsec s -> Parsec s
forall b a. (b -> a -> b) -> Parsec b -> Parsec a -> Parsec b
_repl s -> s -> s
forall a. Semigroup a => a -> a -> a
(<>) (a -> s
f (a -> s) -> Parsec a -> Parsec s
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec a
p) (a -> s
f (a -> s) -> Parsec a -> Parsec s
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec a
p)
_repl :: (b -> a -> b) -> Parsec b -> Parsec a -> Parsec b
_repl :: forall b a. (b -> a -> b) -> Parsec b -> Parsec a -> Parsec b
_repl b -> a -> b
f Parsec b
k Parsec a
p = Parsec b
k Parsec b -> Parsec (b -> b) -> Parsec b
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> (a -> (b -> b) -> b -> b)
-> (b -> b) -> Parsec a -> Parsec (b -> b)
forall a b. (a -> b -> b) -> b -> Parsec a -> Parsec b
manyr (\a
x b -> b
next !b
acc -> b -> b
next (b -> a -> b
f b
acc a
x)) b -> b
forall a. a -> a
id Parsec a
p
filterS :: (a -> Bool) -> Parsec a -> Parsec a
filterS :: forall a. (a -> Bool) -> Parsec a -> Parsec a
filterS = ErrorGen a -> (a -> Bool) -> Parsec a -> Parsec a
forall a. ErrorGen a -> (a -> Bool) -> Parsec a -> Parsec a
filterSWith ErrorGen a
forall a. ErrorGen a
vanillaGen
mapMaybeS :: (a -> Maybe b) -> Parsec a -> Parsec b
mapMaybeS :: forall a b. (a -> Maybe b) -> Parsec a -> Parsec b
mapMaybeS = ErrorGen a -> (a -> Maybe b) -> Parsec a -> Parsec b
forall a b. ErrorGen a -> (a -> Maybe b) -> Parsec a -> Parsec b
mapMaybeSWith ErrorGen a
forall a. ErrorGen a
vanillaGen