Merge pull request #169 from purescript-contrib/module-rename

Rename Text.Parsing.Parser to Parsing

Author: jamesdbrock

CHANGELOG.md

@@ -25,6 +25,7 @@ Breaking changes:
   `<|>` was made right associative. Decreasing these two operators
   prevents a compiler error (i.e. `MixedAssociativityError`)
   without causing issues with `<$>`.
+- Rename module prefix from `Text.Parsing.Parser` to `Parsing` (#169 by @jamesdbrock)
 
 New features:
 

bench/Json/Parsing.purs

@@ -8,9 +8,9 @@ import Data.List (List)
 import Data.Maybe (Maybe(..))
 import Data.Number as Number
 import Data.Tuple (Tuple(..))
-import Text.Parsing.Parser (ParserT, fail)
-import Text.Parsing.Parser.Combinators (between, choice, sepBy, try)
-import Text.Parsing.Parser.String (regex, skipSpaces, string)
+import Parsing (ParserT, fail)
+import Parsing.Combinators (between, choice, sepBy, try)
+import Parsing.String (regex, skipSpaces, string)
 
 json :: forall m. Monad m => ParserT String m Json
 json = defer \_ ->

bench/Main.purs

@@ -70,9 +70,9 @@ import Effect.Console (log)
 import Effect.Exception (throw)
 import Effect.Unsafe (unsafePerformEffect)
 import Performance.Minibench (benchWith)
-import Text.Parsing.Parser (Parser, runParser, runParserT)
-import Text.Parsing.Parser.String (string)
-import Text.Parsing.Parser.String.Basic (digit)
+import Parsing (Parser, runParser, runParserT)
+import Parsing.String (string)
+import Parsing.String.Basic (digit)
 import StringParser as StringParser
 import StringParser.CodePoints as StringParser.CodePoints
 import StringParser.CodeUnits as StringParser.CodeUnits

src/Text/Parsing/Parser.purs renamed to src/Parsing.purs

@@ -1,4 +1,4 @@
-module Text.Parsing.Parser
+module Parsing
   ( ParseError(..)
   , parseErrorMessage
   , parseErrorPosition
@@ -33,7 +33,7 @@ import Data.Identity (Identity)
 import Data.Lazy as Lazy
 import Data.Newtype (unwrap)
 import Data.Tuple (Tuple(..), fst)
-import Text.Parsing.Parser.Pos (Position, initialPos)
+import Parsing.Pos (Position, initialPos)
 
 -- | A parsing error, consisting of a message and position information.
 data ParseError = ParseError String Position

src/Text/Parsing/Parser/Combinators.purs renamed to src/Parsing/Combinators.purs

@@ -40,7 +40,7 @@
 -- | 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.
-module Text.Parsing.Parser.Combinators
+module Parsing.Combinators
   ( (<?>)
   , (<??>)
   , (<~?>)
@@ -110,7 +110,7 @@ import Data.Tuple (Tuple(..))
 import Data.Tuple.Nested (type (/\), (/\))
 import Data.Unfoldable (replicateA)
 import Data.Unfoldable1 (replicate1A)
-import Text.Parsing.Parser (ParseError(..), ParseState(..), ParserT(..), fail)
+import Parsing (ParseError(..), ParseState(..), ParserT(..), fail)
 
 -- | Provide an error message in the case of failure.
 withErrorMessage :: forall m s a. ParserT s m a -> String -> ParserT s m a

src/Text/Parsing/Parser/Expr.purs renamed to src/Parsing/Expr.purs

@@ -2,7 +2,7 @@
 -- | [__Text.Parsec.Expr__](https://hackage.haskell.org/package/parsec/docs/Text-Parsec-Expr.html)
 -- | module.
 
-module Text.Parsing.Parser.Expr
+module Parsing.Expr
   ( Assoc(..)
   , Operator(..)
   , OperatorTable()
@@ -14,8 +14,8 @@ import Prelude hiding (between)
 import Control.Alt ((<|>))
 import Data.Foldable (foldl, foldr)
 import Data.List (List(..), (:))
-import Text.Parsing.Parser (ParserT)
-import Text.Parsing.Parser.Combinators (choice, (<?>))
+import Parsing (ParserT)
+import Parsing.Combinators (choice, (<?>))
 
 data Assoc = AssocNone | AssocLeft | AssocRight
 

src/Text/Parsing/Parser/Indent.purs renamed to src/Parsing/Indent.purs

@@ -29,7 +29,7 @@
 -- |   a sequence of lines need to be /folded/ to a single line. An example
 -- |   is MIME headers. Line folding based binding separation is used in
 -- |   Haskell as well.
-module Text.Parsing.Indent
+module Parsing.Indent
   ( IndentParser
   , runIndent
   , withBlock
@@ -61,25 +61,20 @@ import Prelude
 
 import Control.Alt ((<|>))
 import Control.Apply (lift2)
-import Control.Monad.State (State, evalState, gets)
+import Control.Monad.State (State, evalState)
 import Control.Monad.State.Trans (get, put)
 import Control.Monad.Trans.Class (lift)
 import Data.List (List(..), many)
 import Data.Maybe (Maybe(..))
-import Text.Parsing.Parser (ParseState(ParseState), ParserT, fail)
-import Text.Parsing.Parser.Combinators (option, optionMaybe)
-import Text.Parsing.Parser.Pos (Position(..), initialPos)
-import Text.Parsing.Parser.String (oneOf, string)
+import Parsing (ParserT, fail, position)
+import Parsing.Combinators (option, optionMaybe)
+import Parsing.Pos (Position(..), initialPos)
+import Parsing.String (oneOf, string)
 
 -- | Indentation sensitive parser type. Usually @ m @ will
 -- | be @ Identity @ as with any @ ParserT @
 type IndentParser s a = ParserT s (State Position) a
 
--- | @ getPosition @ returns current position
--- | should probably be added to Text.Parsing.Parser.Pos
-getPosition :: forall m s. ParserT s m Position
-getPosition = gets \(ParseState _ pos _) -> pos
-
 -- | simple helper function to avoid typ-problems with MonadState instance
 get' :: forall s. IndentParser s Position
 get' = do
@@ -102,7 +97,6 @@ setSourceLine (Position { line: _, column: c }) l = Position { line: l, column:
 biAp :: forall a b c. (a -> b) -> (b -> b -> c) -> a -> a -> c
 biAp f c v1 v2 = c (f v1) (f v2)
 
--- | @ many1 @ should prabably be inside Text.Parsing.Parser.Combinators
 many1 :: forall s m a. ParserT s m a -> ParserT s m (List a)
 many1 p = lift2 Cons p (many p)
 
@@ -127,7 +121,7 @@ withBlock' = withBlock (flip const)
 -- | Parses only when indented past the level of the reference
 indented :: forall s. IndentParser s Unit
 indented = do
-  pos <- getPosition
+  pos <- position
   s <- get'
   if biAp sourceColumn (<=) pos s then fail "not indented"
   else do
@@ -137,7 +131,7 @@ indented = do
 -- | Same as `indented`, but does not change internal state
 indented' :: forall s. IndentParser s Unit
 indented' = do
-  pos <- getPosition
+  pos <- position
   s <- get'
   if biAp sourceColumn (<=) pos s then fail "not indented" else pure unit
 
@@ -148,7 +142,7 @@ sameOrIndented = sameLine <|> indented
 -- | Parses only on the same line as the reference
 sameLine :: forall s. IndentParser s Unit
 sameLine = do
-  pos <- getPosition
+  pos <- position
   s <- get'
   if biAp sourceLine (==) pos s then pure unit else fail "over one line"
 
@@ -168,15 +162,15 @@ block p = withPos $ do
 withPos :: forall s a. IndentParser s a -> IndentParser s a
 withPos x = do
   a <- get'
-  p <- getPosition
+  p <- position
   r <- put' p *> x
   put' a *> pure r
 
 -- | Ensures the current indentation level matches that of the reference
 checkIndent :: forall s. IndentParser s Unit
 checkIndent = do
   s <- get'
-  p <- getPosition
+  p <- position
   if biAp sourceColumn (==) p s then pure unit else fail "indentation doesn't match"
 
 -- | Run the result of an indentation sensitive parse

src/Text/Parsing/Parser/Language.purs renamed to src/Parsing/Language.purs

@@ -1,7 +1,7 @@
 -- | This module is a port of the Haskell
 -- | [__Text.Parsec.Language__](https://hackage.haskell.org/package/parsec/docs/Text-Parsec-Language.html)
 -- | module.
-module Text.Parsing.Parser.Language
+module Parsing.Language
   ( haskellDef
   , haskell
   , emptyDef
@@ -12,10 +12,10 @@ module Text.Parsing.Parser.Language
 import Prelude
 
 import Control.Alt ((<|>))
-import Text.Parsing.Parser (ParserT)
-import Text.Parsing.Parser.String (char, oneOf)
-import Text.Parsing.Parser.String.Basic (alphaNum, letter)
-import Text.Parsing.Parser.Token (GenLanguageDef(..), LanguageDef, TokenParser, makeTokenParser, unGenLanguageDef)
+import Parsing (ParserT)
+import Parsing.String (char, oneOf)
+import Parsing.String.Basic (alphaNum, letter)
+import Parsing.Token (GenLanguageDef(..), LanguageDef, TokenParser, makeTokenParser, unGenLanguageDef)
 
 -----------------------------------------------------------
 -- Styles: haskellStyle, javaStyle

src/Text/Parsing/Parser/Pos.purs renamed to src/Parsing/Pos.purs

@@ -1,4 +1,4 @@
-module Text.Parsing.Parser.Pos where
+module Parsing.Pos where
 
 import Prelude
 

src/Text/Parsing/Parser/String.purs renamed to src/Parsing/String.purs

@@ -19,7 +19,7 @@
 -- | The other primitive parsers, which return `CodePoint` and `String` types,
 -- | can parse the full Unicode character set. All of the primitive parsers
 -- | in this module can be used together.
-module Text.Parsing.Parser.String
+module Parsing.String
   ( string
   , eof
   , rest
@@ -60,9 +60,9 @@ import Data.Tuple (Tuple(..), fst)
 import Partial.Unsafe (unsafePartial)
 import Prim.Row (class Nub, class Union)
 import Record (merge)
-import Text.Parsing.Parser (ParseError(..), ParseState(..), ParserT(..), fail)
-import Text.Parsing.Parser.Combinators ((<?>), (<~?>))
-import Text.Parsing.Parser.Pos (Position(..))
+import Parsing (ParseError(..), ParseState(..), ParserT(..), fail)
+import Parsing.Combinators ((<?>), (<~?>))
+import Parsing.Pos (Position(..))
 
 -- | Match “end-of-file,” the end of the input stream.
 eof :: forall m. ParserT String m Unit