module Bookhound.Parsers.Text where

import           Bookhound.Parser            (Parser, anyChar)
import           Bookhound.ParserCombinators (IsMatch (..), between,
                                              maybeBetween, maybeSurroundedBy,
                                              surroundedBy, (->>-), (|+), (|?),
                                              (||*), (||+))
import           Bookhound.Parsers.Char      (alpha, alphaNum, closeAngle,
                                              closeCurly, closeParens,
                                              closeSquare, digit, doubleQuote,
                                              lower, newLine, openAngle,
                                              openCurly, openParens, openSquare,
                                              quote, space, spaceOrTab, tab,
                                              upper, whiteSpace)
import           Data.Text                   (Text)
import qualified Data.Text                   as Text


anyString :: Parser Text
anyString :: Parser Text
anyString = (Parser Char
anyChar ||*)

word :: Parser Text
word :: Parser Text
word = (forall a. IsMatch a => Parser a -> Parser a
inverse Parser Char
whiteSpace ||+)

digits :: Parser Text
digits :: Parser Text
digits = (Parser Char
digit ||+)

uppers :: Parser Text
uppers :: Parser Text
uppers = (Parser Char
upper ||+)

lowers :: Parser Text
lowers :: Parser Text
lowers = (Parser Char
lower ||+)

alphas :: Parser Text
alphas :: Parser Text
alphas = (Parser Char
alpha ||+)

alphaNums :: Parser Text
alphaNums :: Parser Text
alphaNums = (Parser Char
alphaNum ||+)



spaces :: Parser Text
spaces :: Parser Text
spaces = (Parser Char
space ||+)

tabs :: Parser Text
tabs :: Parser Text
tabs = (Parser Char
tab ||+)

newLines :: Parser Text
newLines :: Parser Text
newLines = (Parser Char
newLine ||+)

spacesOrTabs :: Parser Text
spacesOrTabs :: Parser Text
spacesOrTabs = (Parser Char
spaceOrTab ||+)

spacing :: Parser Text
spacing :: Parser Text
spacing = (Parser Char
whiteSpace ||+)

blankLine :: Parser Text
blankLine :: Parser Text
blankLine = (Parser Text
spacesOrTabs |?) forall a b.
(ToText a, ToText b) =>
Parser a -> Parser b -> Parser Text
->>- Parser Char
newLine

blankLines :: Parser Text
blankLines :: Parser Text
blankLines = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Text] -> Text
Text.concat (Parser Text
blankLine |+)



betweenQuotes :: Parser b -> Parser b
betweenQuotes :: forall b. Parser b -> Parser b
betweenQuotes = forall a b. Parser a -> Parser b -> Parser b
surroundedBy Parser Char
quote

betweenDoubleQuotes :: Parser b -> Parser b
betweenDoubleQuotes :: forall b. Parser b -> Parser b
betweenDoubleQuotes = forall a b. Parser a -> Parser b -> Parser b
surroundedBy Parser Char
doubleQuote

betweenSpacing :: Parser b -> Parser b
betweenSpacing :: forall b. Parser b -> Parser b
betweenSpacing = forall a b. Parser a -> Parser b -> Parser b
surroundedBy Parser Text
spacing

betweenParens :: Parser b -> Parser b
betweenParens :: forall b. Parser b -> Parser b
betweenParens = forall a b c. Parser a -> Parser b -> Parser c -> Parser c
between Parser Char
openParens Parser Char
closeParens

betweenSquare :: Parser b -> Parser b
betweenSquare :: forall b. Parser b -> Parser b
betweenSquare = forall a b c. Parser a -> Parser b -> Parser c -> Parser c
between Parser Char
openSquare Parser Char
closeSquare

betweenCurlyBrackets :: Parser b -> Parser b
betweenCurlyBrackets :: forall b. Parser b -> Parser b
betweenCurlyBrackets = forall a b c. Parser a -> Parser b -> Parser c -> Parser c
between Parser Char
openCurly Parser Char
closeCurly

betweenAngleBrackets :: Parser b -> Parser b
betweenAngleBrackets :: forall b. Parser b -> Parser b
betweenAngleBrackets = forall a b c. Parser a -> Parser b -> Parser c -> Parser c
between Parser Char
openAngle Parser Char
closeAngle



maybeBetweenQuotes :: Parser b -> Parser b
maybeBetweenQuotes :: forall b. Parser b -> Parser b
maybeBetweenQuotes = forall a b. Parser a -> Parser b -> Parser b
maybeSurroundedBy Parser Char
quote

maybeBetweenDoubleQuotes :: Parser b -> Parser b
maybeBetweenDoubleQuotes :: forall b. Parser b -> Parser b
maybeBetweenDoubleQuotes = forall a b. Parser a -> Parser b -> Parser b
maybeSurroundedBy Parser Char
doubleQuote

maybeBetweenSpacing :: Parser b -> Parser b
maybeBetweenSpacing :: forall b. Parser b -> Parser b
maybeBetweenSpacing = forall a b. Parser a -> Parser b -> Parser b
maybeSurroundedBy Parser Text
spacing

maybeBetweenParens :: Parser b -> Parser b
maybeBetweenParens :: forall b. Parser b -> Parser b
maybeBetweenParens = forall a b c. Parser a -> Parser b -> Parser c -> Parser c
maybeBetween Parser Char
openParens Parser Char
closeParens

maybeBetweenSquareBrackets :: Parser b -> Parser b
maybeBetweenSquareBrackets :: forall b. Parser b -> Parser b
maybeBetweenSquareBrackets = forall a b c. Parser a -> Parser b -> Parser c -> Parser c
maybeBetween Parser Char
openSquare Parser Char
closeSquare

maybeBetweenCurlyBrackets :: Parser b -> Parser b
maybeBetweenCurlyBrackets :: forall b. Parser b -> Parser b
maybeBetweenCurlyBrackets = forall a b c. Parser a -> Parser b -> Parser c -> Parser c
maybeBetween Parser Char
openCurly Parser Char
closeCurly

maybeBetweenAngleBrackets :: Parser b -> Parser b
maybeBetweenAngleBrackets :: forall b. Parser b -> Parser b
maybeBetweenAngleBrackets = forall a b c. Parser a -> Parser b -> Parser c -> Parser c
maybeBetween Parser Char
openAngle Parser Char
closeAngle