Use BSD3 license, update deps, incorporate #33

Author: paf31

LICENSE

@@ -1,23 +1,24 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 PureScript
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Copyright 2014-2016 PureScript
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+This software is provided by the copyright holders "as is" and any express or
+implied warranties, including, but not limited to, the implied warranties of
+merchantability and fitness for a particular purpose are disclaimed. In no
+event shall the copyright holders be liable for any direct, indirect,
+incidental, special, exemplary, or consequential damages (including, but not
+limited to, procurement of substitute goods or services; loss of use, data,
+or profits; or business interruption) however caused and on any theory of
+liability, whether in contract, strict liability, or tort (including
+negligence or otherwise) arising in any way out of the use of this software,
+even if advised of the possibility of such damage.
 
 -------------------------------------------------------------------------------
 

bower.json

@@ -5,7 +5,7 @@
   "keywords": [
     "purescript"
   ],
-  "license": "MIT",
+  "license": "BSD3",
   "repository": {
     "type": "git",
     "url": "git://github.com/purescript-contrib/purescript-parsing.git"
@@ -29,7 +29,7 @@
     "purescript-maybe": "^2.0.0",
     "purescript-strings": "^2.0.0",
     "purescript-transformers": "^2.0.0",
-    "purescript-unicode": "6d9a4ab9d239da4cecb33283994cce56350bbe87"
+    "purescript-unicode": "^2.0.0"
   },
   "devDependencies": {
     "purescript-assert": "^2.0.0",

src/Text/Parsing/Parser.purs

@@ -1,5 +1,7 @@
 module Text.Parsing.Parser
-  ( ParseError(..)
+  ( ParseError
+  , parseErrorMessage
+  , parseErrorPosition
   , ParseState(..)
   , ParserT(..)
   , Parser
@@ -23,22 +25,23 @@ import Data.Tuple (Tuple(..))
 import Text.Parsing.Parser.Pos (Position, initialPos)
 
 -- | A parsing error, consisting of a message and position information.
-newtype ParseError = ParseError
-  { message :: String
-  , position :: Position
-  }
+data ParseError = ParseError String Position
+
+parseErrorMessage :: ParseError -> String
+parseErrorMessage (ParseError msg _) = msg
+
+parseErrorPosition :: ParseError -> Position
+parseErrorPosition (ParseError _ pos) = pos
 
 instance showParseError :: Show ParseError where
-  show (ParseError msg) = "ParseError { message: " <> msg.message <> ", position: " <> show msg.position <> " }"
+  show (ParseError msg pos) =
+    "(ParseError " <> show msg <> show pos <> ")"
 
 derive instance eqParseError :: Eq ParseError
+derive instance ordParseError :: Ord ParseError
 
--- | `PState` contains the remaining input and current position.
-newtype ParseState s = ParseState
-  { input :: s
-  , position :: Position
-  , consumed :: Boolean
-  }
+-- | Contains the remaining input and current position.
+data ParseState s = ParseState s Position Boolean
 
 -- | The Parser monad transformer.
 -- |
@@ -51,7 +54,7 @@ derive instance newtypeParserT :: Newtype (ParserT s m a) _
 -- | Apply a parser, keeping only the parsed result.
 runParserT :: forall m s a. Monad m => s -> ParserT s m a -> m (Either ParseError a)
 runParserT s p = evalStateT (runExceptT (unwrap p)) initialState where
-  initialState = ParseState { input: s, position: initialPos, consumed: false }
+  initialState = ParseState s initialPos false
 
 -- | The `Parser` monad is a synonym for the parser monad transformer applied to the `Identity` monad.
 type Parser s a = ParserT s Identity a
@@ -73,12 +76,12 @@ derive newtype instance monadStateParserT :: Monad m => MonadState (ParseState s
 derive newtype instance monadErrorParserT :: Monad m => MonadError ParseError (ParserT s m)
 
 instance altParserT :: Monad m => Alt (ParserT s m) where
-  alt p1 p2 = (ParserT <<< ExceptT <<< StateT) \(s@(ParseState { input, position })) -> do
-    Tuple e (ParseState s') <- runStateT (runExceptT (unwrap p1)) (ParseState { input, position, consumed: false })
+  alt p1 p2 = (ParserT <<< ExceptT <<< StateT) \(s@(ParseState i p _)) -> do
+    Tuple e s'@(ParseState i' p' c') <- runStateT (runExceptT (unwrap p1)) (ParseState i p false)
     case e of
       Left err
-        | not s'.consumed -> runStateT (runExceptT (unwrap p2)) s
-      _ -> pure (Tuple e (ParseState s'))
+        | not c' -> runStateT (runExceptT (unwrap p2)) s
+      _ -> pure (Tuple e s')
 
 instance plusParserT :: Monad m => Plus (ParserT s m) where
   empty = fail "No alternative"
@@ -94,11 +97,11 @@ instance monadTransParserT :: MonadTrans (ParserT s) where
 
 -- | Set the consumed flag.
 consume :: forall s m. Monad m => ParserT s m Unit
-consume = modify \(ParseState { input, position }) ->
-  ParseState { input, position, consumed: true }
+consume = modify \(ParseState input position _) ->
+  ParseState input position true
 
 -- | Fail with a message.
 fail :: forall m s a. Monad m => String -> ParserT s m a
 fail message = do
-  position <- gets \(ParseState s) -> s.position
-  throwError (ParseError { message, position })
+  position <- gets \(ParseState _ pos _) -> pos
+  throwError (ParseError message position)

src/Text/Parsing/Parser/Combinators.purs

@@ -73,10 +73,10 @@ optionMaybe p = option Nothing (Just <$> p)
 
 -- | In case of failure, reset the stream to the unconsumed state.
 try :: forall m s a. Monad m => ParserT s m a -> ParserT s m a
-try p = (ParserT <<< ExceptT <<< StateT) \(s@(ParseState { consumed })) -> do
-  Tuple e s'@(ParseState { input, position }) <- runStateT (runExceptT (unwrap p)) s
+try p = (ParserT <<< ExceptT <<< StateT) \(s@(ParseState _ _ consumed)) -> do
+  Tuple e s'@(ParseState input position _) <- runStateT (runExceptT (unwrap p)) s
   case e of
-    Left _ -> pure (Tuple e (ParseState { input, position, consumed }))
+    Left _ -> pure (Tuple e (ParseState input position consumed))
     _ -> pure (Tuple e s')
 
 -- | Parse a phrase, without modifying the consumed state or stream position.

src/Text/Parsing/Parser/String.purs

@@ -31,35 +31,33 @@ instance stringLikeString :: StringLike String where
 -- | Match end-of-file.
 eof :: forall s m. (StringLike s, Monad m) => ParserT s m Unit
 eof = do
-  input <- gets \(ParseState { input }) -> input
+  input <- gets \(ParseState input _ _) -> input
   unless (null input) (fail "Expected EOF")
 
 -- | Match the specified string.
 string :: forall s m. (StringLike s, Monad m) => String -> ParserT s m String
 string str = do
-  input <- gets \(ParseState { input }) -> input
+  input <- gets \(ParseState input _ _) -> input
   case indexOf (wrap str) input of
     Just 0 -> do
-      modify \(ParseState { position }) ->
-        ParseState { position: updatePosString position str
-                   , consumed: true
-                   , input: drop (length str) input
-                   }
+      modify \(ParseState _ position _) ->
+        ParseState (drop (length str) input)
+                   (updatePosString position str)
+                   true
       pure str
     _ -> fail ("Expected " <> show str)
 
 -- | Match any character.
 anyChar :: forall s m. (StringLike s, Monad m) => ParserT s m Char
 anyChar = do
-  input <- gets \(ParseState { input }) -> input
+  input <- gets \(ParseState input _ _) -> input
   case uncons input of
     Nothing -> fail "Unexpected EOF"
     Just { head, tail } -> do
-      modify \(ParseState { position }) ->
-        ParseState { position: updatePosString position (singleton head)
-                   , consumed: true
-                   , input: tail
-                   }
+      modify \(ParseState _ position _) ->
+        ParseState tail
+                   (updatePosString position (singleton head))
+                   true
       pure head
 
 -- | Match a character satisfying the specified predicate.

src/Text/Parsing/Parser/Token.purs

@@ -47,15 +47,12 @@ import Prelude hiding (when,between)
 -- | Create a parser which Returns the first token in the stream.
 token :: forall m a. Monad m => (a -> Position) -> ParserT (List a) m a
 token tokpos = do
-  input <- gets \(ParseState { input }) -> input
+  input <- gets \(ParseState input _ _) -> input
   case List.uncons input of
     Nothing -> fail "Unexpected EOF"
     Just { head, tail } -> do
-      modify \(ParseState { position }) ->
-        ParseState { position: tokpos head
-                   , consumed: true
-                   , input: tail
-                   }
+      modify \(ParseState _ position _) ->
+        ParseState tail (tokpos head) true
       pure head
 
 -- | Create a parser which matches any token satisfying the predicate.

test/Main.purs

@@ -11,7 +11,7 @@ import Data.Maybe (Maybe(..))
 import Data.String (fromCharArray, singleton)
 import Data.Tuple (Tuple(..))
 import Test.Assert (ASSERT, assert')
-import Text.Parsing.Parser (Parser, ParserT, ParseError(..), runParser)
+import Text.Parsing.Parser (Parser, ParserT, runParser, parseErrorPosition)
 import Text.Parsing.Parser.Combinators (endBy1, sepBy1, optionMaybe, try, chainl, between)
 import Text.Parsing.Parser.Expr (Assoc(..), Operator(..), buildExprParser)
 import Text.Parsing.Parser.Language (javaStyle, haskellStyle, haskellDef)
@@ -38,7 +38,8 @@ parseTest input expected p = case runParser input p of
 parseErrorTestPosition :: forall s a eff. (Show a) => Parser s a -> s -> Position -> Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit
 parseErrorTestPosition p input expected = case runParser input p of
   Right _ -> assert' "error: ParseError expected!" false
-  Left (ParseError { position: pos }) -> do
+  Left err -> do
+    let pos = parseErrorPosition err
     assert' ("expected: " <> show expected <> ", pos: " <> show pos) (expected == pos)
     logShow expected