packages feed

looksee 0.8.0 → 0.8.1

raw patch · 2 files changed

+77/−2 lines, 2 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

+ Looksee.Lexer: lexeme :: forall e (m :: Type -> Type) a. ParserT e m () -> ParserT e m a -> ParserT e m a
+ Looksee.Lexer: skipBlockComment :: forall (m :: Type -> Type) e. Monad m => Text -> Text -> ParserT e m ()
+ Looksee.Lexer: skipLineComment :: forall (m :: Type -> Type) e. Monad m => Text -> ParserT e m ()
+ Looksee.Lexer: space :: forall (m :: Type -> Type) e. Monad m => ParserT e m () -> ParserT e m () -> ParserT e m () -> ParserT e m ()
+ Looksee.Lexer: symbol :: forall (m :: Type -> Type) e. Monad m => ParserT e m () -> Text -> ParserT e m Text
+ Looksee.Lexer: symbol_ :: forall (m :: Type -> Type) e. Monad m => ParserT e m () -> Text -> ParserT e m ()
- Looksee: altP :: (Monad m, Foldable f) => f (ParserT e m a) -> ParserT e m a
+ Looksee: altP :: forall (m :: Type -> Type) f e a. (Monad m, Foldable f) => f (ParserT e m a) -> ParserT e m a
- Looksee: betweenP :: ParserT e m x -> ParserT e m y -> ParserT e m a -> ParserT e m a
+ Looksee: betweenP :: forall e (m :: Type -> Type) x y a. ParserT e m x -> ParserT e m y -> ParserT e m a -> ParserT e m a
- Looksee: branchP :: (Monad m, Foldable f) => f (ParserT e m (), ParserT e m a) -> ParserT e m a
+ Looksee: branchP :: forall (m :: Type -> Type) f e a. (Monad m, Foldable f) => f (ParserT e m (), ParserT e m a) -> ParserT e m a
- Looksee: breakP :: Monad m => Text -> ParserT e m a -> ParserT e m a
+ Looksee: breakP :: forall (m :: Type -> Type) e a. Monad m => Text -> ParserT e m a -> ParserT e m a
- Looksee: charP :: Monad m => Char -> ParserT e m Char
+ Looksee: charP :: forall (m :: Type -> Type) e. Monad m => Char -> ParserT e m Char
- Looksee: charP_ :: Monad m => Char -> ParserT e m ()
+ Looksee: charP_ :: forall (m :: Type -> Type) e. Monad m => Char -> ParserT e m ()
- Looksee: commitP :: (Monad m, Foldable f) => f (ParserT e m (), ParserT e m a) -> ParserT e m a
+ Looksee: commitP :: forall (m :: Type -> Type) f e a. (Monad m, Foldable f) => f (ParserT e m (), ParserT e m a) -> ParserT e m a
- Looksee: data ParserT e m a
+ Looksee: data ParserT e (m :: Type -> Type) a
- Looksee: decP :: Monad m => ParserT e m Rational
+ Looksee: decP :: forall (m :: Type -> Type) e. Monad m => ParserT e m Rational
- Looksee: doubleStrP :: Monad m => ParserT e m Text
+ Looksee: doubleStrP :: forall (m :: Type -> Type) e. Monad m => ParserT e m Text
- Looksee: dropAll1P :: Monad m => ParserT e m Int
+ Looksee: dropAll1P :: forall (m :: Type -> Type) e. Monad m => ParserT e m Int
- Looksee: dropAllP :: Monad m => ParserT e m Int
+ Looksee: dropAllP :: forall (m :: Type -> Type) e. Monad m => ParserT e m Int
- Looksee: dropExactP :: Monad m => Int -> ParserT e m ()
+ Looksee: dropExactP :: forall (m :: Type -> Type) e. Monad m => Int -> ParserT e m ()
- Looksee: dropP :: Monad m => Int -> ParserT e m Int
+ Looksee: dropP :: forall (m :: Type -> Type) e. Monad m => Int -> ParserT e m Int
- Looksee: dropWhile1P :: Monad m => (Char -> Bool) -> ParserT e m Int
+ Looksee: dropWhile1P :: forall (m :: Type -> Type) e. Monad m => (Char -> Bool) -> ParserT e m Int
- Looksee: dropWhileP :: Monad m => (Char -> Bool) -> ParserT e m Int
+ Looksee: dropWhileP :: forall (m :: Type -> Type) e. Monad m => (Char -> Bool) -> ParserT e m Int
- Looksee: emptyP :: Monad m => ParserT e m a
+ Looksee: emptyP :: forall (m :: Type -> Type) e a. Monad m => ParserT e m a
- Looksee: endP :: Monad m => ParserT e m ()
+ Looksee: endP :: forall (m :: Type -> Type) e. Monad m => ParserT e m ()
- Looksee: explainP :: Monad m => (Reason e (Err e) -> Maybe (Text, Bool)) -> ParserT e m a -> ParserT e m a
+ Looksee: explainP :: forall (m :: Type -> Type) e a. Monad m => (Reason e (Err e) -> Maybe (Text, Bool)) -> ParserT e m a -> ParserT e m a
- Looksee: headP :: Monad m => ParserT e m Char
+ Looksee: headP :: forall (m :: Type -> Type) e. Monad m => ParserT e m Char
- Looksee: infixRP :: Monad m => Text -> ParserT e m a -> ParserT e m b -> ParserT e m (a, b)
+ Looksee: infixRP :: forall (m :: Type -> Type) e a b. Monad m => Text -> ParserT e m a -> ParserT e m b -> ParserT e m (a, b)
- Looksee: intP :: Monad m => ParserT e m Integer
+ Looksee: intP :: forall (m :: Type -> Type) e. Monad m => ParserT e m Integer
- Looksee: iterP :: ParserT e m (Maybe a) -> ParserT e m a
+ Looksee: iterP :: forall e (m :: Type -> Type) a. ParserT e m (Maybe a) -> ParserT e m a
- Looksee: labelP :: Monad m => Label -> ParserT e m a -> ParserT e m a
+ Looksee: labelP :: forall (m :: Type -> Type) e a. Monad m => Label -> ParserT e m a -> ParserT e m a
- Looksee: lead1P :: Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
+ Looksee: lead1P :: forall (m :: Type -> Type) e a. Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
- Looksee: leadP :: Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
+ Looksee: leadP :: forall (m :: Type -> Type) e a. Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
- Looksee: lookP :: Monad m => ParserT e m a -> ParserT e m a
+ Looksee: lookP :: forall (m :: Type -> Type) e a. Monad m => ParserT e m a -> ParserT e m a
- Looksee: measureP :: Monad m => ParserT e m a -> ParserT e m (a, Int)
+ Looksee: measureP :: forall (m :: Type -> Type) e a. Monad m => ParserT e m a -> ParserT e m (a, Int)
- Looksee: numP :: Monad m => ParserT e m (Either Integer Scientific)
+ Looksee: numP :: forall (m :: Type -> Type) e. Monad m => ParserT e m (Either Integer Scientific)
- Looksee: optP :: Monad m => ParserT e m a -> ParserT e m (Maybe a)
+ Looksee: optP :: forall (m :: Type -> Type) e a. Monad m => ParserT e m a -> ParserT e m (Maybe a)
- Looksee: repeat1P :: Monad m => ParserT e m a -> ParserT e m (Seq a)
+ Looksee: repeat1P :: forall (m :: Type -> Type) e a. Monad m => ParserT e m a -> ParserT e m (Seq a)
- Looksee: repeatP :: Monad m => ParserT e m a -> ParserT e m (Seq a)
+ Looksee: repeatP :: forall (m :: Type -> Type) e a. Monad m => ParserT e m a -> ParserT e m (Seq a)
- Looksee: sciP :: Monad m => ParserT e m Scientific
+ Looksee: sciP :: forall (m :: Type -> Type) e. Monad m => ParserT e m Scientific
- Looksee: scopeP :: Monad m => s -> ParserT e (StateT s m) a -> ParserT e m a
+ Looksee: scopeP :: forall (m :: Type -> Type) s e a. Monad m => s -> ParserT e (StateT s m) a -> ParserT e m a
- Looksee: sepBy1P :: Monad m => ParserT e m () -> ParserT e m a -> ParserT e m (Seq a)
+ Looksee: sepBy1P :: forall (m :: Type -> Type) e a. Monad m => ParserT e m () -> ParserT e m a -> ParserT e m (Seq a)
- Looksee: sepBy2P :: Monad m => ParserT e m () -> ParserT e m a -> ParserT e m (Seq a)
+ Looksee: sepBy2P :: forall (m :: Type -> Type) e a. Monad m => ParserT e m () -> ParserT e m a -> ParserT e m (Seq a)
- Looksee: sepByP :: Monad m => ParserT e m () -> ParserT e m a -> ParserT e m (Seq a)
+ Looksee: sepByP :: forall (m :: Type -> Type) e a. Monad m => ParserT e m () -> ParserT e m a -> ParserT e m (Seq a)
- Looksee: signedP :: (Monad m, Num a) => ParserT e m a -> ParserT e m a
+ Looksee: signedP :: forall (m :: Type -> Type) a e. (Monad m, Num a) => ParserT e m a -> ParserT e m a
- Looksee: signedWithP :: Monad m => (a -> a) -> ParserT e m a -> ParserT e m a
+ Looksee: signedWithP :: forall (m :: Type -> Type) a e. Monad m => (a -> a) -> ParserT e m a -> ParserT e m a
- Looksee: singleStrP :: Monad m => ParserT e m Text
+ Looksee: singleStrP :: forall (m :: Type -> Type) e. Monad m => ParserT e m Text
- Looksee: someBreakP :: Monad m => Text -> ParserT e m a -> ParserT e m a
+ Looksee: someBreakP :: forall (m :: Type -> Type) e a. Monad m => Text -> ParserT e m a -> ParserT e m a
- Looksee: someInfixRP :: Monad m => Text -> ParserT e m a -> ParserT e m b -> ParserT e m (a, b)
+ Looksee: someInfixRP :: forall (m :: Type -> Type) e a b. Monad m => Text -> ParserT e m a -> ParserT e m b -> ParserT e m (a, b)
- Looksee: space1P :: Monad m => ParserT e m ()
+ Looksee: space1P :: forall (m :: Type -> Type) e. Monad m => ParserT e m ()
- Looksee: spaceP :: Monad m => ParserT e m ()
+ Looksee: spaceP :: forall (m :: Type -> Type) e. Monad m => ParserT e m ()
- Looksee: spanAroundP :: Monad m => (Span Int -> a -> b) -> ParserT e m a -> ParserT e m b
+ Looksee: spanAroundP :: forall (m :: Type -> Type) a b e. Monad m => (Span Int -> a -> b) -> ParserT e m a -> ParserT e m b
- Looksee: spanP :: Monad m => ParserT e m (Span Int)
+ Looksee: spanP :: forall (m :: Type -> Type) e. Monad m => ParserT e m (Span Int)
- Looksee: split1P :: Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
+ Looksee: split1P :: forall (m :: Type -> Type) e a. Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
- Looksee: split2P :: Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
+ Looksee: split2P :: forall (m :: Type -> Type) e a. Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
- Looksee: splitP :: Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
+ Looksee: splitP :: forall (m :: Type -> Type) e a. Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
- Looksee: strP :: Monad m => Char -> ParserT e m Text
+ Looksee: strP :: forall (m :: Type -> Type) e. Monad m => Char -> ParserT e m Text
- Looksee: strip1P :: Monad m => ParserT e m a -> ParserT e m a
+ Looksee: strip1P :: forall (m :: Type -> Type) e a. Monad m => ParserT e m a -> ParserT e m a
- Looksee: stripEnd1P :: Monad m => ParserT e m a -> ParserT e m a
+ Looksee: stripEnd1P :: forall (m :: Type -> Type) e a. Monad m => ParserT e m a -> ParserT e m a
- Looksee: stripEndP :: Monad m => ParserT e m a -> ParserT e m a
+ Looksee: stripEndP :: forall (m :: Type -> Type) e a. Monad m => ParserT e m a -> ParserT e m a
- Looksee: stripP :: Monad m => ParserT e m a -> ParserT e m a
+ Looksee: stripP :: forall (m :: Type -> Type) e a. Monad m => ParserT e m a -> ParserT e m a
- Looksee: stripStart1P :: Monad m => ParserT e m a -> ParserT e m a
+ Looksee: stripStart1P :: forall (m :: Type -> Type) e a. Monad m => ParserT e m a -> ParserT e m a
- Looksee: stripStartP :: Monad m => ParserT e m a -> ParserT e m a
+ Looksee: stripStartP :: forall (m :: Type -> Type) e a. Monad m => ParserT e m a -> ParserT e m a
- Looksee: takeAll1P :: Monad m => ParserT e m Text
+ Looksee: takeAll1P :: forall (m :: Type -> Type) e. Monad m => ParserT e m Text
- Looksee: takeAllP :: Monad m => ParserT e m Text
+ Looksee: takeAllP :: forall (m :: Type -> Type) e. Monad m => ParserT e m Text
- Looksee: takeExactP :: Monad m => Int -> ParserT e m Text
+ Looksee: takeExactP :: forall (m :: Type -> Type) e. Monad m => Int -> ParserT e m Text
- Looksee: takeP :: Monad m => Int -> ParserT e m Text
+ Looksee: takeP :: forall (m :: Type -> Type) e. Monad m => Int -> ParserT e m Text
- Looksee: takeWhile1P :: Monad m => (Char -> Bool) -> ParserT e m Text
+ Looksee: takeWhile1P :: forall (m :: Type -> Type) e. Monad m => (Char -> Bool) -> ParserT e m Text
- Looksee: takeWhileP :: Monad m => (Char -> Bool) -> ParserT e m Text
+ Looksee: takeWhileP :: forall (m :: Type -> Type) e. Monad m => (Char -> Bool) -> ParserT e m Text
- Looksee: textP :: Monad m => Text -> ParserT e m Text
+ Looksee: textP :: forall (m :: Type -> Type) e. Monad m => Text -> ParserT e m Text
- Looksee: textP_ :: Monad m => Text -> ParserT e m ()
+ Looksee: textP_ :: forall (m :: Type -> Type) e. Monad m => Text -> ParserT e m ()
- Looksee: throwP :: Monad m => e -> ParserT e m a
+ Looksee: throwP :: forall (m :: Type -> Type) e a. Monad m => e -> ParserT e m a
- Looksee: trail1P :: Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
+ Looksee: trail1P :: forall (m :: Type -> Type) e a. Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
- Looksee: trailP :: Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
+ Looksee: trailP :: forall (m :: Type -> Type) e a. Monad m => Text -> ParserT e m a -> ParserT e m (Seq a)
- Looksee: transP :: (MonadTrans t, Monad m) => (forall a. t m a -> m a) -> ParserT e (t m) b -> ParserT e m b
+ Looksee: transP :: (MonadTrans t, Monad m) => (forall a. () => t m a -> m a) -> ParserT e (t m) b -> ParserT e m b
- Looksee: udecP :: Monad m => ParserT e m Rational
+ Looksee: udecP :: forall (m :: Type -> Type) e. Monad m => ParserT e m Rational
- Looksee: uintP :: Monad m => ParserT e m Integer
+ Looksee: uintP :: forall (m :: Type -> Type) e. Monad m => ParserT e m Integer
- Looksee: unconsP :: Monad m => ParserT e m (Maybe Char)
+ Looksee: unconsP :: forall (m :: Type -> Type) e. Monad m => ParserT e m (Maybe Char)
- Looksee: unumP :: Monad m => ParserT e m (Either Integer Scientific)
+ Looksee: unumP :: forall (m :: Type -> Type) e. Monad m => ParserT e m (Either Integer Scientific)
- Looksee: usciP :: Monad m => ParserT e m Scientific
+ Looksee: usciP :: forall (m :: Type -> Type) e. Monad m => ParserT e m Scientific

Files

looksee.cabal view
@@ -1,11 +1,11 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.37.0.+-- This file has been generated from package.yaml by hpack version 0.38.0. -- -- see: https://github.com/sol/hpack  name:           looksee-version:        0.8.0+version:        0.8.1 synopsis:       A simple text parser with decent errors description:    Please see the README on GitHub at <https://github.com/ejconlon/looksee#readme> category:       Parsing@@ -29,6 +29,7 @@   exposed-modules:       Looksee       Looksee.Examples+      Looksee.Lexer   other-modules:       Paths_looksee   hs-source-dirs:
+ src/Looksee/Lexer.hs view
@@ -0,0 +1,74 @@+-- | Adaptor layer for porting from 'Text.Megaparser.Char.Lexer'.+module Looksee.Lexer+  ( space+  , lexeme+  , symbol+  , symbol_+  , skipLineComment+  , skipBlockComment+  )+where++import Control.Monad (void)+import Data.Text (Text)+import Looksee (ParserT, altP, breakP, dropAllP, dropWhileP, optP, textP, textP_)++space+  :: (Monad m)+  => ParserT e m ()+  -- ^ A parser for space characters which does not accept empty (e.g. 'space1P')+  -> ParserT e m ()+  -- ^ A parser for a line comment (e.g. 'skipLineComment')+  -> ParserT e m ()+  -- ^ A parser for a block comment (e.g. 'skipBlockComment')+  -> ParserT e m ()+space sp line block =+  let p = optP (altP [sp, line, block])+      go = p >>= \case Nothing -> pure (); Just _ -> go+  in  go++lexeme+  :: ParserT e m ()+  -- ^ How to consume white space after lexeme+  -> ParserT e m a+  -- ^ How to parse actual lexeme+  -> ParserT e m a+lexeme spc p = p <* spc++symbol+  :: (Monad m)+  => ParserT e m ()+  -- ^ How to consume white space after lexeme+  -> Text+  -- ^ Symbol to parse+  -> ParserT e m Text+symbol spc = lexeme spc . textP++symbol_+  :: (Monad m)+  => ParserT e m ()+  -- ^ How to consume white space after lexeme+  -> Text+  -- ^ Symbol to parse+  -> ParserT e m ()+symbol_ spc = lexeme spc . textP_++skipLineComment+  :: (Monad m)+  => Text+  -- ^ Line comment prefix+  -> ParserT e m ()+skipLineComment start = do+  textP_ start+  void (dropWhileP (/= '\n'))++skipBlockComment+  :: (Monad m)+  => Text+  -- ^ Start of block comment+  -> Text+  -- ^ End of block comment+  -> ParserT e m ()+skipBlockComment start end = do+  textP_ start+  void (breakP end dropAllP)