renaming, examples added

Author: cryogenian

examples/Test.purs

@@ -16,6 +16,7 @@ import Text.Parsing.Parser
 import Text.Parsing.Parser.Combinators
 import Text.Parsing.Parser.Expr
 import Text.Parsing.Parser.String
+import Text.Parsing.Parser.Token
 
 parens :: forall m a. (Monad m) => ParserT String m a -> ParserT String m a
 parens = between (string "(") (string ")")
@@ -58,6 +59,23 @@ manySatisfyTest = do
     string "?"
     return r
 
+data TestToken = A | B
+
+instance showTestTokens :: Show TestToken where
+  show A = "A"
+  show B = "B"
+
+instance testTokensEq :: Eq TestToken where
+  (==) A A = true
+  (==) B B = true
+  (==) _ _ = false
+  (/=) a b = not $ a == b
+
+isA :: TestToken -> Boolean
+isA A = true
+isA _ = false
+
+
 main = do
   parseTest nested "(((a)))"
   parseTest (many (string "a")) "aaa"
@@ -72,3 +90,22 @@ main = do
   parseTest opTest "a+b+c"
   parseTest exprTest "1*2+3/4-5"
   parseTest manySatisfyTest "ab?"
+
+  print "should be A"
+  parseTest token [A, B]
+  print "should be B"
+  parseTest token [B, A]
+
+  print "should be A"
+  parseTest (when isA) [A, B]
+  print "should fail"
+  parseTest (when isA) [B, B]
+
+  print "should be A"
+  parseTest (match A) [A]
+  print "should be B"
+  parseTest (match B) [B]
+  print "should be A"
+  parseTest (match A) [A, B]
+  print "should fail"
+  parseTest (match B) [A, B]

src/Text/Parsing/Parser/Token.purs

@@ -4,30 +4,28 @@ import Data.String
 import Data.Either
 
 import Control.Monad.State.Class hiding (get)
+import Control.Monad.Error
 import Control.Monad.Error.Class
+import Control.MonadPlus
 
 import Text.Parsing.Parser
 import Text.Parsing.Parser.String
 import Text.Parsing.Parser.Combinators
 
-takeTok :: forall m a. (Monad m) => ParserT [a] m a
-takeTok = ParserT $ \s ->
+token :: forall m a. (Monad m) => ParserT [a] m a
+token = ParserT $ \s ->
   return $ case s of
-    x:xs -> {consumed: true,
-             input: xs,
-             result: Right x}
-    _ -> {consumed: false,
-          input: s,
-          result: Left (ParseError {message: "there is nothing in 'takeTok'"})}
+    x:xs -> { consumed: true, input: xs, result: Right x }
+    _ -> { consumed: false, input: s, result: Left (strMsg "expected token, met EOF") }
 
 when :: forall m a. (Monad m) => (a -> Boolean) -> ParserT [a] m a
 when f = try $ do
-  a <- takeTok
-  if f a then return a
-    else fail "token doesn't satisfy when test"
+  a <- token
+  guard $ f a
+  return a
 
-get :: forall a m. (Monad m, Eq a) => a -> ParserT [a] m a
-get token = when ((==) token)
+match :: forall a m. (Monad m, Eq a) => a -> ParserT [a] m a
+match token = when ((==) token)
 
 
 type LanguageDef s m = {