SimpleParser.Lexer

Utilities for handling lexing/tokenization as a separate parsing pass

Documentation

data Spanned p a

A value annotated with a Span

Constructors

Spanned

Fields

• spannedSpan :: !(Span p)
• spannedValue :: !a

Instances

Functor (Spanned p)

Defined in SimpleParser.Lexer

Methods

fmap :: (a -> b) -> Spanned p a -> Spanned p b

(<$) :: a -> Spanned p b -> Spanned p a

Foldable (Spanned p)

Defined in SimpleParser.Lexer

Methods

fold :: Monoid m => Spanned p m -> m

foldMap :: Monoid m => (a -> m) -> Spanned p a -> m

foldMap' :: Monoid m => (a -> m) -> Spanned p a -> m

foldr :: (a -> b -> b) -> b -> Spanned p a -> b

foldr' :: (a -> b -> b) -> b -> Spanned p a -> b

foldl :: (b -> a -> b) -> b -> Spanned p a -> b

foldl' :: (b -> a -> b) -> b -> Spanned p a -> b

foldr1 :: (a -> a -> a) -> Spanned p a -> a

foldl1 :: (a -> a -> a) -> Spanned p a -> a

toList :: Spanned p a -> [a]

null :: Spanned p a -> Bool

length :: Spanned p a -> Int

elem :: Eq a => a -> Spanned p a -> Bool

maximum :: Ord a => Spanned p a -> a

minimum :: Ord a => Spanned p a -> a

sum :: Num a => Spanned p a -> a

product :: Num a => Spanned p a -> a

Traversable (Spanned p)

Defined in SimpleParser.Lexer

Methods

traverse :: Applicative f => (a -> f b) -> Spanned p a -> f (Spanned p b)

sequenceA :: Applicative f => Spanned p (f a) -> f (Spanned p a)

mapM :: Monad m => (a -> m b) -> Spanned p a -> m (Spanned p b)

sequence :: Monad m => Spanned p (m a) -> m (Spanned p a)

(Eq p, Eq a) => Eq (Spanned p a)

Defined in SimpleParser.Lexer

Methods

(==) :: Spanned p a -> Spanned p a -> Bool

(/=) :: Spanned p a -> Spanned p a -> Bool

(Show p, Show a) => Show (Spanned p a)

Defined in SimpleParser.Lexer

Methods

showsPrec :: Int -> Spanned p a -> ShowS

show :: Spanned p a -> String

showList :: [Spanned p a] -> ShowS

data LexedStream p a

A materialized sequence of Spanned values

Constructors

LexedStream

Fields

• lsTokens :: !(Seq (Spanned p a))
• lsEndPos :: !p

Instances

Functor (LexedStream p)

Defined in SimpleParser.Lexer

Methods

fmap :: (a -> b) -> LexedStream p a -> LexedStream p b

(<$) :: a -> LexedStream p b -> LexedStream p a

Foldable (LexedStream p)

Defined in SimpleParser.Lexer

Methods

fold :: Monoid m => LexedStream p m -> m

foldMap :: Monoid m => (a -> m) -> LexedStream p a -> m

foldMap' :: Monoid m => (a -> m) -> LexedStream p a -> m

foldr :: (a -> b -> b) -> b -> LexedStream p a -> b

foldr' :: (a -> b -> b) -> b -> LexedStream p a -> b

foldl :: (b -> a -> b) -> b -> LexedStream p a -> b

foldl' :: (b -> a -> b) -> b -> LexedStream p a -> b

foldr1 :: (a -> a -> a) -> LexedStream p a -> a

foldl1 :: (a -> a -> a) -> LexedStream p a -> a

toList :: LexedStream p a -> [a]

null :: LexedStream p a -> Bool

length :: LexedStream p a -> Int

elem :: Eq a => a -> LexedStream p a -> Bool

maximum :: Ord a => LexedStream p a -> a

minimum :: Ord a => LexedStream p a -> a

sum :: Num a => LexedStream p a -> a

product :: Num a => LexedStream p a -> a

Traversable (LexedStream p)

Defined in SimpleParser.Lexer

Methods

traverse :: Applicative f => (a -> f b) -> LexedStream p a -> f (LexedStream p b)

sequenceA :: Applicative f => LexedStream p (f a) -> f (LexedStream p a)

mapM :: Monad m => (a -> m b) -> LexedStream p a -> m (LexedStream p b)

sequence :: Monad m => LexedStream p (m a) -> m (LexedStream p a)

(Eq p, Eq a) => Eq (LexedStream p a)

Defined in SimpleParser.Lexer

Methods

(==) :: LexedStream p a -> LexedStream p a -> Bool

(/=) :: LexedStream p a -> LexedStream p a -> Bool

(Show p, Show a) => Show (LexedStream p a)

Defined in SimpleParser.Lexer

Methods

showsPrec :: Int -> LexedStream p a -> ShowS

show :: LexedStream p a -> String

showList :: [LexedStream p a] -> ShowS

PosStream (LexedStream p a)

Defined in SimpleParser.Lexer

Associated Types

type Pos (LexedStream p a)

Methods

streamViewPos :: LexedStream p a -> Pos (LexedStream p a)

Stream (LexedStream p a)

Defined in SimpleParser.Lexer

Associated Types

type Chunk (LexedStream p a)

type Token (LexedStream p a)

Methods

streamTake1 :: LexedStream p a -> Maybe (Token (LexedStream p a), LexedStream p a)

streamTakeN :: Int -> LexedStream p a -> Maybe (Chunk (LexedStream p a), LexedStream p a)

streamTakeWhile :: (Token (LexedStream p a) -> Bool) -> LexedStream p a -> (Chunk (LexedStream p a), LexedStream p a)

streamDropN :: Int -> LexedStream p a -> Maybe (Int, LexedStream p a)

streamDropWhile :: (Token (LexedStream p a) -> Bool) -> LexedStream p a -> (Int, LexedStream p a)

type Pos (LexedStream p a)

Defined in SimpleParser.Lexer

type Pos (LexedStream p a) = LexedSpan p

type Chunk (LexedStream p a)

Defined in SimpleParser.Lexer

type Chunk (LexedStream p a) = Seq a

type Token (LexedStream p a)

Defined in SimpleParser.Lexer

type Token (LexedStream p a) = a

data LexedSpan p

Position in a LexedStream

Constructors

LexedSpanElem !(Span p)

LexedSpanEnd !p

Instances

Eq p => Eq (LexedSpan p)

Defined in SimpleParser.Lexer

Methods

(==) :: LexedSpan p -> LexedSpan p -> Bool

(/=) :: LexedSpan p -> LexedSpan p -> Bool

Show p => Show (LexedSpan p)

Defined in SimpleParser.Lexer

Methods

showsPrec :: Int -> LexedSpan p -> ShowS

show :: LexedSpan p -> String

showList :: [LexedSpan p] -> ShowS

HasLinePos p => HasLinePos (LexedSpan p)

Defined in SimpleParser.Lexer

Methods

viewLine :: LexedSpan p -> Line

viewCol :: LexedSpan p -> Col

spannedParser :: (PosStream s, Monad m) => ParserT l s e m a -> ParserT l s e m (Spanned (Pos s) a)

Annotates parse result with a span

lexedParser :: (PosStream s, Monad m) => ParserT l s e m a -> ParserT l s e m (LexedStream (Pos s) a)

Given a parser for a single token, repeatedly apply it and annotate results with spans

runParserLexed :: (Typeable l1, Typeable e1, Typeable s, Typeable (Token s), Typeable (Chunk s), Show l1, Show e1, Show s, Show (Token s), Show (Chunk s), Typeable l2, Typeable e2, Typeable (Pos s), Typeable a, Show l2, Show e2, Show (Pos s), Show a, PosStream s, MonadThrow m) => Parser l1 s e1 a -> (LexedStream (Pos s) a -> LexedStream (Pos s) a) -> Parser l2 (LexedStream (Pos s) a) e2 b -> s -> m b

Similar to runParserEnd - first lexes the entire stream, applies the given cleanup function, then runs the second parser over the results

lexedParseInteractive :: (s ~ LinePosStream Text, TextBuildable a, ExplainLabel l1, ExplainError e1, ExplainLabel l2, ExplainError e2) => Parser l1 s e1 a -> (LexedStream (Pos s) a -> LexedStream (Pos s) a) -> Parser l2 (LexedStream (Pos s) a) e2 b -> String -> IO (Maybe b)

Similar to parseInteractive