Text.Parsing.Replace.String
- Package
- purescript-parsing-replaceDEPRECATED
- Repository
- jamesdbrock/purescript-parsing-replace
Finding, splitting, and replacing String
s with
Text.Parsing.Parser.String
instead of
Data.String.Regex
.
Functions in this module are ways to run a parser on a String
,
like runParser
or runParserT
.
See the package README for usage examples.
#breakCap Source
breakCap :: forall a. Parser String a -> String -> Maybe (T3 String a String)
Break on and capture one pattern
Find the first occurence of a pattern in a text stream, capture the found pattern, and break the input text stream on the found pattern.
Be careful not to look too far
ahead; if the sep
parser looks to the end of the input then breakCap
could be O(n²).
Output
Nothing
when no pattern match was found.Just (prefix /\ parse_result /\ suffix)
for the result of parsing the pattern match, and theprefix
string before and thesuffix
string after the pattern match.prefix
andsuffix
may be zero-length strings.
Access the matched section of text
If you want to capture the matched string, then combine the pattern
parser sep
with match
.
With the matched string, we can reconstruct the input string.
For all input
, sep
, if
let (Just (prefix /\ (infix /\ _) /\ suffix)) = breakCap (match sep) input
then
input == prefix <> infix <> suffix
#splitCap Source
splitCap :: forall a. Parser String a -> String -> NonEmptyList (Either String a)
Split on and capture all patterns
Find all occurences of the pattern sep
, split the input string, capture
all the patterns and the splits.
The input string will be split on every leftmost non-overlapping occurence
of the pattern sep
. The output list will contain
the parsed result of input string sections which match the sep
pattern
in Right
, and non-matching sections in Left
.
Access the matched section of text
If you want to capture the matched strings, then combine the pattern
parser sep
with the match
combinator.
With the matched strings, we can reconstruct the input string.
For all input
, sep
, if
let output = splitCap (match sep) input
then
input == fold (either identity fst <$> output)
(This invariant might not hold if sep
can succeed without consuming
any input, like if sep
is a lookAhead
parser.)
#streamEdit Source
streamEdit :: forall a. Parser String a -> (a -> String) -> String -> String
Stream editor
Also known as “find-and-replace”, or “match-and-substitute”. Find all
of the leftmost non-overlapping sections of the input string which match
the pattern sep
, and
replace them with the result of the editor
function.
Access the matched section of text in the editor
If you want access to the matched string in the editor
function,
then combine the pattern parser sep
with match
. This will effectively change
the type of the editor
function to (String /\ a) -> String
.
This allows us to write an editor
function which can choose to not
edit the match and just leave it as it is. If the editor
function
returns the first item in the tuple, then streamEdit
will not change
the matched string.
So, for all sep
:
streamEdit (match sep) fst ≡ identity
(This invariant might not hold if sep
can succeed without consuming
any input, like if sep
is a lookAhead
parser.)
Re-exports from Text.Parsing.Replace.String.Combinator
#match Source
match :: forall m a. Monad m => ParserT String m a -> ParserT String m (Tuple String a)
The
famous match
combinator.
Return both the result of a parse and the portion of the input that was consumed while it was being parsed.
Note that this combinator only accepts the type String
, not any instance
of the StringLike
class.
#anyTill Source
anyTill :: forall m a. Monad m => MonadRec m => ParserT String m a -> ParserT String m (Tuple String a)
Find the first place in the input where the phrase can parse. Returns both the parsed result and the unparsable input section consumed before the parse. Will fail if no section of the input is parseable. Will not consume input on failure. Stack-safe.
This combinator is equivalent to manyTill_ anyChar
, but it will be
faster because it returns a slice of the input String
for the
section preceding the match instead of a List Char
.
Note that this combinator only accepts the type String
, not any instance
of the StringLike
class.