boomerang 1.3.3 → 1.3.4

raw patch · 9 files changed

+181/−158 lines, 9 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• Text/Boomerang.hs +3/−3
• Text/Boomerang/Combinators.hs +41/−36
• Text/Boomerang/Error.hs +2/−2
• Text/Boomerang/Prim.hs +28/−25
• Text/Boomerang/String.hs +21/−18
• Text/Boomerang/Strings.hs +23/−23
• Text/Boomerang/TH.hs +26/−14
• Text/Boomerang/Texts.hs +35/−35
• boomerang.cabal +2/−2

@@ -42,15 +42,15 @@ >     | Baz Int Char >       deriving (Eq, Show) -Then we derive some combinators for the type:+Then we generate some combinators for the type: -> $(derivePrinterParsers ''Foo)+> $(makeBoomerangs ''Foo)  The combinators will be named after the constructors, but with an r prefixed to them. In this case, @rBar@ and @rBaz@.  Now we can define a grammar: -> foo :: StringPrinterParser () (Foo :- ())+> foo :: StringBoomerang () (Foo :- ()) > foo = >     (  rBar >     <> rBaz . "baz-" . int . "-" . alpha

@@ -1,5 +1,5 @@ -- | a collection of generic parsing combinators that can work with any token and error type.-{-# LANGUAGE TemplateHaskell, TypeOperators #-}+{-# LANGUAGE CPP, TemplateHaskell, TypeOperators #-} module Text.Boomerang.Combinators     ( (<>), duck, duck1, opt     , manyr, somer, chainr, chainr1, manyl, somel, chainl, chainl1@@ -14,73 +14,78 @@ import Control.Category    (Category((.), id)) import Control.Monad       (guard) import Control.Monad.Error (Error)-import Data.Monoid         (Monoid(mappend))-import Text.Boomerang.Prim    (Parser(..), PrinterParser(..), (.~), val, xpure)+import Text.Boomerang.Prim    (Parser(..), Boomerang(..), (.~), val, xpure) import Text.Boomerang.HStack   ((:-)(..), arg, hhead)-import Text.Boomerang.TH      (derivePrinterParsers)+import Text.Boomerang.TH      (makeBoomerangs) -infixr 8 <>+#if MIN_VERSION_base(4,5,0)+import Data.Monoid         (Monoid(mappend), (<>))+#else+import Data.Monoid         (Monoid(mappend)) +infixr 6 <>+ -- | Infix operator for 'mappend'. (<>) :: Monoid m => m -> m -> m (<>) = mappend+#endif  -- | Convert a router to do what it does on the tail of the stack.-duck :: PrinterParser e tok r1 r2 -> PrinterParser e tok (h :- r1) (h :- r2)-duck r = PrinterParser+duck :: Boomerang e tok r1 r2 -> Boomerang e tok (h :- r1) (h :- r2)+duck r = Boomerang   (fmap (\f (h :- t) -> h :- f t) $ prs r)   (\(h :- t) -> map (second (h :-)) $ ser r t)  -- | Convert a router to do what it does on the tail of the stack.-duck1 :: PrinterParser e tok r1 (a :- r2) -> PrinterParser e tok (h :- r1) (a :- h :- r2)-duck1 r = PrinterParser+duck1 :: Boomerang e tok r1 (a :- r2) -> Boomerang e tok (h :- r1) (a :- h :- r2)+duck1 r = Boomerang   (fmap (\f (h :- t) -> let a :- t' = f t in a :- h :- t') $ prs r)   (\(a :- h :- t) -> map (second (h :-)) $ ser r (a :- t))  -- | Make a router optional.-opt :: PrinterParser e tok r r -> PrinterParser e tok r r+opt :: Boomerang e tok r r -> Boomerang e tok r r opt = (id <>)  -- | Repeat a router zero or more times, combining the results from left to right.-manyr :: PrinterParser e tok r r -> PrinterParser e tok r r+manyr :: Boomerang e tok r r -> Boomerang e tok r r manyr = opt . somer  -- | Repeat a router one or more times, combining the results from left to right.-somer :: PrinterParser e tok r r -> PrinterParser e tok r r+somer :: Boomerang e tok r r -> Boomerang e tok r r somer p = p . manyr p  -- | @chainr p op@ repeats @p@ zero or more times, separated by @op@. --   The result is a right associative fold of the results of @p@ with the results of @op@.-chainr :: PrinterParser e tok r r -> PrinterParser e tok r r -> PrinterParser e tok r r+chainr :: Boomerang e tok r r -> Boomerang e tok r r -> Boomerang e tok r r chainr p op = opt (manyr (p .~ op) . p)  -- | @chainr1 p op@ repeats @p@ one or more times, separated by @op@. --   The result is a right associative fold of the results of @p@ with the results of @op@.-chainr1 :: PrinterParser e tok r (a :- r) -> PrinterParser e tok (a :- a :- r) (a :- r) -> PrinterParser e tok r (a :- r)+chainr1 :: Boomerang e tok r (a :- r) -> Boomerang e tok (a :- a :- r) (a :- r) -> Boomerang e tok r (a :- r) chainr1 p op = manyr (duck p .~ op) . p  -- | Repeat a router zero or more times, combining the results from right to left.-manyl :: PrinterParser e tok r r -> PrinterParser e tok r r+manyl :: Boomerang e tok r r -> Boomerang e tok r r manyl = opt . somel  -- | Repeat a router one or more times, combining the results from right to left.-somel :: PrinterParser e tok r r -> PrinterParser e tok r r+somel :: Boomerang e tok r r -> Boomerang e tok r r somel p = p .~ manyl p  -- | @chainl1 p op@ repeats @p@ zero or more times, separated by @op@. --   The result is a left associative fold of the results of @p@ with the results of @op@.-chainl :: PrinterParser e tok r r -> PrinterParser e tok r r -> PrinterParser e tok r r+chainl :: Boomerang e tok r r -> Boomerang e tok r r -> Boomerang e tok r r chainl p op = opt (p .~ manyl (op . p))  -- | @chainl1 p op@ repeats @p@ one or more times, separated by @op@. --   The result is a left associative fold of the results of @p@ with the results of @op@.-chainl1 :: PrinterParser e tok r (a :- r) -> PrinterParser e tok (a :- a :- r) (a :- r) -> PrinterParser e tok r (a :- r)+chainl1 :: Boomerang e tok r (a :- r) -> Boomerang e tok (a :- a :- r) (a :- r) -> Boomerang e tok r (a :- r) chainl1 p op = p .~ manyl (op . duck p)  -- | Filtering on routers. -- -- TODO: We remove any parse errors, not sure if the should be preserved. Also, if the predicate fails we silently remove the element, but perhaps we should replace the value with an error message?-rFilter :: (a -> Bool) -> PrinterParser e tok () (a :- ()) -> PrinterParser e tok r (a :- r)+rFilter :: (a -> Bool) -> Boomerang e tok () (a :- ()) -> Boomerang e tok r (a :- r) rFilter p r = val ps ss     where       ps = Parser $ \tok pos ->@@ -92,52 +97,52 @@ --   and if it does, instead serializes as @s@. -- -- TODO: can this be more general so that it can work on @tok@ instead of @[tok]@-printAs :: PrinterParser e [tok] a b -> tok -> PrinterParser e [tok] a b+printAs :: Boomerang e [tok] a b -> tok -> Boomerang e [tok] a b printAs r s = r { ser = map (first (const (s :))) . take 1 . ser r }  -- | Push a value on the stack (during parsing, pop it from the stack when serializing).-push :: (Eq a, Error e) => a -> PrinterParser e tok r (a :- r)+push :: (Eq a, Error e) => a -> Boomerang e tok r (a :- r) push a = xpure (a :-) (\(a' :- t) -> guard (a' == a) >> Just t) -rNil :: PrinterParser e tok r ([a] :- r)+rNil :: Boomerang e tok r ([a] :- r) rNil = xpure ([] :-) $ \(xs :- t) -> do [] <- Just xs; Just t -rCons :: PrinterParser e tok (a :- [a] :- r) ([a] :- r)+rCons :: Boomerang e tok (a :- [a] :- r) ([a] :- r) rCons = xpure (arg (arg (:-)) (:)) $ \(xs :- t) -> do a:as <- Just xs; Just (a :- as :- t)  -- | Converts a router for a value @a@ to a router for a list of @a@.-rList :: PrinterParser e tok r (a :- r) -> PrinterParser e tok r ([a] :- r)+rList :: Boomerang e tok r (a :- r) -> Boomerang e tok r ([a] :- r) rList r = manyr (rCons . duck1 r) . rNil  -- | Converts a router for a value @a@ to a router for a list of @a@.-rList1 :: PrinterParser e tok r (a :- r) -> PrinterParser e tok r ([a] :- r)+rList1 :: Boomerang e tok r (a :- r) -> Boomerang e tok r ([a] :- r) rList1 r = somer (rCons . duck1 r) . rNil  -- | Converts a router for a value @a@ to a router for a list of @a@, with a separator.-rListSep :: PrinterParser e tok r (a :- r) -> PrinterParser e tok ([a] :- r) ([a] :- r) -> PrinterParser e tok r ([a] :- r)+rListSep :: Boomerang e tok r (a :- r) -> Boomerang e tok ([a] :- r) ([a] :- r) -> Boomerang e tok r ([a] :- r) rListSep r sep = chainr (rCons . duck1 r) sep . rNil -rPair :: PrinterParser e tok (f :- s :- r) ((f, s) :- r)+rPair :: Boomerang e tok (f :- s :- r) ((f, s) :- r) rPair = xpure (arg (arg (:-)) (,)) $ \(ab :- t) -> do (a,b) <- Just ab; Just (a :- b :- t) -$(derivePrinterParsers ''Either)+$(makeBoomerangs ''Either)  -- | Combines a router for a value @a@ and a router for a value @b@ into a router for @Either a b@.-rEither :: PrinterParser e tok r (a :- r) -> PrinterParser e tok r (b :- r) -> PrinterParser e tok r (Either a b :- r)+rEither :: Boomerang e tok r (a :- r) -> Boomerang e tok r (b :- r) -> Boomerang e tok r (Either a b :- r) rEither l r = rLeft . l <> rRight . r -$(derivePrinterParsers ''Maybe)+$(makeBoomerangs ''Maybe)  -- | Converts a router for a value @a@ to a router for a @Maybe a@.-rMaybe :: PrinterParser e tok r (a :- r) -> PrinterParser e tok r (Maybe a :- r)+rMaybe :: Boomerang e tok r (a :- r) -> Boomerang e tok r (Maybe a :- r) rMaybe r = rJust . r <> rNothing -$(derivePrinterParsers ''Bool)+$(makeBoomerangs ''Bool) -rBool :: PrinterParser e tok a r -- ^ 'True' parser-      -> PrinterParser e tok a r -- ^ 'False' parser-      -> PrinterParser e tok a (Bool :- r)+rBool :: Boomerang e tok a r -- ^ 'True' parser+      -> Boomerang e tok a r -- ^ 'False' parser+      -> Boomerang e tok a (Bool :- r) rBool t f = rTrue . t <> rFalse . f -rUnit :: PrinterParser e tok r (() :- r)+rUnit :: Boomerang e tok r (() :- r) rUnit = xpure ((:-) ()) (\ (() :- x) -> Just x)

@@ -1,4 +1,4 @@--- | An Error handling scheme that can be used with 'PrinterParser'+-- | An Error handling scheme that can be used with 'Boomerang' {-# LANGUAGE DeriveDataTypeable, TypeFamilies #-} module Text.Boomerang.Error where @@ -55,7 +55,7 @@ -- | annotate a parse error with an additional 'Expect' message -- -- > satisfy isUpper <?> 'an uppercase character'-(<?>) :: PrinterParser (ParserError p) tok a b -> String -> PrinterParser (ParserError p) tok a b+(<?>) :: Boomerang (ParserError p) tok a b -> String -> Boomerang (ParserError p) tok a b router <?> msg =     router { prs = Parser $ \tok pos ->         map (either (\(ParserError mPos errs) -> Left $ ParserError mPos ((Expect msg) : errs)) Right) (runParser (prs router) tok pos) }

@@ -1,10 +1,10 @@ {-# LANGUAGE FlexibleContexts, ScopedTypeVariables, TypeOperators, TypeFamilies #-} module Text.Boomerang.Prim     ( -- * Types-    Parser(..), PrinterParser(..), (.~)+    Parser(..), Boomerang(..), PrinterParser, (.~)     -- * Running routers     , parse, parse1, unparse, unparse1, bestErrors-    -- * Constructing / Manipulating PrinterParsers+    -- * Constructing / Manipulating Boomerangs     , xpure, val, xmap     -- heterogeneous list functions     , xmaph@@ -88,70 +88,73 @@ bestErrors [] = [] bestErrors errs = maximumsBy (compare `on` getPosition) errs --- | A @PrinterParser a b@ takes an @a@ to parse a URL and results in @b@ if parsing succeeds.+-- | A @Boomerang a b@ takes an @a@ to parse a URL and results in @b@ if parsing succeeds. --   And it takes a @b@ to serialize to a URL and results in @a@ if serializing succeeds.-data PrinterParser e tok a b = PrinterParser+data Boomerang e tok a b = Boomerang   { prs :: Parser e tok (a -> b)   , ser :: b -> [(tok -> tok, a)]   } -instance Category (PrinterParser e tok) where-  id = PrinterParser+type PrinterParser = Boomerang+{-# DEPRECATED PrinterParser "Use Boomerang instead" #-}++instance Category (Boomerang e tok) where+  id = Boomerang     (return id)     (\x -> [(id, x)]) -  ~(PrinterParser pf sf) . ~(PrinterParser pg sg) = PrinterParser+  ~(Boomerang pf sf) . ~(Boomerang pg sg) = Boomerang     (composeP (.) pf pg)     (compose (.) sf sg) -instance Monoid (PrinterParser e tok a b) where-  mempty = PrinterParser+instance Monoid (Boomerang e tok a b) where+  mempty = Boomerang     mzero     (const mzero) -  ~(PrinterParser pf sf) `mappend` ~(PrinterParser pg sg) = PrinterParser+  ~(Boomerang pf sf) `mappend` ~(Boomerang pg sg) = Boomerang     (pf `mplus` pg)     (\s -> sf s `mplus` sg s)  infixr 9 .~ -- | Reverse composition, but with the side effects still in left-to-right order.-(.~) :: PrinterParser e tok a b -> PrinterParser e tok b c -> PrinterParser e tok a c-~(PrinterParser pf sf) .~ ~(PrinterParser pg sg) = PrinterParser+(.~) :: Boomerang e tok a b -> Boomerang e tok b c -> Boomerang e tok a c+~(Boomerang pf sf) .~ ~(Boomerang pg sg) = Boomerang   (composeP (flip (.)) pf pg)   (compose (flip (.)) sg sf)  -- | Map over routers.-xmap :: (a -> b) -> (b -> Maybe a) -> PrinterParser e tok r a -> PrinterParser e tok r b-xmap f g (PrinterParser p s) = PrinterParser p' s'+xmap :: (a -> b) -> (b -> Maybe a) -> Boomerang e tok r a -> Boomerang e tok r b+xmap f g (Boomerang p s) = Boomerang p' s'     where       p' = fmap (fmap f) p       s' url = maybe mzero s (g url)  -- | Lift a constructor-destructor pair to a pure router.-xpure :: (a -> b) -> (b -> Maybe a) -> PrinterParser e tok a b+xpure :: (a -> b) -> (b -> Maybe a) -> Boomerang e tok a b xpure f g = xmap f g id  -- | Like "xmap", but only maps over the top of the stack.-xmaph :: (a -> b) -> (b -> Maybe a) -> PrinterParser e tok i (a :- o) -> PrinterParser e tok i (b :- o)+xmaph :: (a -> b) -> (b -> Maybe a) -> Boomerang e tok i (a :- o) -> Boomerang e tok i (b :- o) xmaph f g = xmap (hdMap f) (hdTraverse g) --- | lift a 'Parser' and a printer into a 'PrinterParser'-val :: forall e tok a r. Parser e tok a -> (a -> [tok -> tok]) -> PrinterParser e tok r (a :- r)-val rs ss = PrinterParser rs' ss'+-- | lift a 'Parser' and a printer into a 'Boomerang'+val :: forall e tok a r. Parser e tok a -> (a -> [tok -> tok]) -> Boomerang e tok r (a :- r)+val rs ss = Boomerang rs' ss'     where       rs' :: Parser e tok (r -> (a :- r))       rs' = fmap (:-) rs       ss' =  (\(a :- r) -> map (\f -> (f, r)) (ss a))  -- | Give all possible parses or errors.-parse :: forall e a p tok. (InitialPosition e) => PrinterParser e tok () a -> tok -> [Either e (a, tok)]+parse :: forall e a p tok. (InitialPosition e) => Boomerang e tok () a -> tok -> [Either e (a, tok)] parse p s =     map (either Left (\((f, tok), _) -> Right (f (), tok))) $ runParser (prs p) s (initialPos (Nothing :: Maybe e)) --- | Give the first parse, for PrinterParsers with a parser that yields just one value.+-- | Give the first parse, for Boomerangs with a parser that yields just one value. -- Otherwise return the error (or errors) with the highest error position. parse1 :: (ErrorPosition e, InitialPosition e, Show e, Ord (Pos e)) =>-          (tok -> Bool) -> PrinterParser e tok () (a :- ()) -> tok -> Either [e] a+          (tok -> Bool) -> Boomerang e tok () (a :- ()) -> tok -> Either [e] a parse1 isComplete r paths =     let results = parse r paths     in case [ a | (Right (a,tok)) <- results, isComplete tok ] of@@ -159,11 +162,11 @@          _             -> Left $ bestErrors [ e | Left e <- results ]  -- | Give all possible serializations.-unparse :: tok -> PrinterParser e tok () url -> url -> [tok]+unparse :: tok -> Boomerang e tok () url -> url -> [tok] unparse tok p = (map (($ tok) . fst)) . ser p --- | Give the first serialization, for PrinterParsers with a serializer that needs just one value.-unparse1 :: tok -> PrinterParser e tok () (a :- ()) -> a -> Maybe tok+-- | Give the first serialization, for Boomerangs with a serializer that needs just one value.+unparse1 :: tok -> Boomerang e tok () (a :- ()) -> a -> Maybe tok unparse1 tok p a =     case unparse tok p (a :- ()) of       [] -> Nothing

@@ -1,13 +1,13 @@--- | a 'PrinterParser' library for working with a 'String'+-- | a 'Boomerang' library for working with a 'String' {-# LANGUAGE DeriveDataTypeable, FlexibleContexts, FlexibleInstances, TemplateHaskell, TypeFamilies, TypeSynonymInstances, TypeOperators #-} module Text.Boomerang.String     (     -- * Types-      StringPrinterParser, StringError+      StringBoomerang, StringPrinterParser, StringError     -- * Combinators     , alpha, anyChar, char, digit, int     , integer, lit, satisfy, space-    -- * Running the 'PrinterParser'+    -- * Running the 'Boomerang'     , isComplete, parseString, unparseString     )     where@@ -22,17 +22,20 @@ import Text.Boomerang.Error       (ParserError(..),ErrorMsg(..), (<?>), condenseErrors, mkParserError) import Text.Boomerang.HStack       ((:-)(..)) import Text.Boomerang.Pos         (InitialPosition(..), MajorMinorPos(..), incMajor, incMinor)-import Text.Boomerang.Prim        (Parser(..), PrinterParser(..), parse1, xmaph, unparse1, val)+import Text.Boomerang.Prim        (Parser(..), Boomerang(..), parse1, xmaph, unparse1, val)  type StringError         = ParserError MajorMinorPos-type StringPrinterParser = PrinterParser StringError String+type StringBoomerang = Boomerang StringError String +type StringPrinterParser = StringBoomerang+{-# DEPRECATED StringPrinterParser "Use StringBoomerang instead" #-}+ instance InitialPosition StringError where     initialPos _ = MajorMinorPos 0 0  -- | a constant string-lit :: String -> StringPrinterParser r r-lit l = PrinterParser pf sf+lit :: String -> StringBoomerang r r+lit l = Boomerang pf sf     where       pf = Parser $ \tok pos ->            case tok of@@ -47,11 +50,11 @@     | l /= s    = mkParserError pos [UnExpect (show s), Expect (show l)]     | otherwise = parseLit ls ss (if l == '\n' then incMajor 1 pos else incMinor 1 pos) -instance a ~ b => IsString (PrinterParser StringError String a b) where+instance a ~ b => IsString (Boomerang StringError String a b) where     fromString = lit  -- | statisfy a 'Char' predicate-satisfy :: (Char -> Bool) -> StringPrinterParser r (Char :- r)+satisfy :: (Char -> Bool) -> StringBoomerang r (Char :- r) satisfy p = val   (Parser $ \tok pos ->        case tok of@@ -65,24 +68,24 @@   (\c -> [ \paths -> (c:paths) | p c ])  -- | ascii digits @\'0\'..\'9\'@-digit :: StringPrinterParser r (Char :- r)+digit :: StringBoomerang r (Char :- r) digit = satisfy isDigit <?> "a digit 0-9"  -- | matches alphabetic Unicode characters (lower-case, upper-case and title-case letters, -- plus letters of caseless scripts and modifiers letters).  (Uses 'isAlpha')-alpha :: StringPrinterParser r (Char :- r)+alpha :: StringBoomerang r (Char :- r) alpha = satisfy isAlpha <?> "an alphabetic Unicode character"  -- | matches white-space characters in the Latin-1 range. (Uses 'isSpace')-space :: StringPrinterParser r (Char :- r)+space :: StringBoomerang r (Char :- r) space = satisfy isSpace <?> "a white-space character"  -- | any character-anyChar :: StringPrinterParser r (Char :- r)+anyChar :: StringBoomerang r (Char :- r) anyChar = satisfy (const True)  -- | matches the specified character-char :: Char -> StringPrinterParser r (Char :- r)+char :: Char -> StringBoomerang r (Char :- r) char c = satisfy (== c) <?> show [c]  readIntegral :: (Read a, Eq a, Num a) => String -> a@@ -93,11 +96,11 @@       _   -> error "readIntegral: ambiguous parse"  -- | matches an 'Int'-int :: StringPrinterParser r (Int :- r)+int :: StringBoomerang r (Int :- r) int = xmaph readIntegral (Just . show) (opt (rCons . char '-') . (rList1 digit))  -- | matches an 'Integer'-integer :: StringPrinterParser r (Integer :- r)+integer :: StringBoomerang r (Integer :- r) integer = xmaph readIntegral (Just . show) (opt (rCons . char '-') . (rList1 digit))  -- | Predicate to test if we have parsed all the strings.@@ -112,7 +115,7 @@ -- Returns the first complete parse or a parse error. -- -- > parseString (rUnit . lit "foo") ["foo"]-parseString :: StringPrinterParser () (r :- ())+parseString :: StringBoomerang () (r :- ())              -> String              -> Either StringError r parseString pp strs =@@ -121,5 +124,5 @@ -- | run the printer -- -- > unparseString (rUnit . lit "foo") ()-unparseString :: StringPrinterParser () (r :- ()) -> r -> Maybe String+unparseString :: StringBoomerang () (r :- ()) -> r -> Maybe String unparseString pp r = unparse1 [] pp r

@@ -1,4 +1,4 @@--- | a 'PrinterParser' library for working with '[String]'+-- | a 'Boomerang' library for working with '[String]' {-# LANGUAGE DeriveDataTypeable, FlexibleContexts, FlexibleInstances, TemplateHaskell, TypeFamilies, TypeSynonymInstances, TypeOperators #-} module Text.Boomerang.Strings     (@@ -7,7 +7,7 @@     -- * Combinators     , (</>), alpha, anyChar, anyString, char, digit, eos, int     , integer, lit, readshow, satisfy, satisfyStr, space-    -- * Running the 'PrinterParser'+    -- * Running the 'Boomerang'     , isComplete, parseStrings, unparseStrings      )@@ -24,19 +24,19 @@ import Text.Boomerang.Error       (ParserError(..),ErrorMsg(..), (<?>), condenseErrors, mkParserError) import Text.Boomerang.HStack       ((:-)(..)) import Text.Boomerang.Pos         (InitialPosition(..), MajorMinorPos(..), incMajor, incMinor)-import Text.Boomerang.Prim        (Parser(..), PrinterParser(..), parse1, xmaph, unparse1, val)+import Text.Boomerang.Prim        (Parser(..), Boomerang(..), parse1, xmaph, unparse1, val)  type StringsError = ParserError MajorMinorPos  instance InitialPosition StringsError where     initialPos _ = MajorMinorPos 0 0 -instance a ~ b => IsString (PrinterParser StringsError [String] a b) where+instance a ~ b => IsString (Boomerang StringsError [String] a b) where     fromString = lit  -- | a constant string-lit :: String -> PrinterParser StringsError [String] r r-lit l = PrinterParser pf sf+lit :: String -> Boomerang StringsError [String] r r+lit l = Boomerang pf sf     where       pf = Parser $ \tok pos ->            case tok of@@ -52,12 +52,12 @@  infixr 9 </> -- | equivalent to @f . eos . g@-(</>) :: PrinterParser StringsError [String] b c -> PrinterParser StringsError [String] a b -> PrinterParser StringsError [String] a c+(</>) :: Boomerang StringsError [String] b c -> Boomerang StringsError [String] a b -> Boomerang StringsError [String] a c f </> g = f . eos . g  -- | end of string-eos :: PrinterParser StringsError [String] r r-eos = PrinterParser+eos :: Boomerang StringsError [String] r r+eos = Boomerang        (Parser $ \path pos -> case path of                    []      -> [Right ((id, []), incMajor 1 pos)] --                   [] -> mkParserError pos [EOI "input"]@@ -67,7 +67,7 @@        (\a -> [(("" :), a)])  -- | statisfy a 'Char' predicate-satisfy :: (Char -> Bool) -> PrinterParser StringsError [String] r (Char :- r)+satisfy :: (Char -> Bool) -> Boomerang StringsError [String] r (Char :- r) satisfy p = val   (Parser $ \tok pos ->        case tok of@@ -85,7 +85,7 @@ -- | satisfy a 'String' predicate. -- -- Note: must match the entire remainder of the 'String' in this segment-satisfyStr :: (String -> Bool) -> PrinterParser StringsError [String] r (String :- r)+satisfyStr :: (String -> Bool) -> Boomerang StringsError [String] r (String :- r) satisfyStr p = val   (Parser $ \tok pos ->        case tok of@@ -101,27 +101,27 @@   -- | ascii digits @\'0\'..\'9\'@-digit :: PrinterParser StringsError [String] r (Char :- r)+digit :: Boomerang StringsError [String] r (Char :- r) digit = satisfy isDigit <?> "a digit 0-9"  -- | matches alphabetic Unicode characters (lower-case, upper-case and title-case letters, -- plus letters of caseless scripts and modifiers letters).  (Uses 'isAlpha')-alpha :: PrinterParser StringsError [String] r (Char :- r)+alpha :: Boomerang StringsError [String] r (Char :- r) alpha = satisfy isAlpha <?> "an alphabetic Unicode character"  -- | matches white-space characters in the Latin-1 range. (Uses 'isSpace')-space :: PrinterParser StringsError [String] r (Char :- r)+space :: Boomerang StringsError [String] r (Char :- r) space = satisfy isSpace <?> "a white-space character"  -- | any character-anyChar :: PrinterParser StringsError [String] r (Char :- r)+anyChar :: Boomerang StringsError [String] r (Char :- r) anyChar = satisfy (const True)  -- | matches the specified character-char :: Char -> PrinterParser StringsError [String] r (Char :- r)+char :: Char -> Boomerang StringsError [String] r (Char :- r) char c = satisfy (== c) <?> show [c] --- | lift 'Read'/'Show' to a 'PrinterParser'+-- | lift 'Read'/'Show' to a 'Boomerang' -- -- There are a few restrictions here: --@@ -131,7 +131,7 @@ -- --  2. it is (currently) not safe to use 'readshow' on integral values --  because the 'Read' instance for 'Int', 'Integer', etc,-readshow :: (Read a, Show a) => PrinterParser StringsError [String] r (a :- r)+readshow :: (Read a, Show a) => Boomerang StringsError [String] r (a :- r) readshow =     val readParser s     where@@ -159,13 +159,13 @@ -- | matches an 'Int' -- -- Note that the combinator @(rPair . int . int)@ is ill-defined because the parse can not tell where it is supposed to split the sequence of digits to produced two ints.-int :: PrinterParser StringsError [String] r (Int :- r)+int :: Boomerang StringsError [String] r (Int :- r) int = xmaph readIntegral (Just . show) (opt (rCons . char '-') . (rList1 digit))  -- | matches an 'Integer' -- -- Note that the combinator @(rPair . integer . integer)@ is ill-defined because the parse can not tell where it is supposed to split the sequence of digits to produced two ints.-integer :: PrinterParser StringsError [String] r (Integer :- r)+integer :: Boomerang StringsError [String] r (Integer :- r) integer = xmaph readIntegral (Just . show) (opt (rCons . char '-') . (rList1 digit))  -- | matches any 'String'@@ -185,7 +185,7 @@ -- > parseStrings (rPair . anyString . anyString)  ["foobar"] -- -- We will get @Right ("foobar","")@ instead of the original @Right ("foo","bar")@-anyString :: PrinterParser StringsError [String] r (String :- r)+anyString :: Boomerang StringsError [String] r (String :- r) anyString = val ps ss     where       ps = Parser $ \tok pos ->@@ -212,7 +212,7 @@ -- Returns the first complete parse or a parse error. -- -- > parseStrings (rUnit . lit "foo") ["foo"]-parseStrings :: PrinterParser StringsError [String] () (r :- ())+parseStrings :: Boomerang StringsError [String] () (r :- ())              -> [String]              -> Either StringsError r parseStrings pp strs =@@ -221,5 +221,5 @@ -- | run the printer -- -- > unparseStrings (rUnit . lit "foo") ()-unparseStrings :: PrinterParser e [String] () (r :- ()) -> r -> Maybe [String]+unparseStrings :: Boomerang e [String] () (r :- ()) -> r -> Maybe [String] unparseStrings pp r = unparse1 [] pp r

@@ -1,28 +1,40 @@ {-# LANGUAGE TemplateHaskell, TypeOperators #-}-module Text.Boomerang.TH (derivePrinterParsers) where+module Text.Boomerang.TH+    ( makeBoomerangs+    -- * Backwards-compatibility+    , derivePrinterParsers+    ) where  import Control.Monad       (liftM, replicateM) import Language.Haskell.TH import Text.Boomerang.HStack   ((:-)(..), arg)-import Text.Boomerang.Prim    (xpure, PrinterParser)+import Text.Boomerang.Prim    (xpure, Boomerang) --- | Derive routers for all constructors in a datatype. For example:+-- | Make a 'Boomerang' router for each constructor in a datatype. For+-- example: -----   @$(derivePrinterParsers \'\'Sitemap)@-derivePrinterParsers :: Name -> Q [Dec]-derivePrinterParsers name = do+--   @$(makeBoomerangs \'\'Sitemap)@+makeBoomerangs :: Name -> Q [Dec]+makeBoomerangs name = do   info <- reify name   case info of     TyConI (DataD _ tName tBinds cons _)   ->-      concat `liftM` mapM (derivePrinterParser (tName, tBinds)) cons+      concat `liftM` mapM (deriveBoomerang (tName, tBinds)) cons     TyConI (NewtypeD _ tName tBinds con _) ->-      derivePrinterParser (tName, tBinds) con+      deriveBoomerang (tName, tBinds) con     _ ->       fail $ show name ++ " is not a datatype." +-- | Old name for 'makeBoomerangs', since renamed to reflect the fact+-- that it's not actually deriving instances for any type class, but rather+-- generates top-level definitions for routers of type 'Boomerang'.+derivePrinterParsers :: Name -> Q [Dec]+derivePrinterParsers = makeBoomerangs+{-# DEPRECATED derivePrinterParsers "Use makeBoomerangs instead" #-}+ -- Derive a router for a single constructor.-derivePrinterParser :: (Name, [TyVarBndr]) -> Con -> Q [Dec]-derivePrinterParser (tName, tParams) con =+deriveBoomerang :: (Name, [TyVarBndr]) -> Con -> Q [Dec]+deriveBoomerang (tName, tParams) con =   case con of     NormalC name tys -> go name (map snd tys)     RecC name tys -> go name (map (\(_,_,ty) -> ty) tys)@@ -33,10 +45,10 @@     takeName (PlainTV n) = n     takeName (KindedTV n _) = n     go name tys = do-      let name' = mkPrinterParserName name+      let name' = mkBoomerangName name       let tok' = mkName "tok"       let e' = mkName "e"-      let ppType = AppT (AppT (ConT ''PrinterParser) (VarT e')) (VarT tok')+      let ppType = AppT (AppT (ConT ''Boomerang) (VarT e')) (VarT tok')       let r' = mkName "r"       let inT = foldr (\a b -> AppT (AppT (ConT ''(:-)) a) b) (VarT r') tys       let outT = AppT (AppT (ConT ''(:-))@@ -92,8 +104,8 @@   -- Derive the name of a router based on the name of the constructor in question.-mkPrinterParserName :: Name -> Name-mkPrinterParserName name = mkName ('r' : nameBase name)+mkBoomerangName :: Name -> Name+mkBoomerangName name = mkName ('r' : nameBase name)   -- Retrieve the name of a constructor.

@@ -1,4 +1,4 @@--- | a 'PrinterParser' library for working with '[Text]'+-- | a 'Boomerang' library for working with '[Text]' {-# LANGUAGE DeriveDataTypeable, FlexibleContexts, FlexibleInstances, TemplateHaskell, TypeFamilies, TypeSynonymInstances, TypeOperators #-} module Text.Boomerang.Texts     (@@ -8,7 +8,7 @@     , (</>), alpha, anyChar, anyText, char, digit, digits, signed, eos, integral, int     , integer, lit, readshow, satisfy, satisfyStr, space     , rTextCons, rEmpty, rText, rText1-    -- * Running the 'PrinterParser'+    -- * Running the 'Boomerang'     , isComplete, parseTexts, unparseTexts     )     where@@ -24,19 +24,19 @@ import Text.Boomerang.Error       (ParserError(..),ErrorMsg(..), (<?>), condenseErrors, mkParserError) import Text.Boomerang.HStack      ((:-)(..), arg) import Text.Boomerang.Pos         (InitialPosition(..), MajorMinorPos(..), incMajor, incMinor)-import Text.Boomerang.Prim        (Parser(..), PrinterParser(..), parse1, xmaph, xpure, unparse1, val)+import Text.Boomerang.Prim        (Parser(..), Boomerang(..), parse1, xmaph, xpure, unparse1, val)  type TextsError = ParserError MajorMinorPos  instance InitialPosition TextsError where     initialPos _ = MajorMinorPos 0 0 -instance a ~ b => IsString (PrinterParser TextsError [Text] a b) where+instance a ~ b => IsString (Boomerang TextsError [Text] a b) where     fromString = lit . Text.pack  -- | a constant string-lit :: Text -> PrinterParser TextsError [Text] r r-lit l = PrinterParser pf sf+lit :: Text -> Boomerang TextsError [Text] r r+lit l = Boomerang pf sf     where       pf = Parser $ \tok pos ->            case tok of@@ -53,12 +53,12 @@  infixr 9 </> -- | equivalent to @f . eos . g@-(</>) :: PrinterParser TextsError [Text] b c -> PrinterParser TextsError [Text] a b -> PrinterParser TextsError [Text] a c+(</>) :: Boomerang TextsError [Text] b c -> Boomerang TextsError [Text] a b -> Boomerang TextsError [Text] a c f </> g = f . eos . g  -- | end of string-eos :: PrinterParser TextsError [Text] r r-eos = PrinterParser+eos :: Boomerang TextsError [Text] r r+eos = Boomerang        (Parser $ \path pos -> case path of                    []      -> [Right ((id, []), incMajor 1 pos)] --                   [] -> mkParserError pos [EOI "input"]@@ -69,7 +69,7 @@        (\a -> [((Text.empty :), a)])  -- | statisfy a 'Char' predicate-satisfy :: (Char -> Bool) -> PrinterParser TextsError [Text] r (Char :- r)+satisfy :: (Char -> Bool) -> Boomerang TextsError [Text] r (Char :- r) satisfy p = val   (Parser $ \tok pos ->        case tok of@@ -89,7 +89,7 @@ -- | satisfy a 'Text' predicate. -- -- Note: must match the entire remainder of the 'Text' in this segment-satisfyStr :: (Text -> Bool) -> PrinterParser TextsError [Text] r (Text :- r)+satisfyStr :: (Text -> Bool) -> Boomerang TextsError [Text] r (Text :- r) satisfyStr p = val   (Parser $ \tok pos ->        case tok of@@ -104,27 +104,27 @@   (\str -> [ \strings -> case strings of [] -> [str] ; (s:ss) -> ((str `Text.append` s):ss) | p str ])  -- | ascii digits @\'0\'..\'9\'@-digit :: PrinterParser TextsError [Text] r (Char :- r)+digit :: Boomerang TextsError [Text] r (Char :- r) digit = satisfy isDigit <?> "a digit 0-9"  -- | matches alphabetic Unicode characters (lower-case, upper-case and title-case letters, -- plus letters of caseless scripts and modifiers letters).  (Uses 'isAlpha')-alpha :: PrinterParser TextsError [Text] r (Char :- r)+alpha :: Boomerang TextsError [Text] r (Char :- r) alpha = satisfy isAlpha <?> "an alphabetic Unicode character"  -- | matches white-space characters in the Latin-1 range. (Uses 'isSpace')-space :: PrinterParser TextsError [Text] r (Char :- r)+space :: Boomerang TextsError [Text] r (Char :- r) space = satisfy isSpace <?> "a white-space character"  -- | any character-anyChar :: PrinterParser TextsError [Text] r (Char :- r)+anyChar :: Boomerang TextsError [Text] r (Char :- r) anyChar = satisfy (const True)  -- | matches the specified character-char :: Char -> PrinterParser TextsError [Text] r (Char :- r)+char :: Char -> Boomerang TextsError [Text] r (Char :- r) char c = satisfy (== c) <?> show [c] --- | lift 'Read'/'Show' to a 'PrinterParser'+-- | lift 'Read'/'Show' to a 'Boomerang' -- -- There are a few restrictions here: --@@ -134,7 +134,7 @@ -- --  2. it is (currently) not safe to use 'readshow' on integral values --  because the 'Read' instance for 'Int', 'Integer', etc,-readshow :: (Read a, Show a) => PrinterParser TextsError [Text] r (a :- r)+readshow :: (Read a, Show a) => Boomerang TextsError [Text] r (a :- r) readshow =     val readParser s     where@@ -162,7 +162,7 @@   -- | the empty string-rEmpty :: PrinterParser e [Text] r (Text :- r)+rEmpty :: Boomerang e [Text] r (Text :- r) rEmpty = xpure (Text.empty :-) $               \(xs :- t) ->                   if Text.null xs@@ -170,7 +170,7 @@                      else Nothing  -- | the first character of a 'Text'-rTextCons :: PrinterParser e tok (Char :- Text :- r) (Text :- r)+rTextCons :: Boomerang e tok (Char :- Text :- r) (Text :- r) rTextCons =     xpure (arg (arg (:-)) (Text.cons)) $           \(xs :- t) ->@@ -178,44 +178,44 @@                  return (a :- as :- t)  -- | construct/parse some 'Text' by repeatedly apply a 'Char' 0 or more times parser-rText :: PrinterParser e [Text] r (Char :- r)-      -> PrinterParser e [Text] r (Text :- r)+rText :: Boomerang e [Text] r (Char :- r)+      -> Boomerang e [Text] r (Text :- r) rText r = manyr (rTextCons . duck1 r) . rEmpty  -- | construct/parse some 'Text' by repeatedly apply a 'Char' 1 or more times parser-rText1 :: PrinterParser e [Text] r (Char :- r)-      -> PrinterParser e [Text] r (Text :- r)+rText1 :: Boomerang e [Text] r (Char :- r)+      -> Boomerang e [Text] r (Text :- r) rText1 r = somer (rTextCons . duck1 r) . rEmpty  --- | a sequence of digits-digits :: PrinterParser TextsError [Text] r (Text :- r)-digits = rText digit+-- | a sequence of one or more digits+digits :: Boomerang TextsError [Text] r (Text :- r)+digits = rText1 digit  -- | an optional - character -- -- Typically used with 'digits' to support signed numbers -- -- > signed digits-signed :: PrinterParser TextsError [Text] a (Text :- r)-       -> PrinterParser TextsError [Text] a (Text :- r)+signed :: Boomerang TextsError [Text] a (Text :- r)+       -> Boomerang TextsError [Text] a (Text :- r) signed r = opt (rTextCons . char '-') . r  -- | matches an 'Integral' value -- -- Note that the combinator @(rPair . integral . integral)@ is ill-defined because the parse canwell. not tell where it is supposed to split the sequence of digits to produced two ints.-integral :: (Integral a, Show a) => PrinterParser TextsError [Text] r (a :- r)+integral :: (Integral a, Show a) => Boomerang TextsError [Text] r (a :- r) integral = xmaph readIntegral (Just . Text.pack . show)  (signed digits)  -- | matches an 'Int' -- Note that the combinator @(rPair . int . int)@ is ill-defined because the parse canwell. not tell where it is supposed to split the sequence of digits to produced two ints.-int :: PrinterParser TextsError [Text] r (Int :- r)+int :: Boomerang TextsError [Text] r (Int :- r) int = integral  -- | matches an 'Integer' -- -- Note that the combinator @(rPair . integer . integer)@ is ill-defined because the parse can not tell where it is supposed to split the sequence of digits to produced two ints.-integer :: PrinterParser TextsError [Text] r (Integer :- r)+integer :: Boomerang TextsError [Text] r (Integer :- r) integer = integral  -- | matches any 'Text'@@ -235,7 +235,7 @@ -- > parseTexts (rPair . anyText . anyText)  ["foobar"] -- -- We will get @Right ("foobar","")@ instead of the original @Right ("foo","bar")@-anyText :: PrinterParser TextsError [Text] r (Text :- r)+anyText :: Boomerang TextsError [Text] r (Text :- r) anyText = val ps ss     where       ps = Parser $ \tok pos ->@@ -262,7 +262,7 @@ -- Returns the first complete parse or a parse error. -- -- > parseTexts (rUnit . lit "foo") ["foo"]-parseTexts :: PrinterParser TextsError [Text] () (r :- ())+parseTexts :: Boomerang TextsError [Text] () (r :- ())              -> [Text]              -> Either TextsError r parseTexts pp strs =@@ -271,5 +271,5 @@ -- | run the printer -- -- > unparseTexts (rUnit . lit "foo") ()-unparseTexts :: PrinterParser e [Text] () (r :- ()) -> r -> Maybe [Text]+unparseTexts :: Boomerang e [Text] () (r :- ()) -> r -> Maybe [Text] unparseTexts pp r = unparse1 [] pp r

@@ -1,5 +1,5 @@ Name:             boomerang-Version:          1.3.3+Version:          1.3.4 License:          BSD3 License-File:     LICENSE Author:           jeremy@seereason.com@@ -41,5 +41,5 @@  source-repository head     type:     darcs-    location: http://patch-tag.com/r/stepcut/boomerang+    location: http://hub.darcs.net/stepcut/boomerang