Use many and some from Control.Alternative

Author: garyb

docs/Module.md

@@ -9,7 +9,7 @@
 
     type Parser s a = ParserT s Identity a
 
-    data ParserT s m a where
+    newtype ParserT s m a where
       ParserT :: s -> m { consumed :: Boolean, result :: Either ParseError a, input :: s } -> ParserT s m a
 
 
@@ -29,6 +29,8 @@
 
     instance functorParserT :: (Functor m) => Functor (ParserT s m)
 
+    instance lazy1ParserT :: Lazy1 (ParserT s m)
+
     instance monadParserT :: (Monad m) => Monad (ParserT s m)
 
     instance monadPlusParserT :: (Monad m) => MonadPlus (ParserT s m)
@@ -42,7 +44,7 @@
 
 ### Values
 
-    consume :: forall s m. (Monad m) => ParserT s m {  }
+    consume :: forall s m. (Monad m) => ParserT s m Unit
 
     fail :: forall m s a. (Monad m) => String -> ParserT s m a
 
@@ -83,10 +85,6 @@
 
     fix2 :: forall m s a b. (Tuple (ParserT m s a) (ParserT m s b) -> Tuple (ParserT m s a) (ParserT m s b)) -> Tuple (ParserT m s a) (ParserT m s b)
 
-    many :: forall m s a. (Monad m) => ParserT s m a -> ParserT s m [a]
-
-    many1 :: forall m s a. (Monad m) => ParserT s m a -> ParserT s m [a]
-
     option :: forall m s a. (Monad m) => a -> ParserT s m a -> ParserT s m a
 
     optionMaybe :: forall m s a. (Functor m, Monad m) => ParserT s m a -> ParserT s m (Maybe a)

examples/Test.purs

@@ -5,6 +5,7 @@ import Data.Either
 import Data.Maybe
 
 import Control.Alt
+import Control.Alternative
 import Control.Monad.Eff
 import Control.Monad.Identity
 
@@ -52,7 +53,7 @@ exprTest = buildExprParser [[Infix (string "/" >>= \_ -> return (/)) AssocRight]
 
 manySatisfyTest :: Parser String [String]
 manySatisfyTest = do
-    r <- many1 $ satisfy (\s -> s /= "?")
+    r <- some $ satisfy (\s -> s /= "?")
     string "?"
     return r
 

src/Text/Parsing/Parser.purs

@@ -7,7 +7,7 @@ import Data.Tuple
 
 import Control.Alt
 import Control.Alternative
-import Control.Plus
+import Control.Lazy
 import Control.Monad
 import Control.Monad.Identity
 import Control.Monad.Trans
@@ -17,6 +17,7 @@ import Control.Monad.Error
 import Control.Monad.Error.Class
 import Control.Monad.Error.Trans
 import Control.MonadPlus
+import Control.Plus
 
 data ParseError = ParseError
   { message :: String
@@ -26,7 +27,7 @@ instance errorParseError :: Error ParseError where
   noMsg = ParseError { message: "" }
   strMsg msg = ParseError { message: msg }
 
-data ParserT s m a = ParserT (s -> m { input :: s, result :: Either ParseError a, consumed :: Boolean })
+newtype ParserT s m a = ParserT (s -> m { input :: s, result :: Either ParseError a, consumed :: Boolean })
 
 unParserT :: forall m s a. ParserT s m a -> s -> m { input :: s, result :: Either ParseError a, consumed :: Boolean }
 unParserT (ParserT p) = p
@@ -83,8 +84,11 @@ instance monadStateParserT :: (Monad m) => MonadState s (ParserT s m) where
     return $ case f s of
       Tuple a s' -> { input: s', consumed: false, result: Right a }
 
-consume :: forall s m. (Monad m) => ParserT s m {}
-consume = ParserT $ \s -> return { consumed: true, input: s, result: Right {} }
+instance lazy1ParserT :: Lazy1 (ParserT s m) where
+  defer1 f = ParserT $ \s -> unParserT (f unit) s
+
+consume :: forall s m. (Monad m) => ParserT s m Unit
+consume = ParserT $ \s -> return { consumed: true, input: s, result: Right unit }
 
 fail :: forall m s a. (Monad m) => String -> ParserT s m a
 fail message = ParserT $ \s -> return { input: s, consumed: false, result: Left (ParseError { message: message }) }

src/Text/Parsing/Parser/Combinators.purs

@@ -6,6 +6,7 @@ import Data.Tuple
 import Data.Either
 
 import Control.Alt
+import Control.Alternative
 import Control.Monad
 import Control.Monad.Error.Trans
 import Control.Monad.Error.Class
@@ -22,14 +23,6 @@ fix2 f = Tuple
            (ParserT $ \s -> unParserT (fst (f (fix2 f))) s)
            (ParserT $ \s -> unParserT (snd (f (fix2 f))) s)
 
-many :: forall m s a. (Monad m) => ParserT s m a -> ParserT s m [a]
-many p = many1 p <|> return []
-
-many1 :: forall m s a. (Monad m) => ParserT s m a -> ParserT s m [a]
-many1 p = do a <- p
-             as <- many p
-             return (a : as)
-
 (<?>) :: forall m s a. (Monad m) => ParserT s m a -> String -> ParserT s m a
 (<?>) p msg = p <|> fail ("Expected " ++ msg)
 
@@ -78,7 +71,7 @@ sepEndBy1 p sep = do
       return (a : as)) <|> return [a]
 
 endBy1 :: forall m s a sep. (Monad m) => ParserT s m a -> ParserT s m sep -> ParserT s m [a]
-endBy1 p sep = many1 $ do
+endBy1 p sep = some $ do
   a <- p
   sep
   return a

src/Text/Parsing/Parser/String.purs

@@ -6,6 +6,7 @@ import Data.Foldable
 import Data.Monoid
 
 import Control.Alt
+import Control.Alternative
 import Control.Monad.Error
 import Control.Monad.Error.Class
 import Control.Monad.State.Class