Remove all *Rec combinators.

We don't need these anymore because the CPS ParserT is always
stack-safe.

Author: jamesdbrock

src/Parsing/Combinators.purs

@@ -14,8 +14,6 @@
 -- | ### Data.List
 -- | * [Data.List.many](https://pursuit.purescript.org/packages/purescript-lists/docs/Data.List#v:many)
 -- | * [Data.List.some](https://pursuit.purescript.org/packages/purescript-lists/docs/Data.List#v:some)
--- | * [Data.List.someRec](https://pursuit.purescript.org/packages/purescript-lists/docs/Data.List#v:someRec)
--- | * [Data.List.manyRec](https://pursuit.purescript.org/packages/purescript-lists/docs/Data.List#v:manyRec)
 -- |
 -- | ### Data.List.NonEmpty
 -- | * See the __many1__ combinator below.
@@ -40,6 +38,11 @@
 -- | return a parser `replicateA n p :: Parser s (Array a)` which will
 -- | repeat parser `p` exactly `n` times. `replicateA n p` will only succeed
 -- | if it can match parser `p` exactly `n` consecutive times.
+-- |
+-- | ## Stack-safety
+-- |
+-- | The `ParserT` monad is always stack-safe, so `MonadRec` combinators are
+-- | not necessary.
 module Parsing.Combinators
   ( (<?>)
   , (<??>)
@@ -48,27 +51,16 @@ module Parsing.Combinators
   , between
   , chainl
   , chainl1
-  , chainl1Rec
-  , chainlRec
   , chainr
   , chainr1
-  , chainr1Rec
-  , chainrRec
   , choice
   , endBy
   , endBy1
-  , endBy1Rec
-  , endByRec
   , lookAhead
   , many1
-  , many1Rec
   , many1Till
-  , many1TillRec
-  , many1TillRec_
   , many1Till_
   , manyTill
-  , manyTillRec
-  , manyTillRec_
   , manyTill_
   , module Control.Plus
   , module Data.Unfoldable
@@ -79,16 +71,10 @@ module Parsing.Combinators
   , optional
   , sepBy
   , sepBy1
-  , sepBy1Rec
-  , sepByRec
   , sepEndBy
   , sepEndBy1
-  , sepEndBy1Rec
-  , sepEndByRec
   , skipMany
   , skipMany1
-  , skipMany1Rec
-  , skipManyRec
   , try
   , tryRethrow
   , withErrorMessage
@@ -98,16 +84,14 @@ module Parsing.Combinators
 import Prelude
 
 import Control.Lazy (defer)
-import Control.Monad.Rec.Class (Step(..), tailRecM)
 import Control.Plus (empty, (<|>), alt)
-import Data.Foldable (class Foldable, foldl, foldr)
+import Data.Foldable (class Foldable, foldr)
 import Data.Function.Uncurried (mkFn2, mkFn5, runFn2, runFn5)
-import Data.List (List(..), many, manyRec, reverse, (:))
+import Data.List (List(..), many, (:))
 import Data.List.NonEmpty (NonEmptyList, cons')
 import Data.List.NonEmpty as NEL
 import Data.Maybe (Maybe(..), fromMaybe)
 import Data.Tuple (Tuple(..))
-import Data.Tuple.Nested (type (/\), (/\))
 import Data.Unfoldable (replicateA)
 import Data.Unfoldable1 (replicate1A)
 import Parsing (ParseError(..), ParseState(..), ParserT(..), fail)
@@ -223,12 +207,6 @@ lookAhead (ParserT k1) = ParserT
 many1 :: forall m s a. ParserT s m a -> ParserT s m (NonEmptyList a)
 many1 p = NEL.cons' <$> p <*> many p
 
--- | Match one or more times.
--- |
--- | Stack-safe version of `many1` at the expense of a `MonadRec` constraint.
-many1Rec :: forall m s a. ParserT s m a -> ParserT s m (NonEmptyList a)
-many1Rec p = NEL.cons' <$> p <*> manyRec p
-
 -- | Parse phrases delimited by a separator.
 -- |
 -- | For example:
@@ -239,38 +217,17 @@ many1Rec p = NEL.cons' <$> p <*> manyRec p
 sepBy :: forall m s a sep. ParserT s m a -> ParserT s m sep -> ParserT s m (List a)
 sepBy p sep = map NEL.toList (sepBy1 p sep) <|> pure Nil
 
--- | Parse phrases delimited by a separator.
--- |
--- | Stack-safe version of `sepBy` at the expense of a `MonadRec` constraint.
-sepByRec :: forall m s a sep. ParserT s m a -> ParserT s m sep -> ParserT s m (List a)
-sepByRec p sep = map NEL.toList (sepBy1Rec p sep) <|> pure Nil
-
 -- | Parse phrases delimited by a separator, requiring at least one match.
 sepBy1 :: forall m s a sep. ParserT s m a -> ParserT s m sep -> ParserT s m (NonEmptyList a)
 sepBy1 p sep = do
   a <- p
   as <- many $ sep *> p
   pure (NEL.cons' a as)
 
--- | Parse phrases delimited by a separator, requiring at least one match.
--- |
--- | Stack-safe version of `sepBy1` at the expense of a `MonadRec` constraint.
-sepBy1Rec :: forall m s a sep. ParserT s m a -> ParserT s m sep -> ParserT s m (NonEmptyList a)
-sepBy1Rec p sep = do
-  a <- p
-  as <- manyRec $ sep *> p
-  pure (NEL.cons' a as)
-
 -- | Parse phrases delimited and optionally terminated by a separator.
 sepEndBy :: forall m s a sep. ParserT s m a -> ParserT s m sep -> ParserT s m (List a)
 sepEndBy p sep = map NEL.toList (sepEndBy1 p sep) <|> pure Nil
 
--- | Parse phrases delimited and optionally terminated by a separator.
--- |
--- | Stack-safe version of `sepEndBy` at the expense of a `MonadRec` constraint.
-sepEndByRec :: forall m s a sep. ParserT s m a -> ParserT s m sep -> ParserT s m (List a)
-sepEndByRec p sep = map NEL.toList (sepEndBy1Rec p sep) <|> pure Nil
-
 -- | Parse phrases delimited and optionally terminated by a separator, requiring at least one match.
 sepEndBy1 :: forall m s a sep. ParserT s m a -> ParserT s m sep -> ParserT s m (NonEmptyList a)
 sepEndBy1 p sep = do
@@ -281,45 +238,14 @@ sepEndBy1 p sep = do
       pure (NEL.cons' a as)
   ) <|> pure (NEL.singleton a)
 
--- | Parse phrases delimited and optionally terminated by a separator, requiring at least one match.
--- |
--- | Stack-safe version of `sepEndBy1` at the expense of a `MonadRec` constraint.
-sepEndBy1Rec :: forall m s a sep. ParserT s m a -> ParserT s m sep -> ParserT s m (NonEmptyList a)
-sepEndBy1Rec p sep = do
-  a <- p
-  (NEL.cons' a <$> tailRecM go Nil) <|> pure (NEL.singleton a)
-  where
-  go :: List a -> ParserT s m (Step (List a) (List a))
-  go acc = nextOne <|> done
-    where
-    nextOne = do
-      -- First make sure there's a separator.
-      _ <- sep
-      -- Then try the phrase and loop if it's there, or bail if it's not there.
-      (p <#> \a -> Loop $ a : acc) <|> done
-
-    done = defer \_ -> pure $ Done $ reverse acc
-
 -- | Parse phrases delimited and terminated by a separator, requiring at least one match.
 endBy1 :: forall m s a sep. ParserT s m a -> ParserT s m sep -> ParserT s m (NonEmptyList a)
 endBy1 p sep = many1 $ p <* sep
 
--- | Parse phrases delimited and terminated by a separator, requiring at least one match.
--- |
--- | Stack-safe version of `endBy1` at the expense of a `MonadRec` constraint.
-endBy1Rec :: forall m s a sep. ParserT s m a -> ParserT s m sep -> ParserT s m (NonEmptyList a)
-endBy1Rec p sep = many1Rec $ p <* sep
-
 -- | Parse phrases delimited and terminated by a separator.
 endBy :: forall m s a sep. ParserT s m a -> ParserT s m sep -> ParserT s m (List a)
 endBy p sep = many $ p <* sep
 
--- | Parse phrases delimited and terminated by a separator.
--- |
--- | Stack-safe version of `endBy` at the expense of a `MonadRec` constraint.
-endByRec :: forall m s a sep. ParserT s m a -> ParserT s m sep -> ParserT s m (List a)
-endByRec p sep = manyRec $ p <* sep
-
 -- | Parse phrases delimited by a right-associative operator.
 -- |
 -- | For example:
@@ -330,12 +256,6 @@ endByRec p sep = manyRec $ p <* sep
 chainr :: forall m s a. ParserT s m a -> ParserT s m (a -> a -> a) -> a -> ParserT s m a
 chainr p f a = chainr1 p f <|> pure a
 
--- | Parse phrases delimited by a right-associative operator.
--- |
--- | Stack-safe version of `chainr` at the expense of a `MonadRec` constraint.
-chainrRec :: forall m s a. ParserT s m a -> ParserT s m (a -> a -> a) -> a -> ParserT s m a
-chainrRec p f a = chainr1Rec p f <|> pure a
-
 -- | Parse phrases delimited by a left-associative operator.
 -- |
 -- | For example:
@@ -346,12 +266,6 @@ chainrRec p f a = chainr1Rec p f <|> pure a
 chainl :: forall m s a. ParserT s m a -> ParserT s m (a -> a -> a) -> a -> ParserT s m a
 chainl p f a = chainl1 p f <|> pure a
 
--- | Parse phrases delimited by a left-associative operator.
--- |
--- | Stack-safe version of `chainl` at the expense of a `MonadRec` constraint.
-chainlRec :: forall m s a. ParserT s m a -> ParserT s m (a -> a -> a) -> a -> ParserT s m a
-chainlRec p f a = chainl1Rec p f <|> pure a
-
 -- | Parse phrases delimited by a left-associative operator, requiring at least one match.
 chainl1 :: forall m s a. ParserT s m a -> ParserT s m (a -> a -> a) -> ParserT s m a
 chainl1 p f = do
@@ -365,23 +279,6 @@ chainl1 p f = do
         chainl1' (f' a a')
     ) <|> pure a
 
--- | Parse phrases delimited by a left-associative operator, requiring at least one match.
--- |
--- | Stack-safe version of `chainl1` at the expense of a `MonadRec` constraint.
-chainl1Rec :: forall m s a. ParserT s m a -> ParserT s m (a -> a -> a) -> ParserT s m a
-chainl1Rec p f = do
-  a <- p
-  tailRecM go a
-  where
-  go :: a -> ParserT s m (Step a a)
-  go a =
-    ( do
-        op <- f
-        a' <- p
-        pure $ Loop $ op a a'
-    )
-      <|> pure (Done a)
-
 -- | Parse phrases delimited by a right-associative operator, requiring at least one match.
 chainr1 :: forall m s a. ParserT s m a -> ParserT s m (a -> a -> a) -> ParserT s m a
 chainr1 p f = do
@@ -395,51 +292,6 @@ chainr1 p f = do
         pure $ f' a a'
     ) <|> pure a
 
--- | Parse phrases delimited by a right-associative operator, requiring at least one match.
--- |
--- | Stack-safe version of `chainr1` at the expense of a `MonadRec` constraint.
-chainr1Rec :: forall m s a. ParserT s m a -> ParserT s m (a -> a -> a) -> ParserT s m a
-chainr1Rec p f = do
-  a <- p
-  tailRecM go { last: a, init: Nil }
-  where
-  -- This looks scary at first glance, so I'm leaving a comment in a vain
-  -- attempt to explain how it works.
-  --
-  -- The loop state is a record {init, last}, where `last` is the last (i.e.
-  -- rightmost) `a` value that has been parsed so far, and `init` is a list of
-  -- (value + operator) pairs that have been parsed before that.
-  --
-  -- The very first value is parsed at top level, and it becomes the initial
-  -- value of `last`, while the initial value of `init` is just `Nil`,
-  -- indicating that no pairs of (value + operator) have been parsed yet.
-  --
-  -- At every step, we parse an operator and a value, and then the newly parsed
-  -- value becomes `last` (because, well, it's been parsed last), and the pair
-  -- of (previous last + operator) is prepended to `init`.
-  --
-  -- After we can no longer parse a pair of (value + operation), we're done. At
-  -- that point, we have a list of (value + operation) pairs in reverse order
-  -- (since we prepend each pair as we go) and the very last value. All that's
-  -- left is combine them all via `foldl`.
-  go
-    :: { init :: List (a /\ (a -> a -> a)), last :: a }
-    -> ParserT s m
-         ( Step
-             { init :: List (a /\ (a -> a -> a)), last :: a }
-             a
-         )
-  go { last, init } =
-    ( do
-        op <- f
-        a <- p
-        pure $ Loop { last: a, init: (last /\ op) : init }
-    )
-      <|> pure (Done $ foldl apply last init)
-
-  apply :: a -> (a /\ (a -> a -> a)) -> a
-  apply y (x /\ op) = x `op` y
-
 -- | Parse one of a set of alternatives.
 choice :: forall f m s a. Foldable f => f (ParserT s m a) -> ParserT s m a
 choice = fromMaybe empty <<< foldr go Nothing
@@ -452,27 +304,13 @@ choice = fromMaybe empty <<< foldr go Nothing
 skipMany :: forall s a m. ParserT s m a -> ParserT s m Unit
 skipMany p = skipMany1 p <|> pure unit
 
--- | Skip many instances of a phrase.
--- |
--- | Stack-safe version of `skipMany` at the expense of a `MonadRec` constraint.
-skipManyRec :: forall s a m. ParserT s m a -> ParserT s m Unit
-skipManyRec p = skipMany1Rec p <|> pure unit
-
 -- | Skip at least one instance of a phrase.
 skipMany1 :: forall s a m. ParserT s m a -> ParserT s m Unit
 skipMany1 p = do
   _ <- p
   _ <- skipMany p
   pure unit
 
--- | Skip at least one instance of a phrase.
--- |
--- | Stack-safe version of `skipMany1` at the expense of a `MonadRec` constraint.
-skipMany1Rec :: forall s a m. ParserT s m a -> ParserT s m Unit
-skipMany1Rec p = p *> tailRecM go unit
-  where
-  go _ = (p $> Loop unit) <|> pure (Done unit)
-
 -- | Fail if the parser succeeds.
 -- |
 -- | Will never consume input.
@@ -488,30 +326,13 @@ manyTill p end = scan
     xs <- scan
     pure (x : xs)
 
--- | Parse many phrases until the terminator phrase matches.
--- |
--- | Stack-safe version of `manyTill` at the expense of a `MonadRec` constraint.
-manyTillRec :: forall s a m e. ParserT s m a -> ParserT s m e -> ParserT s m (List a)
-manyTillRec p end = tailRecM go Nil
-  where
-  go :: List a -> ParserT s m (Step (List a) (List a))
-  go acc =
-    (end <#> \_ -> Done $ reverse acc)
-      <|> (p <#> \x -> Loop $ x : acc)
-
 -- | Parse at least one phrase until the terminator phrase matches.
 many1Till :: forall s a m e. ParserT s m a -> ParserT s m e -> ParserT s m (NonEmptyList a)
 many1Till p end = do
   x <- p
   xs <- manyTill p end
   pure (NEL.cons' x xs)
 
--- | Parse at least one phrase until the terminator phrase matches.
--- |
--- | Stack-safe version of `many1Till` at the expense of a `MonadRec` constraint.
-many1TillRec :: forall s a m e. ParserT s m a -> ParserT s m e -> ParserT s m (NonEmptyList a)
-many1TillRec p end = NEL.cons' <$> p <*> manyTillRec p end
-
 -- | Parse many phrases until the terminator phrase matches.
 -- | Returns the list of phrases and the terminator phrase.
 -- |
@@ -567,30 +388,3 @@ many1Till_ p end = do
   x <- p
   Tuple xs t <- manyTill_ p end
   pure $ Tuple (cons' x xs) t
-
--- | Parse many phrases until the terminator phrase matches.
--- | Returns the list of phrases and the terminator phrase.
--- |
--- | Stack-safe version of `manyTill_` at the expense of a `MonadRec` constraint.
-manyTillRec_ :: forall s a m e. ParserT s m a -> ParserT s m e -> ParserT s m (Tuple (List a) e)
-manyTillRec_ p end = tailRecM go Nil
-  where
-  go :: List a -> ParserT s m (Step (List a) (Tuple (List a) e))
-  go xs =
-    do
-      t <- end
-      pure (Done (Tuple (reverse xs) t))
-      <|>
-        do
-          x <- p
-          pure (Loop (x : xs))
-
--- | Parse many phrases until the terminator phrase matches, requiring at least one match.
--- | Returns the list of phrases and the terminator phrase.
--- |
--- | Stack-safe version of `many1Till_` at the expense of a `MonadRec` constraint.
-many1TillRec_ :: forall s a m e. ParserT s m a -> ParserT s m e -> ParserT s m (Tuple (NonEmptyList a) e)
-many1TillRec_ p end = do
-  x <- p
-  Tuple xs t <- manyTillRec_ p end
-  pure $ Tuple (cons' x xs) t