Add many1

Author: markfarrell

bower.json

@@ -1,6 +1,6 @@
 {
   "name": "purescript-parsing-repetition",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "license": "MIT",
   "repository": {                                                           
     "type": "git",                                                          

src/Text/Parsing/Applicative/Repetition.purs

@@ -4,6 +4,7 @@ module Text.Parsing.Applicative.Repetition
   , least
   , greedy
   , many
+  , many1
   , most
   , range
   ) where
@@ -43,8 +44,13 @@ greedy p = R.greedy (pure <$> p)
 many :: forall m a f b. Monad m => Applicative f => Monoid (f b) => ParserT a m b -> ParserT a m (f b)
 many p = R.many (pure <$> p)
 
+-- | Consumes the current input with a parser `p` as many times as successful, with at least one occurrence of `p`.
+-- | Produces the accumulated result, without the guarantee of being stack-safe for large input.
+many1 :: forall m a f b. Monad m => Applicative f => Monoid (f b) => ParserT a m b -> ParserT a m (f b)
+many1 p = R.many1 (pure <$> p)
+
 -- | Consumes the current parse input with a parser `p`, with `m` greedy repetitions of `p`.
--- | Fails if `m` is greater than the constraint `n` passed to the function. 
+-- | Fails if `m` is greater than the constraint `n` passed to the function.
 most :: forall m a f b. Monad m => Applicative f => Monoid (f b) => Int -> ParserT a m b -> ParserT a m (f b)
 most n p = case n > 0 of
  false -> exact 0 p
@@ -53,7 +59,7 @@ most n p = case n > 0 of
    m <- pure $ T.fst w
    x <- pure $ T.snd w
    case m > n of
-     true  -> fail $ "Number of repetitions must be at most " <> show n <> "." 
+     true  -> fail $ "Number of repetitions must be at most " <> show n <> "."
      false -> pure x
 
 -- | Consumes the current parse input with a parser `p`, with at *least* `min` and at *most* `max >= min` repetitions of `p`.

src/Text/Parsing/Array/Repetition.purs

@@ -4,6 +4,7 @@ module Text.Parsing.Array.Repetition
   , least
   , greedy
   , many
+  , many1
   , most
   , range
   ) where
@@ -47,8 +48,16 @@ greedy p = do
 many :: forall m a b. Monad m => ParserT a m b -> ParserT a m (Array b)
 many p = A.fromFoldable <$> L.many p
 
+-- | Consumes the current input with a parser `p` as many times as successful, with at least one occurrence of `p`.
+-- | Produces the accumulated result, without the guarantee of being stack-safe for large input.
+many1 :: forall m a b. Monad m => ParserT a m b -> ParserT a m (Array b)
+many1 p = do
+  x <- pure <$> p
+  y <- many p
+  pure $ x <> y
+
 -- | Consumes the current parse input with a parser `p`, with `m` greedy repetitions of `p`.
--- | Fails if `m` is greater than the constraint `n` passed to the function. 
+-- | Fails if `m` is greater than the constraint `n` passed to the function.
 most :: forall a m b. Monad m => Int -> ParserT a m b -> ParserT a m (Array b)
 most = R.most
 

src/Text/Parsing/Monoid/Repetition.purs

@@ -4,6 +4,7 @@ module Text.Parsing.Monoid.Repetition
   , least
   , greedy
   , many
+  , many1
   ) where
 
 import Prelude
@@ -63,10 +64,18 @@ greedy = \p -> many' 0 mempty p
     many' n acc  = \p -> do
       x <- C.optionMaybe p
       case x of
-        (Nothing) -> pure $ Tuple n acc 
+        (Nothing) -> pure $ Tuple n acc
         (Just y)  -> many' (n + 1) (acc <> y) p
 
 -- | Consumes the current input with a parser `p` as many times as successful.
 -- | Produces the accumulated result, without the guarantee of being stack-safe for large input.
 many :: forall a m b. Monad m => Monoid b => ParserT a m b -> ParserT a m b
 many p = T.snd <$> greedy p
+
+-- | Consumes the current input with a parser `p` as many times as successful, with at least one occurrence of `p`.
+-- | Produces the accumulated result, without the guarantee of being stack-safe for large input.
+many1 :: forall a m b. Monad m => Monoid b => ParserT a m b -> ParserT a m b
+many1 p = do
+  x <- p
+  y <- many p
+  pure $ x <> y

src/Text/Parsing/String/Repetition.purs

@@ -4,6 +4,7 @@ module Text.Parsing.String.Repetition
   , exact
   , greedy
   , many
+  , many1
   , most
   , range
   ) where
@@ -33,7 +34,7 @@ until p q = fromArray <$> R.until p q
 -- | Consumes the current parse input with a parser `p`, with `n` repetitions of `p`.
 -- | Does not check if the remaining parse input can be moreover parsed with `p`.
 least :: forall a m. Monad m => Int -> ParserT a m Char -> ParserT a m String
-least n p = fromArray <$> R.least n p 
+least n p = fromArray <$> R.least n p
 
 -- | Consumes the current parse input with a parser `p`, with `n` repetitions of `p`.
 -- | Fails if the remaining parse input can be moreover be parsed with `p`.
@@ -55,8 +56,13 @@ greedy p = do
 many :: forall a m. Monad m => ParserT a m Char -> ParserT a m String
 many p = fromArray <$> R.many p
 
+-- | Consumes the current input with a parser `p` as many times as successful, with at least once occurrence of `p`.
+-- | Produces the accumulated result, without the guarantee of being stack-safe for large input.
+many1 :: forall a m. Monad m => ParserT a m Char -> ParserT a m String
+many1 p = fromArray <$> R.many1 p
+
 -- | Consumes the current parse input with a parser `p`, with `m` greedy repetitions of `p`.
--- | Fails if `m` is greater than the constraint `n` passed to the function. 
+-- | Fails if `m` is greater than the constraint `n` passed to the function.
 most :: forall a m. Monad m => Int -> ParserT a m Char -> ParserT a m String
 most n p = fromArray <$> R.most n p