Gobble is a simple parser combinator system for parsing strings.
For example parsing a function call
use *;
let ident = ;
let fsig = ;
let = fsig.parse_s.unwrap;
assert_eq!;
assert_eq!;
//identifiers cant start with numbers,
assert!;
To work this library depends the following:
//The LCChars in the result will be a clone of the incoming iterator
//but having iterated to end of the what the parser required.
pub type ParseRes<'a, V> = ;
//implements Iterator and can be cloned relatively cheaply
Parser is automatically implemented for:
Fn<'a>(&LCChars<'a>)->ParseRes<'a,String>
&'static str
which will return itself if it matcheschar
which will return itself if it matched the next char- Tuples of up to 6 parsers. Returning a tuple of all the parsers matched one after the other.
Most of the time a parser can be built simply by combining other parsers
use *;
// map can be used to convert one result to another
// keyval is now a function that returns a parser
let keyval = ;
//this can also be written as below for better type safety
//parse_s is a helper on Parsers
let = keyval.parse_s.unwrap;
assert_eq!;
assert_eq!;
//this can now be combined with other parsers.
// 'ig_then' combines 2 parsers and drops the result of the first
// 'then_ig' drops the result of the second
// 'sep_until will repeat the first term into a Vec, separated by the second
// until the final term.
let obj = ;
let obs = obj.parse_s.unwrap;
assert_eq!;
CharBool
CharBool is the trait for boolean char checks. It is auto implemented for:
- Fn(char)->bool
- char -- Returns true if the input matches the char
- &'static str -- returns true if the str contains the input
- several zero size types - Alpha,NumDigit,HexDigit,WS,WSL,Any
- Tuples of up to 6 CharBools -- returning true if any of the members succeed
This means you can combine them in tuples (Alpha,NumDigit,"_").char_bool(c)
will be true if any of them match
CharBool also provides 3 helper methods which each return a parser
one()
matches and returns exactly 1 charactermin_n(n)
requires at least n matches ruturns a stringany()
matches any number of chars returning a string
And a helper that returns a CharBool
except(cb)
Passes if self does, and cb doesnt
use *;
let s = ;
let xv = s.one.parse_s.unwrap;
assert_eq!;
let id = .min_n.parse_s.unwrap;
assert_eq!;
// not enough matches
assert!;
// any succeeds even with no matches equivilent to min(0)
assert_eq!;
assert_eq!;
White Space
White space is pretty straight forward to handle
use *;
let my_ws = ;
// middle takes three parsers and returns the result of the middle
// this could also be done easily with 'map' or 'then_ig'
let my_s = ;
let sp_id = my_s;
let v = sp_id.parse_s.unwrap;
assert_eq!;
That said gobble already provides ws()
and s_(p)
use *;
//eoi = end of input
let p = repeat_until_ig;
let r = p.parse_s.unwrap;
assert_eq!;
Recursive Structures
Some structures like Json, or programming languages need to be able to handle recursion. However with the techniques we have used so far this would lead to infinitely sized structures.
The way to handle this is to make sure one member of the loop is not
build into the structure. Instead to create it using the 'Fn'
use *;
// using the full fn def we avoid the recursive structure
let r = expr.parse_s.unwrap;
//recursive structures are never fun to write manually
assert_eq!;
Changelog:
v 0.2.1 WIP:
- Added StringRepeat
- added SkipRepeat
- switched LCChars to use CharIndices
- now has index parser
v 0.2.0 -- Major update:
- created a new trait called CharBool
- removed is_alpha_num
- Added Character readers, that take use the CharBool trait to get what they want
v 0.1.6:
- Added line_col wrappper to get the line and column of the result
- Added
one_char(&str)
Parser to check the next char is a member of that.
v 0.1.5 :
- Added common_float method
- impl Parser for char and &'static str
- made tuples work as combinator parsers
v 0.1.4:
- Added keyword to make sure there are no alpha num characters on the end of the keyword
- Fixed the error display method to make them easier to read.
- added a 'common' module and
common_int
andcommon_bool
parsers
v 0.1.3:
- Added reflect functionality for when you need to count up and down again
v 0.1.2 :
- Added
sep_until(main,sep,close)
- Added
repeat_until(main,close)
- Fixed Or Error to include both errors to make it easier to find the problems in branching iterators
v 0.1.1 :
- Added
eoi
andto_end()
functions for making sure you have the end of the input; - Added
common_str()
for getting the most common form of string