SYMBOL INDEX (223 symbols across 18 files)

FILE: benches/json.rs
  function json_byte (line 14) | fn json_byte(b: &mut Bencher) {

FILE: benches/json_char.rs
  function json_char (line 14) | fn json_char(b: &mut Bencher) {

FILE: examples/duration.rs
  type Duration (line 7) | struct Duration {
  function number_separator (line 17) | fn number_separator() -> Parser<u8, ()> {
  function number (line 22) | fn number() -> Parser<u8, f32> {
  function date_part (line 32) | fn date_part() -> Parser<u8, (Option<f32>, Option<f32>, Option<f32>, Opt...
  function time_part (line 40) | fn time_part() -> Parser<u8, (Option<f32>, Option<f32>, Option<f32>)> {
  function parser (line 48) | fn parser() -> Parser<u8, Duration> {
  function main (line 75) | fn main() {

FILE: examples/json.rs
  type JsonValue (line 9) | pub enum JsonValue {
  function space (line 18) | fn space<'a>() -> Parser<'a, u8, ()> {
  function number (line 22) | fn number<'a>() -> Parser<'a, u8, f64> {
  function string (line 33) | fn string<'a>() -> Parser<'a, u8, String> {
  function array (line 60) | fn array<'a>() -> Parser<'a, u8, Vec<JsonValue>> {
  function object (line 65) | fn object<'a>() -> Parser<'a, u8, HashMap<String, JsonValue>> {
  function value (line 72) | fn value<'a>() -> Parser<'a, u8, JsonValue> {
  function json (line 83) | pub fn json<'a>() -> Parser<'a, u8, JsonValue> {
  function main (line 88) | fn main() {

FILE: examples/json_char.rs
  type JsonValue (line 9) | pub enum JsonValue {
  function space (line 18) | fn space<'a>() -> Parser<'a, char, ()> {
  function number (line 22) | fn number<'a>() -> Parser<'a, char, f64> {
  function string (line 33) | fn string<'a>() -> Parser<'a, char, String> {
  function array (line 60) | fn array<'a>() -> Parser<'a, char, Vec<JsonValue>> {
  function object (line 65) | fn object<'a>() -> Parser<'a, char, HashMap<String, JsonValue>> {
  function value (line 72) | fn value<'a>() -> Parser<'a, char, JsonValue> {
  function json (line 83) | pub fn json<'a>() -> Parser<'a, char, JsonValue> {
  function main (line 88) | fn main() {

FILE: examples/json_file.rs
  type JsonValue (line 11) | pub enum JsonValue {
  function space (line 20) | fn space<'a>() -> Parser<'a, u8, ()> {
  function number (line 24) | fn number<'a>() -> Parser<'a, u8, f64> {
  function string (line 35) | fn string<'a>() -> Parser<'a, u8, String> {
  function array (line 62) | fn array<'a>() -> Parser<'a, u8, Vec<JsonValue>> {
  function object (line 67) | fn object<'a>() -> Parser<'a, u8, HashMap<String, JsonValue>> {
  function value (line 74) | fn value<'a>() -> Parser<'a, u8, JsonValue> {
  function json (line 85) | pub fn json<'a>() -> Parser<'a, u8, JsonValue> {
  function main (line 90) | fn main() {

FILE: examples/simple.rs
  function main (line 3) | fn main() {

FILE: examples/utf8.rs
  function main (line 5) | fn main() {

FILE: examples/utf8_mixed.rs
  function main (line 6) | fn main() {

FILE: examples/whitespace.rs
  type Container (line 4) | struct Container {
  type TmpContainerOrContent (line 9) | enum TmpContainerOrContent {
  function whitespace (line 14) | fn whitespace<'a>() -> Parser<'a, u8, ()> {
  function linebreak (line 18) | fn linebreak<'a>() -> Parser<'a, u8, ()> {
  function indented (line 22) | fn indented<'a>() -> Parser<'a, u8, Vec<u8>> {
  function empty (line 26) | fn empty<'a>() -> Parser<'a, u8, ()> {
  function content (line 30) | fn content<'a>() -> Parser<'a, u8, String> {
  function subcontainer (line 34) | fn subcontainer<'a>() -> Parser<'a, u8, (Vec<Container>, Vec<String>)> {
  function container (line 52) | fn container<'a>() -> Parser<'a, u8, Container> {
  function mylang (line 74) | fn mylang<'a>() -> Parser<'a, u8, Vec<Container>> {
  function main (line 78) | fn main() -> Result<(), ()> {

FILE: src/char_class.rs
  function alpha (line 3) | pub fn alpha(term: u8) -> bool {
  function alpha_uppercase (line 9) | pub fn alpha_uppercase(term: u8) -> bool {
  function alpha_lowercase (line 15) | pub fn alpha_lowercase(term: u8) -> bool {
  function digit (line 21) | pub fn digit(term: u8) -> bool {
  function alphanum (line 27) | pub fn alphanum(term: u8) -> bool {
  function hex_digit (line 33) | pub fn hex_digit(term: u8) -> bool {
  function oct_digit (line 39) | pub fn oct_digit(term: u8) -> bool {
  function space (line 45) | pub fn space(term: u8) -> bool {
  function multispace (line 51) | pub fn multispace(term: u8) -> bool {
  function is_an_alpha (line 60) | fn is_an_alpha() {
  function is_an_alpha_uppercase (line 68) | fn is_an_alpha_uppercase() {
  function is_an_alpha_lowercase (line 76) | fn is_an_alpha_lowercase() {
  function is_a_digit (line 84) | fn is_a_digit() {
  function is_an_alphanum (line 91) | fn is_an_alphanum() {
  function is_a_hex_digit (line 102) | fn is_a_hex_digit() {
  function is_a_oct_digit (line 113) | fn is_a_oct_digit() {
  function is_space (line 121) | fn is_space() {
  function is_multispace (line 129) | fn is_multispace() {

FILE: src/lib.rs
  type Parser (line 19) | pub type Parser<I, O> = parser::Parser<'static, I, O>;

FILE: src/parser.rs
  type Parse (line 9) | type Parse<'a, I, O> = dyn Fn(&'a [I], usize) -> Result<(O, usize)> + 'a;
  type Parser (line 12) | pub struct Parser<'a, I, O> {
  function new (line 18) | pub fn new<P>(parse: P) -> Self
  function parse (line 28) | pub fn parse(&self, input: &'a [I]) -> Result<O> {
  function parse_at (line 33) | pub fn parse_at(&self, input: &'a [I], start: usize) -> Result<(O, usize...
  function map (line 38) | pub fn map<U, F>(self, f: F) -> Parser<'a, I, U>
  function convert (line 51) | pub fn convert<U, E, F>(self, f: F) -> Parser<'a, I, U>
  function cache (line 70) | pub fn cache(self) -> Self
  function pos (line 87) | pub fn pos(self) -> Parser<'a, I, usize>
  function collect (line 97) | pub fn collect(self) -> Parser<'a, I, &'a [I]>
  function discard (line 107) | pub fn discard(self) -> Parser<'a, I, ()>
  function opt (line 117) | pub fn opt(self) -> Parser<'a, I, Option<O>>
  function repeat (line 133) | pub fn repeat<R>(self, range: R) -> Parser<'a, I, Vec<O>>
  function name (line 180) | pub fn name(self, name: &'a str) -> Self
  function name (line 201) | pub fn name(self, name: &'a str) -> Self
  function expect (line 228) | pub fn expect(self, name: &'a str) -> Self
  function empty (line 246) | pub fn empty<'a, I>() -> Parser<'a, I, ()> {
  function any (line 251) | pub fn any<'a, I>() -> Parser<'a, I, I>
  function sym (line 267) | pub fn sym<'a, I>(t: I) -> Parser<'a, I, I>
  function seq (line 286) | pub fn seq<'a, 'b: 'a, I>(tag: &'b [I]) -> Parser<'a, I, &'a [I]>
  function tag (line 312) | pub fn tag<'a, 'b: 'a>(tag: &'b str) -> Parser<'a, char, &'a str> {
  function list (line 332) | pub fn list<'a, I, O, U>(
  function one_of (line 361) | pub fn one_of<'a, I, S>(set: &'a S) -> Parser<'a, I, I>
  function none_of (line 381) | pub fn none_of<'a, I, S>(set: &'static S) -> Parser<'a, I, I>
  function is_a (line 401) | pub fn is_a<'a, I, F>(predicate: F) -> Parser<'a, I, I>
  function not_a (line 421) | pub fn not_a<'a, I, F>(predicate: F) -> Parser<'a, I, I>
  function take (line 441) | pub fn take<'a, I>(n: usize) -> Parser<'a, I, &'a [I]> {
  function skip (line 452) | pub fn skip<'a, I>(n: usize) -> Parser<'a, I, ()> {
  function call (line 463) | pub fn call<'a, I, O, F>(parser_factory: F) -> Parser<'a, I, O>
  function end (line 475) | pub fn end<'a, I>() -> Parser<'a, I, ()>
  type Output (line 492) | type Output = Parser<'a, I, (O, U)>;
  function add (line 494) | fn add(self, other: Parser<'a, I, U>) -> Self::Output {
  type Output (line 505) | type Output = Parser<'a, I, O>;
  function sub (line 507) | fn sub(self, other: Parser<'a, I, U>) -> Self::Output {
  type Output (line 517) | type Output = Parser<'a, I, U>;
  function mul (line 519) | fn mul(self, other: Parser<'a, I, U>) -> Self::Output {
  type Output (line 528) | type Output = Parser<'a, I, U>;
  function shr (line 530) | fn shr(self, other: F) -> Self::Output {
  type Output (line 539) | type Output = Parser<'a, I, O>;
  method bitor (line 541) | fn bitor(self, other: Parser<'a, I, O>) -> Self::Output {
  type Output (line 556) | type Output = Parser<'a, I, bool>;
  method neg (line 558) | fn neg(self) -> Self::Output {
  type Output (line 567) | type Output = Parser<'a, I, bool>;
  method not (line 569) | fn not(self) -> Self::Output {
  function byte_works (line 588) | fn byte_works() {
  function char_works (line 621) | fn char_works() {
  function recursive_parser (line 629) | fn recursive_parser() {
  function chain_parser (line 649) | fn chain_parser() {
  function repeat_at_least (line 676) | fn repeat_at_least() {
  function repeat_up_to (line 717) | fn repeat_up_to() {
  function repeat_up_to_inclusive (line 752) | fn repeat_up_to_inclusive() {
  function repeat_from_to_inclusive (line 781) | fn repeat_from_to_inclusive() {
  function repeat_exactly (line 816) | fn repeat_exactly() {
  function named (line 852) | fn named() {
  function named (line 882) | fn named() {

FILE: src/range.rs
  type RangeArgument (line 3) | pub trait RangeArgument<T> {
    method start (line 4) | fn start(&self) -> Bound<&usize>;
    method end (line 5) | fn end(&self) -> Bound<&usize>;
  function start (line 9) | fn start(&self) -> Bound<&usize> {
  function end (line 12) | fn end(&self) -> Bound<&usize> {
  function start (line 18) | fn start(&self) -> Bound<&usize> {
  function end (line 21) | fn end(&self) -> Bound<&usize> {
  method start (line 27) | fn start(&self) -> Bound<&usize> {
  method end (line 30) | fn end(&self) -> Bound<&usize> {
  function start (line 36) | fn start(&self) -> Bound<&usize> {
  function end (line 39) | fn end(&self) -> Bound<&usize> {
  function start (line 45) | fn start(&self) -> Bound<&usize> {
  function end (line 48) | fn end(&self) -> Bound<&usize> {
  function start (line 54) | fn start(&self) -> Bound<&usize> {
  function end (line 57) | fn end(&self) -> Bound<&usize> {
  function start (line 63) | fn start(&self) -> Bound<&usize> {
  function end (line 66) | fn end(&self) -> Bound<&usize> {
  function accept (line 75) | fn accept<T, R>(ra: R, expected: impl std::ops::RangeBounds<usize>)
  function unbounded (line 84) | fn unbounded() {
  function up_to_inclusive (line 89) | fn up_to_inclusive() {
  function up_to_exclusive (line 94) | fn up_to_exclusive() {
  function from (line 99) | fn from() {
  function from_to_inclusive (line 104) | fn from_to_inclusive() {
  function from_to_exclusive (line 109) | fn from_to_exclusive() {
  function exactly (line 114) | fn exactly() {

FILE: src/result.rs
  type Error (line 8) | pub enum Error {
    method description (line 31) | fn description(&self) -> &'static str {
  method fmt (line 37) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Result (line 68) | pub type Result<O> = ::std::result::Result<O, Error>;

FILE: src/set.rs
  type Set (line 8) | pub trait Set<T> {
    method contains (line 10) | fn contains(&self, elem: &T) -> bool;
    method to_str (line 13) | fn to_str(&self) -> &str {
  function contains (line 19) | fn contains(&self, elem: &T) -> bool {
  function contains (line 25) | fn contains(&self, elem: &char) -> bool {
  function to_str (line 29) | fn to_str(&self) -> &str {
  function contains (line 35) | fn contains(&self, elem: &T) -> bool {
  function contains (line 41) | fn contains(&self, elem: &T) -> bool {
  function contains (line 47) | fn contains(&self, elem: &T) -> bool {
  function contains (line 53) | fn contains(&self, elem: &T) -> bool {
  function contains (line 59) | fn contains(&self, elem: &T) -> bool {
  method contains (line 65) | fn contains(&self, _: &T) -> bool {
  method to_str (line 69) | fn to_str(&self) -> &str {
  function contains (line 75) | fn contains(&self, elem: &u8) -> bool {
  function to_str (line 79) | fn to_str(&self) -> &str {
  function one_of_using_set (line 89) | fn one_of_using_set() {
  function one_of_using_range (line 95) | fn one_of_using_range() {
  function one_of_using_range_to (line 102) | fn one_of_using_range_to() {
  function one_of_using_range_inclusive (line 109) | fn one_of_using_range_inclusive() {
  function one_of_using_range_to_inclusive (line 116) | fn one_of_using_range_to_inclusive() {
  function one_of_using_full_range (line 123) | fn one_of_using_full_range() {

FILE: src/utf8.rs
  type Parser (line 16) | pub struct Parser<'a, O>(parser::Parser<'a, u8, O>);
  function new (line 20) | pub fn new<P>(parse: P) -> Self
  function collect (line 29) | pub fn collect(self) -> Parser<'a, &'a str>
  function parse (line 42) | pub fn parse(&self, input: &'a [u8]) -> Result<O> {
  function parse_at (line 47) | pub fn parse_at(&self, input: &'a [u8], start: usize) -> Result<(O, usiz...
  function parse_str (line 52) | pub fn parse_str(&self, input: &'a str) -> Result<O> {
  function map (line 57) | pub fn map<U, F>(self, f: F) -> Parser<'a, U>
  function convert (line 67) | pub fn convert<U, E, F>(self, f: F) -> Parser<'a, U>
  function cache (line 78) | pub fn cache(self) -> Self
  function pos (line 86) | pub fn pos(self) -> Parser<'a, usize>
  function discard (line 94) | pub fn discard(self) -> Parser<'a, ()>
  function opt (line 102) | pub fn opt(self) -> Parser<'a, Option<O>>
  function repeat (line 113) | pub fn repeat<R>(self, range: R) -> Parser<'a, Vec<O>>
  function name (line 122) | pub fn name(self, name: &'a str) -> Self
  function expect (line 130) | pub fn expect(self, name: &'a str) -> Self
  function from (line 139) | fn from(parser: Parser<'a, O>) -> Self {
  function decode (line 144) | pub fn decode(slice: &[u8], start: usize) -> Result<(char, usize)> {
  function no_utf8 (line 153) | fn no_utf8<T>(start: usize, size: usize) -> Result<T> {
  function any (line 166) | pub fn any<'a>() -> Parser<'a, char> {
  function sym (line 175) | pub fn sym<'a>(tag: char) -> Parser<'a, char> {
  function seq (line 190) | pub fn seq<'a, 'b: 'a>(tag_str: &'b str) -> Parser<'a, &'a str> {
  function one_of (line 217) | pub fn one_of<'a, S>(set: &'a S) -> Parser<'a, char>
  function none_of (line 235) | pub fn none_of<'a, S>(set: &'a S) -> Parser<'a, char>
  function is_a (line 253) | pub fn is_a<'a, F>(predicate: F) -> Parser<'a, char>
  function not_a (line 271) | pub fn not_a<'a, F>(predicate: F) -> Parser<'a, char>
  function take (line 289) | pub fn take<'a>(n: usize) -> Parser<'a, &'a str> {
  function skip (line 307) | pub fn skip<'a>(n: usize) -> Parser<'a, ()> {
  function take_bytes (line 322) | pub fn take_bytes<'a>(n: usize) -> Parser<'a, &'a str> {
  function skip_bytes (line 352) | pub fn skip_bytes<'a>(n: usize) -> Parser<'a, ()> {
  type Output (line 377) | type Output = Parser<'a, U>;
  function shr (line 379) | fn shr(self, other: F) -> Self::Output {
  function empty (line 392) | pub fn empty<'a>() -> Parser<'a, ()> {
  function list (line 397) | pub fn list<'a, O, U>(item: Parser<'a, O>, separator: Parser<'a, U>) -> ...
  function call (line 406) | pub fn call<'a, O, F>(parser_factory: F) -> Parser<'a, O>
  function end (line 415) | pub fn end<'a>() -> Parser<'a, ()> {
  type Output (line 476) | type Output = Self;
  method bitor (line 478) | fn bitor(self, other: Self) -> Self {
  type Output (line 485) | type Output = parser::Parser<'a, u8, O>;
  function bitor (line 487) | fn bitor(self, other: parser::Parser<'a, u8, O>) -> Self::Output {
  type Output (line 494) | type Output = parser::Parser<'a, u8, O>;
  function bitor (line 496) | fn bitor(self, other: Parser<'a, O>) -> Self::Output {
  type Output (line 503) | type Output = Parser<'a, bool>;
  method neg (line 505) | fn neg(self) -> Self::Output {
  type Output (line 512) | type Output = Parser<'a, bool>;
  method not (line 514) | fn not(self) -> Self::Output {

FILE: tests/list.rs
  function spaces (line 6) | fn spaces() -> Parser<u8, ()> {
  function works (line 10) | fn works() -> Parser<u8, Vec<u8>> {
  function dangle (line 14) | fn dangle() -> Parser<u8, (Vec<u8>, &'static [u8])> {
  function test_list (line 19) | fn test_list() {