{-# language OverloadedStrings #-}
{-# options_ghc -Wno-unused-imports #-}
module Algebra.Graph.IO.Internal.Megaparsec (Parser, ParserT, ParseE,
                                            -- * Internal
                                            lexeme, symbol, anyString, alphaNum
                                            ) where

import Control.Applicative hiding (many, some)
import Data.Char (isAlpha, isSpace, isAlphaNum)
import Data.Void (Void)

-- megaparsec
import Text.Megaparsec (Parsec, ParsecT, parseTest, satisfy, (<?>))
import Text.Megaparsec.Char (space1)
import Text.Megaparsec.Error (ParseErrorBundle)
import qualified Text.Megaparsec.Char.Lexer as L
-- parser-combinators
import Control.Monad.Combinators (many, some, between)
-- text
import Data.Text (Text)

type Parser = Parsec Void Text

type ParserT = ParsecT Void Text

type ParseE = ParseErrorBundle Text Void

lexeme :: Parser a -- ^ disregard any whitespace around this parser
       -> Parser a
lexeme :: forall a. Parser a -> Parser a
lexeme = forall e s (m :: * -> *) a. MonadParsec e s m => m () -> m a -> m a
L.lexeme Parser ()
sc

-- | Match a string
symbol :: Text
       -> Parser Text
symbol :: Text -> Parser Text
symbol = forall e s (m :: * -> *).
MonadParsec e s m =>
m () -> Tokens s -> m (Tokens s)
L.symbol Parser ()
sc

-- | space consumer
sc :: Parser ()
sc :: Parser ()
sc = forall e s (m :: * -> *).
MonadParsec e s m =>
m () -> m () -> m () -> m ()
L.space
     forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
space1
     (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Tokens s -> m ()
L.skipLineComment Tokens Text
"//")
     (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Tokens s -> Tokens s -> m ()
L.skipBlockComment Tokens Text
"/*" Tokens Text
"*/")

anyString, alphaNum :: Parser String
anyString :: Parser String
anyString = forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy Char -> Bool
isAlpha)

alphaNum :: Parser String
alphaNum = forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy forall a b. (a -> b) -> a -> b
$ \Token Text
c -> Char -> Bool
isAlphaNum Token Text
c Bool -> Bool -> Bool
|| Token Text
c forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Char
'-', Char
'_']) forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> String -> m a
<?> String
"alphanumeric string or -"