Parser Templates

TextParse.tryparsenext(x::CombinedParser,str,i,till,opts=TextParse.default_opts)

TextParse.jl integrates with CombinedParsers.jl both ways.

tryparsenext returns a tuple (result, nextpos) where result is of type Nullable{T}, Nullable{T}() if parsing failed, non-null containing the parsed value if it succeeded. If parsing succeeded, nextpos is the position the next token, if any, starts at. If parsing failed, nextpos is the position at which the

parsing failed.

julia> using TextParse

julia> p = ("Number:" * Repeat(' ') * TextParse.Numeric(Int))[3]
🗄 Sequence[3]
├─ Number\:
├─ \ *  |> Repeat
└─ <Int64>
::Int64

julia> parse(p, "Number:    42")
42

julia> TextParse.tryparsenext(p, "Number:    42")
(Nullable{Int64}(42), 14)

NumericParser(x...) = parser(TextParse.Numeric(x...))

DateParser(format::DateFormat...)
DateTimeParser(format::DateFormat...)

Create a parser matching either one format using TextParse.DateTimeToken for Dates.Date and Dates.DateTime respectively.

DateParser(format::AbstractString...; locale="english")
DateTimeParser(format::AbstractString...; locale="english")

Convenience functions for above using Dates.DateFormat.(format, locale).

DateParser(format::DateFormat...)
DateTimeParser(format::DateFormat...)

Create a parser matching either one format using TextParse.DateTimeToken for Dates.Date and Dates.DateTime respectively.

DateParser(format::AbstractString...; locale="english")
DateTimeParser(format::AbstractString...; locale="english")

Convenience functions for above using Dates.DateFormat.(format, locale).

integer_base(base,mind=0,maxd=Repeat_max)

Parser matching a integer format on base base.

parser(x)

A ConstantParser matching x.

parser(x::StepRange{Char,<:Integer})

ValueIn matching x.

parser(x::Pair{Symbol, P}) where P

A parser labelled with name x.first. Labels are useful in printing and logging.

See also: @with_names, with_name, log_names

parser(x::CharWithOptions)

A ConstantParser matching x, respecting Base.PCRE.CASELESS.

Base.convert(::Type{CombinedParser},x)

parser(x).

Base.convert(::Type{Char},y::CharWithOptions)

Strips options.

wrap(x::CombinedParser; log = nothing, trace = false)

transform a parser by wrapping sub-parsers in logging and tracing parser types.

trim(p...; whitespace=horizontal_space_maybe, 
           left=whitespace, right=whitespace)

Ignore whitespace left and right of sSequence(p...).

@trimmed

Create parser within whitespace_maybe to match the variables they are asigned to.

See also trim.

DocTestFilters = r"map\(.+\)"

so, for example

julia> @trimmed foo = AnyChar()
🗄 Sequence[2]
├─ (?>[\h]*) ValueIn |> Repeat |> ! |> Atomic
├─ . AnyValue |> with_name(:foo)
└─ (?>[\h]*) ValueIn |> Repeat |> ! |> Atomic
::Char

julia> parse(log_names(foo),"  ab  ")
   match foo@3-4:   ab
                    ^
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

whitespace_char  = re"[[:space:]]"
whitespace_maybe = re"(?>[[:space:]]*)"
whitespace       = re"(?>[[:space:]]+)"

julia> CombinedParsers.char_label_table(whitespace_char)
|      Char |                     |
|-----------|---------------------|
|     '\t' | Horizontal tab (HT) |
|     '\v' |   Vertical tab (VT) |
|     '\f' |      Form feed (FF) |
|       ' ' |               Space |
|   '\u85' |     Next line (NEL) |
| '\u200e' |  Left-to-right mark |
| '\u200f' |  Right-to-left mark |
| '\u2028' |      Line separator |
| '\u2029' | Paragraph separator |

horizontal_space_char  = re"[\h]"
horizontal_space_maybe = re"(?>[\h]*)"
horizontal_space       = re"(?>[\h]+)"

julia> CombinedParsers.char_label_table(horizontal_space_char)
|      Char |                           |
|-----------|---------------------------|
|     '\t' |       Horizontal tab (HT) |
|       ' ' |                     Space |
|       ' ' |           Non-break space |
|       ' ' |          Ogham space mark |
| '\u180e' | Mongolian vowel separator |
|       ' ' |                   En quad |
|       ' ' |                   Em quad |
|       ' ' |                  En space |
|       ' ' |                  Em space |
|       ' ' |        Three-per-em space |
|       ' ' |         Four-per-em space |
|       ' ' |          Six-per-em space |
|       ' ' |              Figure space |
|       ' ' |         Punctuation space |
|       ' ' |                Thin space |
|       ' ' |                Hair space |
|       ' ' |     Narrow no-break space |
|       ' ' | Medium mathematical space |
|       '　' |         Ideographic space |

vertical_space_char  = re"[\v]"
vertical_space_maybe = re"(?>[\v]*)"
vertical_space       = re"(?>[\v]+)"

julia> CombinedParsers.char_label_table(vertical_space_char)
|      Char |                      |
|-----------|----------------------|
|     '\n' |        Linefeed (LF) |
|     '\v' |    Vertical tab (VT) |
|     '\f' |       Form feed (FF) |
|     '\r' | Carriage return (CR) |
|   '\u85' |      Next line (NEL) |
| '\u2028' |       Line separator |
| '\u2029' |  Paragraph separator |

CombinedParsers.newline
CombinedParsers.Regexp.bsr

newlines, PCRE \r backslash R (BSR).

julia> CombinedParsers.Regexp.bsr
(?>|🗄) Either |> Atomic |> with_name(:bsr)
├─ \r\n 
└─ [\n\x0b\f\r\x85] ValueIn |> !
::SubString{String}

caseless(x)

MappedSequenceParser(lowercase, deepmap_parser(lowercase,parser(x))).

DocTestFilters = r"[0-9.]+ .s.*"

julia> p = caseless("AlsO")
🗄  |> MappedSequenceParser
├─ also
└─ lowercase
::SubString{String}

julia> p("also")
"also"

julia> using BenchmarkTools;

julia> @btime match(p,"also");
  51.983 ns (2 allocations: 176 bytes)

julia> p = parser("also")
re"also"

julia> @btime match(p,"also");
  44.759 ns (2 allocations: 176 bytes)

SubString of at least 1 repeated CombinedParsers.word_char.

Vector of at least 1 repeated CombinedParsers.words delimited by CombinedParsers.whitespace_horizontal.

inline = !Atomic(Repeat(NegativeLookahead(at_lineend)*AnyChar()))

See at_lineend.

Equivalent PRCE \w: Char with unicode class L, N, or _.

word_boundary = re""

beyond_word = Either(non_word_char,AtStart(),AtEnd())

Parser part of word_boundary.

at_linestart

julia> CombinedParsers.Regexp.at_linestart
|🗄 Either |> with_name(:at_linestart)
├─ ^ AtStart
└─ (?<=🗄)) Either |> Atomic |> with_name(:bsr) |> PositiveLookbehind
   ├─ \r\n
   └─ [\n\x0b\f\r\x85] ValueIn |> !
::Union{AtStart, SubString}

at_lineend

julia> CombinedParsers.Regexp.at_lineend
|🗄 Either |> with_name(:at_lineend)
├─ $ AtEnd
└─ (?=(?>|🗄)) Either |> Atomic |> with_name(:bsr) |> PositiveLookahead
   ├─ \r\n 
   └─ [\n\x0b\f\r\x85] ValueIn |> !
::Union{AtEnd, SubString{String}}