Re-export main API from single module and remove Text.Parsing prefix per #78 (#89)

* Move existing StringParser module to Parser

* Re-export other modules in main API

* Remove Text.Parsing prefex per #78

Author: chtenb

CHANGELOG.md

@@ -7,6 +7,7 @@ Notable changes to this project are documented in this file. The format is based
 Breaking changes:
 - Issue #77: Fix CodePoint parser quadratic performance (#83 by @chtenb). The parser now tracks the remaining unparsed substring. This change is breaking, but will trigger compile errors in all places where this definition is used.
 - Fix semantics of endBy and sepEndBy parser combinators (#84 by @chtenb)
+- Issue #78: Remove the Text.Parsing prefix from the modules (#89 by @chtenb)
 
 New features:
 - Introduce code point parsers `anyCodePoint`, `codePoint'` and `satisfyCodePoint` (#88 by @chtenb)
@@ -21,6 +22,7 @@ Other improvements:
 - Added `purs-tidy` formatter (#76 by @thomashoneyman)
 - Add a benchmark module (#79 by @chtenb)
 - Run slowest tests last and print status updates (#72)
+- Re-export the main API from a single module (StringParser) (#89 by @chtenb)
 
 ## [v6.0.1](https://github.com/purescript-contrib/purescript-string-parsers/releases/tag/v6.0.1) - 2021-05-11
 

bench/Main.purs

@@ -15,9 +15,9 @@ import Data.List.Types (List)
 import Effect (Effect)
 import Effect.Console (log)
 import Performance.Minibench (benchWith)
-import Text.Parsing.StringParser (Parser, runParser)
-import Text.Parsing.StringParser.CodePoints as StringParser.CodePoints
-import Text.Parsing.StringParser.CodeUnits as StringParser.CodeUnits
+import StringParser.Parser (Parser, runParser)
+import StringParser.CodePoints as StringParser.CodePoints
+import StringParser.CodeUnits as StringParser.CodeUnits
 
 string23_100 :: String
 string23_100 = fold $ replicate 100 "23"

src/StringParser.purs

@@ -0,0 +1,9 @@
+module StringParser
+  ( module StringParser.Parser
+  , module StringParser.Combinators
+  , module StringParser.CodePoints
+  ) where
+
+import StringParser.Parser (ParseError, Parser(..), Pos, PosString, fail, printParserError, runParser, unParser)
+import StringParser.Combinators (assertConsume, between, chainl, chainl1, chainr, chainr1, choice, endBy, endBy1, fix, lookAhead, many, many1, many1Till, manyTill, option, optionMaybe, optional, sepBy, sepBy1, sepEndBy, sepEndBy1, try, tryAhead, withError, (<?>))
+import StringParser.CodePoints (alphaNum, anyChar, anyCodePoint, anyDigit, anyLetter, char, codePoint, eof, lowerCaseChar, noneOf, oneOf, regex, satisfy, satisfyCodePoint, skipSpaces, string, upperCaseChar, whiteSpace)

src/Text/Parsing/StringParser/CodePoints.purs renamed to src/StringParser/CodePoints.purs

@@ -3,7 +3,7 @@
 -- | These functions will be much slower than the `CodeUnits` alternatives, but
 -- | will behave correctly in the presence of Unicode characters made up of
 -- | multiple code units.
-module Text.Parsing.StringParser.CodePoints
+module StringParser.CodePoints
   ( eof
   , anyChar
   , anyCodePoint
@@ -39,9 +39,9 @@ import Data.String.CodePoints as SCP
 import Data.String.CodeUnits as SCU
 import Data.String.Regex as Regex
 import Data.String.Regex.Flags (noFlags)
-import Text.Parsing.StringParser (Parser(..), fail)
-import Text.Parsing.StringParser.CodeUnits as CodeUnitsParser
-import Text.Parsing.StringParser.Combinators (try, many, (<?>))
+import StringParser.Parser (Parser(..), fail)
+import StringParser.CodeUnits as CodeUnitsParser
+import StringParser.Combinators (try, many, (<?>))
 
 -- | Match the end of the file.
 eof :: Parser Unit
@@ -157,7 +157,7 @@ regex :: String -> Parser String
 regex pat =
   case Regex.regex pattern noFlags of
     Left _ ->
-      fail $ "Text.Parsing.StringParser.String.regex': illegal regex " <> pat
+      fail $ "StringParser.String.regex': illegal regex " <> pat
     Right r ->
       matchRegex r
   where

src/Text/Parsing/StringParser/CodeUnits.purs renamed to src/StringParser/CodeUnits.purs

@@ -3,7 +3,7 @@
 -- | These functions will be much faster than the `CodePoints` alternatives, but
 -- | will behave incorrectly when dealing with Unicode characters that consist
 -- | of multiple code units.
-module Text.Parsing.StringParser.CodeUnits
+module StringParser.CodeUnits
   ( eof
   , anyChar
   , anyDigit
@@ -34,8 +34,8 @@ import Data.String.CodeUnits (charAt, singleton)
 import Data.String.CodeUnits as SCU
 import Data.String.Regex as Regex
 import Data.String.Regex.Flags (noFlags)
-import Text.Parsing.StringParser (Parser(..), fail)
-import Text.Parsing.StringParser.Combinators (try, many, (<?>))
+import StringParser.Parser (Parser(..), fail)
+import StringParser.Combinators (try, many, (<?>))
 
 -- | Match the end of the file.
 eof :: Parser Unit
@@ -124,7 +124,7 @@ regex :: String -> Parser String
 regex pat =
   case Regex.regex pattern noFlags of
     Left _ ->
-      fail $ "Text.Parsing.StringParser.String.regex': illegal regex " <> pat
+      fail $ "StringParser.String.regex': illegal regex " <> pat
     Right r ->
       matchRegex r
   where

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

@@ -1,5 +1,5 @@
 -- | This module defines combinators for building string parsers.
-module Text.Parsing.StringParser.Combinators
+module StringParser.Combinators
   ( try
   , lookAhead
   , tryAhead
@@ -40,7 +40,7 @@ import Data.List.NonEmpty (NonEmptyList(..))
 import Data.List.NonEmpty as NEL
 import Data.Maybe (Maybe(..))
 import Data.NonEmpty ((:|))
-import Text.Parsing.StringParser (Parser(..), fail)
+import StringParser.Parser (Parser(..), fail)
 
 -- | `try p` means: run `p` but do not consume input in case of failure.
 try :: forall a. Parser a -> Parser a

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

@@ -1,6 +1,6 @@
 -- | This module defines helper functions for defining parsers using operator tables.
 
-module Text.Parsing.StringParser.Expr
+module StringParser.Expr
   ( Assoc(..)
   , Operator(..)
   , OperatorTable()
@@ -12,8 +12,8 @@ import Prelude
 import Control.Alt ((<|>))
 import Data.Foldable (foldl, foldr)
 import Data.List (List(..))
-import Text.Parsing.StringParser (Parser)
-import Text.Parsing.StringParser.Combinators (choice, (<?>))
+import StringParser.Parser (Parser)
+import StringParser.Combinators (choice, (<?>))
 
 -- | Operator associativity types.
 data Assoc = AssocNone | AssocLeft | AssocRight
@@ -57,7 +57,7 @@ buildExprParser operators simpleExpr = do
             <|> lassocP x lassocOp prefixP term postfixP
             <|> nassocP x nassocOp prefixP term postfixP
             <|> pure x
-            <?> "operator"
+              <?> "operator"
 
     splitOp :: forall b. Operator b -> SplitAccum b -> SplitAccum b
     splitOp (Infix op AssocNone) accum = accum { nassoc = Cons op accum.nassoc }

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

@@ -1,6 +1,6 @@
 -- | This module defines the `Parser` type of string parsers, and its instances.
 
-module Text.Parsing.StringParser where
+module StringParser.Parser where
 
 import Prelude
 

test/BasicSpecs.purs

@@ -15,9 +15,7 @@ import Effect.Class.Console (log)
 import Partial.Unsafe (unsafePartial)
 import Test.Assert (assert')
 import Test.Utils (AnyParser(..), mkAnyParser)
-import Text.Parsing.StringParser (Parser, runParser)
-import Text.Parsing.StringParser.CodePoints (anyChar, anyCodePoint, anyDigit, anyLetter, char, codePoint, eof, skipSpaces, string)
-import Text.Parsing.StringParser.Combinators (try, tryAhead, between, chainl, chainl1, endBy, endBy1, lookAhead, many, many1, manyTill, many1Till, optionMaybe, sepBy, sepBy1, sepEndBy, sepEndBy1)
+import StringParser (Parser, anyChar, anyCodePoint, anyDigit, anyLetter, between, chainl, chainl1, char, codePoint, endBy, endBy1, eof, lookAhead, many, many1, many1Till, manyTill, optionMaybe, runParser, sepBy, sepBy1, sepEndBy, sepEndBy1, skipSpaces, string, try, tryAhead)
 
 type TestInputs = { successes :: Array String, failures :: Array String }
 type TestCase = { name :: String, parser :: AnyParser, inputs :: TestInputs }

test/CodePoints.purs

@@ -15,10 +15,10 @@ import Data.Unfoldable (replicate)
 import Effect (Effect)
 import Effect.Class.Console (log)
 import Test.Assert (assert', assert)
-import Text.Parsing.StringParser (ParseError, Parser(..), PosString, runParser)
-import Text.Parsing.StringParser.CodePoints (anyDigit, char, eof, string, anyChar, regex)
-import Text.Parsing.StringParser.Combinators (try, many1, endBy1, sepBy1, optionMaybe, many, manyTill, many1Till, chainl, fix, between)
-import Text.Parsing.StringParser.Expr (Assoc(..), Operator(..), buildExprParser)
+import StringParser.Parser (ParseError, Parser(..), PosString, runParser)
+import StringParser.CodePoints (anyDigit, char, eof, string, anyChar, regex)
+import StringParser.Combinators (try, many1, endBy1, sepBy1, optionMaybe, many, manyTill, many1Till, chainl, fix, between)
+import StringParser.Expr (Assoc(..), Operator(..), buildExprParser)
 
 parens :: forall a. Parser a -> Parser a
 parens = between (string "(") (string ")")

test/CodeUnits.purs

@@ -15,10 +15,10 @@ import Data.Unfoldable (replicate)
 import Effect (Effect)
 import Effect.Class.Console (log)
 import Test.Assert (assert', assert)
-import Text.Parsing.StringParser (Parser, runParser)
-import Text.Parsing.StringParser.CodeUnits (anyDigit, eof, string, anyChar, regex)
-import Text.Parsing.StringParser.Combinators (try, many1, endBy1, sepBy1, optionMaybe, many, manyTill, many1Till, chainl, fix, between)
-import Text.Parsing.StringParser.Expr (Assoc(..), Operator(..), buildExprParser)
+import StringParser.Parser (Parser, runParser)
+import StringParser.CodeUnits (anyDigit, eof, string, anyChar, regex)
+import StringParser.Combinators (try, many1, endBy1, sepBy1, optionMaybe, many, manyTill, many1Till, chainl, fix, between)
+import StringParser.Expr (Assoc(..), Operator(..), buildExprParser)
 
 parens :: forall a. Parser a -> Parser a
 parens = between (string "(") (string ")")

test/Examples.purs

@@ -1,4 +1,4 @@
-module Text.Parsing.StringParser.Examples where
+module StringParser.Examples where
 
 import Prelude hiding (between)
 
@@ -8,9 +8,7 @@ import Data.Foldable (fold, foldl, sum)
 import Data.List.Types (NonEmptyList)
 import Effect (Effect)
 import Effect.Console (log, logShow)
-import Text.Parsing.StringParser (Parser, fail, runParser, unParser)
-import Text.Parsing.StringParser.CodePoints (anyChar, char, eof, regex, skipSpaces, string)
-import Text.Parsing.StringParser.Combinators (between, lookAhead, endBy1, many, many1, sepBy1, (<?>))
+import StringParser (Parser, anyChar, between, char, endBy1, eof, fail, lookAhead, many, many1, regex, runParser, sepBy1, skipSpaces, string, unParser, (<?>))
 
 -- Serves only to make this file runnable
 main :: Effect Unit
@@ -95,14 +93,14 @@ extractWords = do
     ( many1
         ( string " " <?> "Failed to match space as a separator"
             <|> string "'"
-            <?> "Failed to match single-quote char as a separator"
+              <?> "Failed to match single-quote char as a separator"
             <|> string ","
-            <?> "Failed to match comma as a separator"
+              <?> "Failed to match comma as a separator"
             <|> string "?"
-            <?> "Failed to match question mark as a separator"
+              <?> "Failed to match question mark as a separator"
             <|> string "."
-            <?> "Failed to match period as a separator"
-            <?> "Could not find a character that separated the content..."
+              <?> "Failed to match period as a separator"
+              <?> "Could not find a character that separated the content..."
         )
     )
 
@@ -113,12 +111,12 @@ badExtractWords = do
     ( many1
         ( string " " <?> "Failed to match space as a separator"
             <|> string "'"
-            <?> "Failed to match single-quote char as a separator"
+              <?> "Failed to match single-quote char as a separator"
             <|> string ","
-            <?> "Failed to match comma as a separator"
-            -- <|> string "?" <?> "Failed to match question mark as a separator"
-            -- <|> string "." <?> "Failed to match period as a separator"
-            <?> "Could not find a character that separated the content..."
+              <?> "Failed to match comma as a separator"
+              -- <|> string "?" <?> "Failed to match question mark as a separator"
+              -- <|> string "." <?> "Failed to match period as a separator"
+              <?> "Could not find a character that separated the content..."
         )
     )
   -- short for 'end of file' or 'end of content'

test/Utils.purs

@@ -1,6 +1,6 @@
 module Test.Utils where
 
-import Text.Parsing.StringParser (Parser)
+import StringParser.Parser (Parser)
 
 newtype AnyParser = AnyParser (forall r. (forall a. Parser a -> r) -> r)