Merge pull request #11 from Thimoteus/master

added satisfy, char, whiteSpace, skipSpaces, oneOf, noneOf, and Eq instance

Author: paf31

bower.json

@@ -17,14 +17,14 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-control": "^0.3.0",
-    "purescript-arrays": "^0.4.0",
-    "purescript-maybe": "^0.3.0",
+    "purescript-control": "~0.3.1",
+    "purescript-arrays": "~0.4.2",
+    "purescript-maybe": "~0.3.4",
     "purescript-strings": "~0.7.0",
-    "purescript-foldable-traversable": "^0.4.0"
+    "purescript-foldable-traversable": "~0.4.0"
   },
   "devDependencies": {
-    "purescript-math": "^0.2.0",
-    "purescript-quickcheck": "^0.12.0"
+    "purescript-math": "~0.2.0",
+    "purescript-quickcheck": "~0.12.0"
   }
 }

docs/Text/Parsing/StringParser.md

@@ -37,6 +37,7 @@ The type of parsing errors.
 ##### Instances
 ``` purescript
 instance showParseError :: Show ParseError
+instance eqParseError :: Eq ParseError
 ```
 
 #### `Parser`

docs/Text/Parsing/StringParser/String.md

@@ -34,4 +34,52 @@ string :: String -> Parser String
 
 Match the specified string.
 
+#### `satisfy`
+
+``` purescript
+satisfy :: (Char -> Boolean) -> Parser Char
+```
+
+Match a character satisfying the given predicate.
+
+#### `char`
+
+``` purescript
+char :: Char -> Parser Char
+```
+
+Match the specified character.
+
+#### `whiteSpace`
+
+``` purescript
+whiteSpace :: Parser String
+```
+
+Match many whitespace characters.
+
+#### `skipSpaces`
+
+``` purescript
+skipSpaces :: Parser Unit
+```
+
+Skip many whitespace characters.
+
+#### `oneOf`
+
+``` purescript
+oneOf :: forall f. (Foldable f) => f Char -> Parser Char
+```
+
+Match one of the characters in the foldable structure.
+
+#### `noneOf`
+
+``` purescript
+noneOf :: forall f. (Foldable f) => f Char -> Parser Char
+```
+
+Match any character not in the foldable structure.
+
 

src/Text/Parsing/StringParser.purs

@@ -30,6 +30,9 @@ data ParseError = ParseError String
 instance showParseError :: Show ParseError where
   show (ParseError msg) = msg
 
+instance eqParseError :: Eq ParseError where
+  eq (ParseError x) (ParseError y) = x == y
+
 -- | A parser is represented as a function which takes a pair of
 -- | continuations for failure and success.
 data Parser a = Parser (forall r. PosString -> (Pos -> ParseError -> r) -> (a -> PosString -> r) -> r)

src/Text/Parsing/StringParser/String.purs

@@ -5,12 +5,22 @@ module Text.Parsing.StringParser.String
   , anyChar
   , anyDigit
   , string
+  , satisfy
+  , char
+  , whiteSpace
+  , skipSpaces
+  , oneOf
+  , noneOf
   ) where
 
 import Prelude
 
 import Data.Maybe (Maybe(..))
-import Data.String (charAt, fromChar, length, indexOf')
+import Data.String (charAt, fromChar, length, indexOf', fromCharArray)
+import Data.Char (toString)
+import Data.Foldable (Foldable, foldMap, elem, notElem)
+
+import Text.Parsing.StringParser.Combinators (many, (<?>))
 import Text.Parsing.StringParser
 
 import qualified Data.String.Regex as Rx
@@ -46,3 +56,33 @@ string :: String -> Parser String
 string nt = Parser (\s fc sc -> case s of
   { str = str, pos = i } | indexOf' nt i str == Just i -> sc nt { str: str, pos: i + length nt }
   { pos = i } -> fc i (ParseError $ "Expected '" ++ nt ++ "'."))
+
+-- | Match a character satisfying the given predicate.
+satisfy :: (Char -> Boolean) -> Parser Char
+satisfy f = try do
+  c <- anyChar
+  if f c
+     then return c
+     else fail $ "Character " <> toString c <> " did not satisfy predicate"
+
+-- | Match the specified character.
+char :: Char -> Parser Char
+char c = satisfy (== c) <?> "Could not match character " <> toString c
+
+-- | Match many whitespace characters.
+whiteSpace :: Parser String
+whiteSpace = do
+  cs <- many (satisfy \ c -> c == 'n' || c == 'r' || c == ' ' || c == '\t')
+  return (foldMap toString cs)
+
+-- | Skip many whitespace characters.
+skipSpaces :: Parser Unit
+skipSpaces = void whiteSpace
+
+-- | Match one of the characters in the foldable structure.
+oneOf :: forall f. (Foldable f) => f Char -> Parser Char
+oneOf = satisfy <<< flip elem
+
+-- | Match any character not in the foldable structure.
+noneOf :: forall f. (Foldable f) => f Char -> Parser Char
+noneOf = satisfy <<< flip notElem