trifecta 0.31 → 0.32

raw patch · 15 files changed

+68/−74 lines, 15 filesdep ~semigroupsdep ~wl-pprint-extrasdep ~wl-pprint-terminfo

Dependency ranges changed: semigroups, wl-pprint-extras, wl-pprint-terminfo

Files

• Text/Trifecta/CharSet.hs +4/−1
• Text/Trifecta/Diagnostic/Err.hs +1/−2
• Text/Trifecta/Diagnostic/Err/Log.hs +0/−1
• Text/Trifecta/Diagnostic/Err/State.hs +0/−1
• Text/Trifecta/Diagnostic/Prim.hs +0/−1
• Text/Trifecta/Diagnostic/Rendering/Prim.hs +0/−1
• Text/Trifecta/Parser/ByteString.hs +29/−25
• Text/Trifecta/Parser/Class.hs +0/−1
• Text/Trifecta/Parser/It.hs +1/−1
• Text/Trifecta/Parser/Prim.hs +5/−6
• Text/Trifecta/Parser/Result.hs +15/−19
• Text/Trifecta/Parser/Step.hs +9/−9
• Text/Trifecta/Rope/Delta.hs +0/−1
• Text/Trifecta/Rope/Prim.hs +0/−1
• trifecta.cabal +4/−4

@@ -81,7 +81,7 @@ import Data.Bits hiding (complement) import Data.Word import Data.ByteString.Internal (c2w)-import Data.Monoid (Monoid(..))+import Data.Semigroup import qualified Data.IntSet as I import qualified Data.List as L import Prelude hiding (filter, map, null)@@ -345,6 +345,9 @@       normal = prec 10 $ do         Ident "fromDistinctAscList" <- lexP         fromDistinctAscList `fmap` step readPrec++instance Semigroup CharSet where+  (<>) = union  instance Monoid CharSet where   mempty = empty

@@ -5,7 +5,6 @@   ) where  import Data.Semigroup-import Data.Monoid import Data.Functor.Plus import Text.Trifecta.Diagnostic.Prim import Text.Trifecta.Diagnostic.Level@@ -49,7 +48,7 @@  instance Semigroup (Err t) where   (<>) = (<!>)-  replicate1p _ = id+  times1p _ = id  instance Monoid (Err t) where   mempty = EmptyErr

@@ -4,7 +4,6 @@  import Data.Functor.Plus import Data.Semigroup-import Data.Monoid import Text.PrettyPrint.Free import Text.Trifecta.Diagnostic.Prim import Text.Trifecta.Parser.Token.Highlight

@@ -5,7 +5,6 @@ import Data.Functor.Plus import Data.Set as Set import Data.Semigroup-import Data.Monoid import Text.PrettyPrint.Free import Text.Trifecta.Diagnostic.Err 

@@ -12,7 +12,6 @@ import Data.Functor.Apply import Data.Foldable import Data.Traversable-import Data.Monoid import Data.List.NonEmpty hiding (map) import Data.Semigroup import Data.Semigroup.Reducer

@@ -26,7 +26,6 @@ import Data.Array import Data.ByteString hiding (groupBy, empty, any) import Data.Foldable-import Data.Monoid import Data.Function (on) import Data.Functor.Bind import Data.List (groupBy)

@@ -22,11 +22,10 @@  import Control.Applicative import Control.Monad (unless)-import Data.Monoid+import Data.Semigroup import Data.Foldable import qualified Data.ByteString as B import System.Console.Terminfo.PrettyPrint-import Text.Trifecta.Diagnostic.Prim import Text.Trifecta.Parser.Class import Text.Trifecta.Parser.Prim import Text.Trifecta.Parser.Step@@ -42,35 +41,40 @@ -- input read from @filePath@ using 'ByteString.readFile'. All diagnostic messages -- emitted over the course of the parse attempt are shown to the user on the console. ----- >  main    = do{ result <- parseFromFile numbers "digits.txt"--- >              ; case result of--- >                  Nothing -> return ()--- >                  Just a  -> print $ sum a--- >              }+-- > main = do+-- >   result <- parseFromFile numbers "digits.txt"+-- >   case result of+-- >     Nothing -> return ()+-- >     Just a  -> print $ sum a  parseFromFile :: Show a => Parser String a -> String -> IO (Maybe a) parseFromFile p fn = do -  (xs, result) <- parseFromFileEx p fn-  unless (Seq.null xs) $ displayLn $ toList xs-  return result+  result <- parseFromFileEx p fn+  case result of +     Success xs a -> Just a  <$ unless (Seq.null xs) (displayLn (toList xs))+     Failure xs   -> Nothing <$ unless (Seq.null xs) (displayLn (toList xs))  -- | @parseFromFileEx p filePath@ runs a parser @p@ on the -- input read from @filePath@ using 'ByteString.readFile'. Returns all diagnostic messages -- emitted over the course of the parse and the answer if the parse was successful. ----- >  main    = do{ (xs, result) <- parseFromFileEx numbers "digits.txt"--- >              ; unless (Seq.null xs) $ displayLn (toList xs)--- >              ; case result of--- >                  Nothing -> return ()--- >                  Just a  -> print $ sum a--- >              }+-- > main = do+-- >   result <- parseFromFileEx (many number) "digits.txt"+-- >   case result of+-- >     Failure xs -> unless (Seq.null xs) $ displayLn xs+-- >     Success xs a  -> +-- >       unless (Seq.null xs) $ displayLn xs+-- >       print $ sum a+-- > -parseFromFileEx :: Show a => Parser String a -> String -> IO (Seq (Diagnostic TermDoc), Maybe a)-parseFromFileEx p fn = do-  i <- B.readFile fn-  case starve-     $ feed (rope (F.fromList [LineDirective (UTF8.fromString fn) 0, strand i]))-     $ stepParser (fmap prettyTerm) (why prettyTerm) (release (Directed n 0 0 0 0) *> p) mempty True mempty mempty of-     Success xs a -> return (xs,      Just a )-     Failure xs e -> return (xs |> e, Nothing)-  where n = UTF8.fromString fn+parseFromFileEx :: Show a => Parser String a -> String -> IO (Result TermDoc a)+parseFromFileEx p fn = k <$> B.readFile fn where +  k i = starve +      $ feed (rope (F.fromList [LineDirective (UTF8.fromString fn) 0, strand i]))+      $ stepParser (fmap prettyTerm) +                   (why prettyTerm) +                   (release (Directed (UTF8.fromString fn) 0 0 0 0) *> p) +                   mempty +                   True +                   mempty +                   mempty 

@@ -34,7 +34,6 @@ import Control.Monad.Trans.Reader import Control.Monad.Trans.Identity import Data.Functor.Yoneda-import Data.Monoid import Data.Word import Data.ByteString as Strict import Data.ByteString.Internal (w2c)

@@ -15,7 +15,7 @@ import Control.Applicative import Control.Comonad import Control.Monad-import Data.Monoid+import Data.Semigroup import Data.ByteString as Strict import Data.ByteString.Lazy as Lazy import Data.Functor.Bind

@@ -27,7 +27,6 @@ import Data.Functor.Plus hiding (some, many) import Data.Semigroup import Data.Foldable-import Data.Monoid import Data.Functor.Bind (Apply(..), Bind((>>-))) import Data.IntervalMap.FingerTree (Interval(..)) import qualified Data.IntervalMap.FingerTree as IntervalMap@@ -260,12 +259,12 @@   go mempty $ p ju no ju no l0 b80 d0 bs0   where     ju a e l b8 d bs = Pure (JuSt a e l b8 d bs)-    no e l b8 d bs = Pure (NoSt e l b8 d bs)+    no e l b8 d bs   = Pure (NoSt e l b8 d bs)     go r (Pure (JuSt a _ l _ _ _)) = StepDone r (yl <$> errLog l) a-    go r (Pure (NoSt e l b8 d bs)) = StepFail r (yl <$> errLog l) $ y e b8 d bs+    go r (Pure (NoSt e l b8 d bs)) = StepFail r ((yl <$> errLog l) |> y e b8 d bs)     go r (It ma k) = StepCont r (case ma of                                    JuSt a _ l _ _ _  -> Success (yl <$> errLog l) a-                                   NoSt e l b8 d bs  -> Failure (yl <$> errLog l) $ y e b8 d bs) +                                   NoSt e l b8 d bs  -> Failure ((yl <$> errLog l) |> y e b8 d bs))                                  (go <*> k)  why :: Pretty e => (e -> Doc t) -> ErrState e -> Bool -> Delta -> ByteString -> Diagnostic (Doc t)@@ -286,7 +285,7 @@ parseTest p s = case starve                     $ feed (UTF8.fromString s)                     $ stepParser (fmap prettyTerm) (why prettyTerm) (release mempty *> p) mempty True mempty mempty of-  Failure xs e -> displayLn $ prettyTerm $ toList (xs |> e)+  Failure xs -> displayLn $ toList xs   Success xs a -> do-    unless (Seq.null xs) $ displayLn $ prettyTerm $ toList xs+    unless (Seq.null xs) $ displayLn $ toList xs     print a

@@ -3,7 +3,6 @@   ) where  import Control.Applicative-import Data.Monoid import Data.Semigroup import Data.Foldable import Data.Functor.Apply@@ -17,59 +16,56 @@  data Result e a   = Success !(Seq (Diagnostic e)) a-  | Failure !(Seq (Diagnostic e)) !(Diagnostic e)+  | Failure !(Seq (Diagnostic e))   deriving Show  instance (Pretty e, Show a) => Pretty (Result e a) where   pretty (Success xs a)      | Seq.null xs = string (show a)     | otherwise   = prettyList (toList xs) `above` string (show a)-  pretty (Failure xs e) = prettyList $ toList $ xs |> e+  pretty (Failure xs) = prettyList $ toList xs  instance (PrettyTerm e, Show a) => PrettyTerm (Result e a) where   prettyTerm (Success xs a)     | Seq.null xs = string (show a)     | otherwise   = prettyTermList (toList xs) `above` string (show a)-  prettyTerm (Failure xs e) = prettyTermList $ toList $ xs |> e+  prettyTerm (Failure xs) = prettyTermList $ toList xs  instance Functor (Result e) where   fmap f (Success xs a) = Success xs (f a)-  fmap _ (Failure xs e) = Failure xs e+  fmap _ (Failure xs) = Failure xs  instance Bifunctor Result where   bimap f g (Success xs a) = Success (fmap (fmap f) xs) (g a)-  bimap f _ (Failure xs e) = Failure (fmap (fmap f) xs) (fmap f e)+  bimap f _ (Failure xs) = Failure (fmap (fmap f) xs)  instance Foldable (Result e) where   foldMap f (Success _ a) = f a-  foldMap _ (Failure _ _) = mempty+  foldMap _ (Failure _) = mempty  instance Traversable (Result e) where   traverse f (Success xs a) = Success xs <$> f a-  traverse _ (Failure xs e) = pure $ Failure xs e+  traverse _ (Failure xs) = pure $ Failure xs  instance Applicative (Result e) where   pure = Success mempty-  Success xs f <*> Success ys a  = Success (xs <> ys) (f a)-  Success xs _ <*> Failure ys e  = Failure (xs <> ys) e-  Failure xs e <*> Success ys _  = Failure (xs <> ys) e-  Failure xs e <*> Failure ys e' = Failure (xs <> ys |> e) e'+  Success xs f <*> Success ys a = Success (xs <> ys) (f a)+  Success xs _ <*> Failure ys   = Failure (xs <> ys)+  Failure xs   <*> Success ys _ = Failure (xs <> ys)+  Failure xs   <*> Failure ys   = Failure (xs <> ys)  instance Apply (Result e) where   (<.>) = (<*>) -{- instance Alt (Result e) where-  Failure xs e <!> Failure ys e' = Failure (xs <> ys |> e) e'+  Failure xs   <!> Failure ys    = Failure (xs <> ys)   Success xs a <!> Success ys _  = Success (xs <> ys) a-  Success xs a <!> Failure ys e  = Success (xs <> ys) a-  Failure xs _ <!> Success ys a  = Success (xs <> ys |> e) a+  Success xs a <!> Failure ys    = Success (xs <> ys) a+  Failure xs   <!> Success ys a  = Success (xs <> ys) a  instance Plus (Result e) where-  zero = Failure mempty zero+  zero = Failure mempty  instance Alternative (Result e) where    (<|>) = (<!>)   empty = zero--}-

@@ -15,38 +15,38 @@  data Step e a   = StepDone !Rope !(Seq (Diagnostic e)) a-  | StepFail !Rope !(Seq (Diagnostic e)) !(Diagnostic e)+  | StepFail !Rope !(Seq (Diagnostic e))   | StepCont !Rope (Result e a) (Rope -> Step e a)  instance (Show e, Show a) => Show (Step e a) where   showsPrec d (StepDone r xs a) = showParen (d > 10) $      showString "StepDone " . showsPrec 11 r . showChar ' ' . showsPrec 11 xs . showChar ' ' . showsPrec 11 a-  showsPrec d (StepFail r xs e) = showParen (d > 10) $ -    showString "StepFail " . showsPrec 11 r . showChar ' ' . showsPrec 11 xs . showChar ' ' . showsPrec 11 e+  showsPrec d (StepFail r xs) = showParen (d > 10) $ +    showString "StepFail " . showsPrec 11 r . showChar ' ' . showsPrec 11 xs   showsPrec d (StepCont r fin _) = showParen (d > 10) $      showString "StepCont " . showsPrec 11 r . showChar ' ' . showsPrec 11 fin . showString " ..."      instance Functor (Step e) where   fmap f (StepDone r xs a) = StepDone r xs (f a)-  fmap _ (StepFail r xs e) = StepFail r xs e+  fmap _ (StepFail r xs)   = StepFail r xs   fmap f (StepCont r z k)  = StepCont r (fmap f z) (fmap f . k)  instance Bifunctor Step where   bimap f g (StepDone r xs a) = StepDone r (fmap (fmap f) xs) (g a)-  bimap f _ (StepFail r xs e) = StepFail r (fmap (fmap f) xs) (fmap f e)+  bimap f _ (StepFail r xs)   = StepFail r (fmap (fmap f) xs)   bimap f g (StepCont r z k)  = StepCont r (bimap f g z) (bimap f g . k)  feed :: Reducer t Rope => t -> Step e r -> Step e r feed t (StepDone r xs a) = StepDone (snoc r t) xs a-feed t (StepFail r xs e) = StepFail (snoc r t) xs e-feed t (StepCont r _ k) = k (snoc r t)+feed t (StepFail r xs)   = StepFail (snoc r t) xs+feed t (StepCont r _ k)  = k (snoc r t)  starve :: Step e a -> Result e a starve (StepDone _ xs a) = Success xs a-starve (StepFail _ xs e) = Failure xs e+starve (StepFail _ xs)   = Failure xs starve (StepCont _ z _)  = z  stepResult :: Rope -> Result e a -> Step e a stepResult r (Success xs a) = StepDone r xs a-stepResult r (Failure xs e) = StepFail r xs e+stepResult r (Failure xs) = StepFail r xs 

@@ -9,7 +9,6 @@   ) where  import Control.Applicative-import Data.Monoid import Data.Semigroup import Data.Hashable import Data.Word

@@ -9,7 +9,6 @@   , grabLine   ) where -import Data.Monoid import Data.Semigroup import Data.Semigroup.Reducer import Data.ByteString (ByteString)

@@ -1,6 +1,6 @@ name:          trifecta category:      Text, Parsing, Diagnostics, Pretty Printer, Logging-version:       0.31+version:       0.32 license:       BSD3 cabal-version: >= 1.6 license-file:  LICENSE@@ -82,7 +82,7 @@     hashable             >= 1.1.2.1 && < 1.2,     bytestring           >= 0.9.1   && < 0.10,     mtl                  >= 2.0.1   && < 2.1,-    semigroups           >= 0.7.1   && < 0.8, +    semigroups           >= 0.8     && < 0.9,      fingertree           >= 0.0.1   && < 0.1,     reducers             >= 0.1.4   && < 0.2,     profunctors          >= 0.1.1   && < 0.2,@@ -94,5 +94,5 @@     comonad              >= 1.1.1   && < 1.2,     terminfo             >= 0.3.2   && < 0.4,     keys                 >= 2.1     && < 2.2,-    wl-pprint-extras     >= 1.4     && < 1.5,-    wl-pprint-terminfo   >= 0.5.1   && < 0.6+    wl-pprint-extras     >= 1.5     && < 1.6,+    wl-pprint-terminfo   >= 0.6     && < 0.7