parsix 0.1.0.4 → 0.2.0.0

raw patch · 4 files changed

+28/−21 lines, 4 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +4/−0
• parsix.cabal +1/−1
• src/Text/Parsix/Combinators.hs +14/−14
• tests/WithRecovery.hs +9/−6

@@ -1,3 +1,7 @@+# 0.2.0.0++- Make `withRecovery` rewind before running recovery+ # 0.1.0.4  - Add `Generic` instances to `Span` and `Position`

@@ -1,5 +1,5 @@ name:                parsix-version:             0.1.0.4+version:             0.2.0.0 synopsis:            Parser combinators with slicing, error recovery, and syntax highlighting description:         A parser combinator library based on 'parsers' (like 'trifecta') with slicing, error recovery, and syntax highlighted diagnostics homepage:            https://github.com/ollef/parsix

@@ -45,14 +45,14 @@ sliced = slicedWith (\_ t -> t)  class Parsing m => RecoveryParsing m where-  withRecovery :: (ErrorInfo -> m a) -> m a -> m a+  withRecovery :: (ErrorInfo -> Position -> m a) -> m a -> m a  instance RecoveryParsing Parser where   withRecovery recover (Parser p) = Parser     $ \s0 s e0 e pos hl inp -> p       s0       s-      (\err -> unParser (recover err)+      (\err -> unParser (recover err pos)         (\a _err' -> s0 a err)         s         (\_err' -> e0 err)@@ -60,13 +60,13 @@         pos         hl         inp)-      (\err pos' hl' -> unParser (recover err)-        (\a _err' -> s a err pos' hl')+      (\err pos' hl' -> unParser (recover err pos')+        (\a _err' -> s a err pos hl)         s         (\_err' -> e err pos' hl')         (\_err' _pos'' _hl'' -> e err pos' hl')-        pos'-        hl'+        pos+        hl         inp)       pos       hl@@ -127,39 +127,39 @@ instance (RecoveryParsing m, MonadPlus m) => RecoveryParsing (Lazy.StateT s m) where   withRecovery r (Lazy.StateT m)     = Lazy.StateT-    $ \s -> withRecovery (\err -> Lazy.runStateT (r err) s) (m s)+    $ \s -> withRecovery (\err pos -> Lazy.runStateT (r err pos) s) (m s)  instance (RecoveryParsing m, MonadPlus m) => RecoveryParsing (Strict.StateT s m) where   withRecovery r (Strict.StateT m)     = Strict.StateT-    $ \s -> withRecovery (\err -> Strict.runStateT (r err) s) (m s)+    $ \s -> withRecovery (\err pos -> Strict.runStateT (r err pos) s) (m s)  instance (RecoveryParsing m, MonadPlus m) => RecoveryParsing (ReaderT e m) where   withRecovery r (ReaderT m)     = ReaderT-    $ \s -> withRecovery (\err -> runReaderT (r err) s) (m s)+    $ \s -> withRecovery (\err pos -> runReaderT (r err pos) s) (m s)  instance (RecoveryParsing m, MonadPlus m, Monoid w) => RecoveryParsing (Strict.WriterT w m) where   withRecovery r (Strict.WriterT m)     = Strict.WriterT-    $ withRecovery (Strict.runWriterT . r) m+    $ withRecovery (\err pos -> Strict.runWriterT $ r err pos) m  instance (RecoveryParsing m, MonadPlus m, Monoid w) => RecoveryParsing (Lazy.WriterT w m) where   withRecovery r (Lazy.WriterT m)     = Lazy.WriterT-    $ withRecovery (Lazy.runWriterT . r) m+    $ withRecovery (\err pos -> Lazy.runWriterT $ r err pos) m  instance (RecoveryParsing m, MonadPlus m, Monoid w) => RecoveryParsing (Lazy.RWST r w s m) where   withRecovery r (Lazy.RWST m)     = Lazy.RWST-    $ \s s' -> withRecovery (\err -> Lazy.runRWST (r err) s s') (m s s')+    $ \s s' -> withRecovery (\err pos -> Lazy.runRWST (r err pos) s s') (m s s')  instance (RecoveryParsing m, MonadPlus m, Monoid w) => RecoveryParsing (Strict.RWST r w s m) where   withRecovery r (Strict.RWST m)     = Strict.RWST-    $ \s s' -> withRecovery (\err -> Strict.runRWST (r err) s s') (m s s')+    $ \s s' -> withRecovery (\err pos -> Strict.runRWST (r err pos) s s') (m s s')  instance (RecoveryParsing m, MonadPlus m) => RecoveryParsing (IdentityT m) where   withRecovery r (IdentityT m)     = IdentityT-    $ withRecovery (runIdentityT . r) m+    $ withRecovery (\err pos -> runIdentityT $ r err pos) m

@@ -8,20 +8,23 @@ tests = testGroup "withRecovery"   [ testProperty "inner epsilon success"     $ \xs -> success (== Just ())-    $ parse (withRecovery (\_ -> pure Nothing) (pure (Just ()))) xs+    $ parse (withRecovery (\_ _ -> pure Nothing) (pure (Just ()))) xs   , testProperty "inner committed success"     $ \x -> success (== Just x)-    $ parse (withRecovery (\_ -> pure Nothing) (Just <$> char x)) [x]+    $ parse (withRecovery (\_ _ -> pure Nothing) (Just <$> char x)) [x]   , testProperty "inner epsilon error"     $ \x y -> x /= y ==> success (== Nothing)-    $ parse (withRecovery (\_ -> pure Nothing) (Just <$> char x)) [y]+    $ parse (withRecovery (\_ _ -> pure Nothing) (Just <$> char x)) [y]   , testProperty "inner committed error"     $ \x y -> x /= y ==> success (== Nothing)-    $ parse (withRecovery (\_ -> pure Nothing) (Just <$> char x <* char x)) [x, y]+    $ parse (withRecovery (\_ _ -> pure Nothing) (Just <$> char x <* char x)) [x, y]   , testProperty "recover epsilon error"     $ \x y -> x /= y ==> failure (atPosition 1)-    $ parse (withRecovery (\_ -> empty) (Just <$> char x <* char x)) [x, y]+    $ parse (withRecovery (\_ _ -> empty) (Just <$> char x <* char x)) [x, y]   , testProperty "recover committed error"     $ \x y z -> x /= y && y /= z ==> failure (atPosition 1)-    $ parse (withRecovery (\_ -> Nothing <$ char y <* char y) (Just <$> char x <* char x)) [x, y, z]+    $ parse (withRecovery (\_ _ -> Nothing <$ char y <* char y) (Just <$> char x <* char x)) [x, y, z]+  , testProperty "recovery runs from start"+    $ \x y -> x /= y ==> success (== Just x)+    $ parse (withRecovery (\_ _ -> Just <$> char x <* char y) (Just <$> char x <* char x)) [x, y]   ]