Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Undocumented nom 5.0 functions #915

Closed
lu-zero opened this issue Apr 22, 2019 · 5 comments
Closed

Undocumented nom 5.0 functions #915

lu-zero opened this issue Apr 22, 2019 · 5 comments

Comments

@lu-zero
Copy link
Contributor

lu-zero commented Apr 22, 2019

Here the list of all the functions missing documentation helpfully split per-file.

(I let @Geal format/split it further)

  • src/branch/mod.rs
    • src/branch/mod.rs:pub fn or<I: Clone, O, E: ParseError<I>, F, G>(f: F, g: G) -> impl Fn(I) -> IResult<I, O, E>
    • src/branch/mod.rs:pub fn alt<I: Clone, O, E: ParseError<I>, List: Alt<I,O,E>>(l: List) -> impl Fn(I) -> IResult<I, O, E> {
  • src/bytes/complete.rs
    • src/bytes/complete.rs:pub fn tag<'a, T: 'a, Input:'a, Error: ParseError<Input>>(tag: T) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/complete.rs:pub fn tag_no_case<T, Input, Error: ParseError<Input>>(tag: T) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/complete.rs:pub fn is_not<T, Input, Error: ParseError<Input>>(arr: T) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/complete.rs:pub fn is_a<T, Input, Error: ParseError<Input>>(arr: T) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/complete.rs:pub fn take_while<F, Input, Error: ParseError<Input>>(cond: F) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/complete.rs:pub fn take_while1<F, Input, Error: ParseError<Input>>(cond: F) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/complete.rs:pub fn take_while_m_n<F, Input, Error: ParseError<Input>>(m: usize, n: usize, cond: F) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/complete.rs:pub fn take_till<F, Input, Error: ParseError<Input>>(cond: F) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/complete.rs:pub fn take_till1<F, Input, Error: ParseError<Input>>(cond: F) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/complete.rs:pub fn take<C, Input, Error: ParseError<Input>>(count: C) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/complete.rs:pub fn take_until<T, Input, Error: ParseError<Input>>(tag: T) -> impl Fn(Input) -> IResult<Input, Input, Error>
  • src/bytes/streaming.rs
    • src/bytes/streaming.rs:pub fn tag<'a, T: 'a, Input:'a, Error: ParseError<Input>>(tag: T) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/streaming.rs:pub fn tag_no_case<T, Input, Error: ParseError<Input>>(tag: T) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/streaming.rs:pub fn is_not<T, Input, Error: ParseError<Input>>(arr: T) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/streaming.rs:pub fn is_a<T, Input, Error: ParseError<Input>>(arr: T) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/streaming.rs:pub fn take_while<F, Input, Error: ParseError<Input>>(cond: F) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/streaming.rs:pub fn take_while1<F, Input, Error: ParseError<Input>>(cond: F) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/streaming.rs:pub fn take_while_m_n<F, Input, Error: ParseError<Input>>(m: usize, n: usize, cond: F) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/streaming.rs:pub fn take_till<F, Input, Error: ParseError<Input>>(cond: F) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/streaming.rs:pub fn take_till1<F, Input, Error: ParseError<Input>>(cond: F) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/streaming.rs:pub fn take<C, Input, Error: ParseError<Input>>(count: C) -> impl Fn(Input) -> IResult<Input, Input, Error>
    • src/bytes/streaming.rs:pub fn take_until<T, Input, Error: ParseError<Input>>(tag: T) -> impl Fn(Input) -> IResult<Input, Input, Error>
  • src/combinator/macros.rs
    • src/combinator/macros.rs: pub fn $name( i: $i ) -> $crate::IResult<$i,$o, ($i, $crate::error::ErrorKind)> {
    • src/combinator/macros.rs: pub fn $name( i: $i ) -> $crate::IResult<$i, $o, $e> {
    • src/combinator/macros.rs: pub fn $name( i: $i ) -> $crate::IResult<$i, $o, ($i, $crate::error::ErrorKind)> {
    • src/combinator/macros.rs: pub fn $name( i: &[u8] ) -> $crate::IResult<&[u8], $o, (&[u8], $crate::error::ErrorKind)> {
    • src/combinator/macros.rs: pub fn $name( i: &[u8] ) -> $crate::IResult<&[u8], &[u8], (&[u8], $crate::error::ErrorKind)> {
    • src/combinator/macros.rs: pub fn $func_name(input: &[u8], $( $arg : $typ ),*) -> $crate::IResult<&[u8], $return_type> {
    • src/combinator/macros.rs: pub fn $func_name<'this_is_probably_unique_i_hope_please, 'a>(
    • src/combinator/macros.rs: pub fn $func_name(input: $input_type, $( $arg : $typ ),*) -> $crate::IResult<$input_type, $return_type> {
    • src/combinator/macros.rs: pub fn $func_name<'a>(
    • src/combinator/macros.rs: pub fn $name( i: $i ) -> $crate::IResult<$i,$o, ($i, $crate::error::ErrorKind)> {
    • src/combinator/macros.rs: pub fn $name( i: $i ) -> $crate::IResult<$i, $o, $e> {
    • src/combinator/macros.rs: pub fn $name( i: $i ) -> $crate::IResult<$i, $o, ($i, $crate::error::ErrorKind)> {
    • src/combinator/macros.rs: pub fn $name<'a>( i: &'a[u8] ) -> $crate::IResult<&'a[u8], $o, (&'a[u8], $crate::error::ErrorKind)> {
    • src/combinator/macros.rs: pub fn $name<'a>( i: &'a [u8] ) -> $crate::IResult<&'a[u8], &'a[u8], (&'a[u8], $crate::error::ErrorKind)> {
    • src/combinator/macros.rs: pub fn _unify<T, R, F: FnOnce(T) -> R>(f: F, t: T) -> R {
  • src/combinator/mod.rs
    • src/combinator/mod.rs:pub fn tag_cl<'a, 'b>(rec: &'a [u8]) -> Box<Fn(&'b [u8]) -> IResult<&'b [u8], &'b [u8]> + 'a> {
    • src/combinator/mod.rs:pub fn print<T: Debug>(input: T) -> IResult<T, ()> {
    • src/combinator/mod.rs:pub fn begin(input: &[u8]) -> IResult<(), &[u8]> {
    • src/combinator/mod.rs:pub fn sized_buffer<'a, E: ParseError<&'a[u8]>>(input: &'a[u8]) -> IResult<&'a[u8], &'a[u8], E> {
    • src/combinator/mod.rs:pub fn map<I, O1, O2, E: ParseError<I>, F, G>(first: F, second: G) -> impl Fn(I) -> IResult<I, O2, E>
    • src/combinator/mod.rs:pub fn map_res<I: Clone, O1, O2, E: ParseError<I>, E2, F, G>(first: F, second: G) -> impl Fn(I) -> IResult<I, O2, E>
    • src/combinator/mod.rs:pub fn opt<I:Clone, O, E: ParseError<I>, F>(f: F) -> impl Fn(I) -> IResult<I, Option<O>, E>
  • src/error.rs
    • src/error.rs:pub fn make_error<I, E: ParseError<I>>(input: I, kind: ErrorKind) -> E {
    • src/error.rs:pub fn append_error<I, E: ParseError<I>>(input: I, kind: ErrorKind, other: E) -> E {
    • src/error.rs:pub fn context<I: Clone, E: ParseError<I>, F, O>(context: &'static str, f: F) -> impl FnOnce(I) -> IResult<I, O, E>
    • src/error.rs:pub fn error_to_u32(e: &ErrorKind) -> u32 {
    • src/error.rs: pub fn description(&self) -> &str {
  • src/internal.rs
    • src/internal.rs: pub fn is_known(&self) -> bool {
  • src/multi/macros.rs
    • src/multi/macros.rs: pub fn compile_count_fixed(input: &[u8]) -> IResult<&[u8], ()> {
  • src/multi/mod.rs
    • src/multi/mod.rs:pub fn many0<I, O, E, F>(f: F) -> impl Fn(I) -> IResult<I, Vec<O>, E>
    • src/multi/mod.rs:pub fn many0c<I, O, E, F>(input: I, f: F) -> IResult<I, Vec<O>, E>
    • src/multi/mod.rs:pub fn many1<I, O, E, F>(f: F) -> impl Fn(I) -> IResult<I, Vec<O>, E>
    • src/multi/mod.rs:pub fn many1c<I, O, E, F>(input: I, f: F) -> IResult<I, Vec<O>, E>
    • src/multi/mod.rs:pub fn many_tillc<I, O, P, E, F, G>(i: I, f: F, g: G) -> IResult<I, (Vec<O>, P), E>
    • src/multi/mod.rs:pub fn separated_list<I, O, O2, E, F, G>(sep: G, f: F) -> impl Fn(I) -> IResult<I, Vec<O>, E>
    • src/multi/mod.rs:pub fn separated_listc<I, O, O2, E, F, G>(i: I, sep: G, f: F) -> IResult<I, Vec<O>, E>
    • src/multi/mod.rs:pub fn separated_nonempty_list<I, O, O2, E, F, G>(sep: G, f: F) -> impl Fn(I) -> IResult<I, Vec<O>, E>
    • src/multi/mod.rs:pub fn separated_nonempty_listc<I, O, O2, E, F, G>(i: I, sep: G, f: F) -> IResult<I, Vec<O>, E>
    • src/multi/mod.rs:pub fn many_m_n<I, O, E, F>(m: usize, n: usize, f: F) -> impl Fn(I) -> IResult<I, Vec<O>, E>
    • src/multi/mod.rs:pub fn many_m_nc<I, O, E, F>(i: I, m: usize, n: usize, f: F) -> IResult<I, Vec<O>, E>
    • src/multi/mod.rs:pub fn many0_countc<I, O, E, F>(i: I, f: F) -> IResult<I, usize, E>
    • src/multi/mod.rs:pub fn many1_countc<I, O, E, F>(i: I, f: F) -> IResult<I, usize, E>
    • src/multi/mod.rs:pub fn fold_many0c<I, O, E, F, G, R>(i: I, f: F, init: R, g: G) -> IResult<I, R, E>
    • src/multi/mod.rs:pub fn fold_many1c<I, O, E, F, G, R>(i: I, f: F, init: R, g: G) -> IResult<I, R, E>
    • src/multi/mod.rs:pub fn fold_many_m_nc<I, O, E, F, G, R>(i: I, m: usize, n: usize, f: F, init: R, g: G) -> IResult<I, R, E>
    • src/multi/mod.rs:pub fn length_value<I, O, N, E, F, G>(f: F, g: G) -> impl Fn(I) -> IResult<I, O, E>
    • src/multi/mod.rs:pub fn length_valuec<I, O, N, E, F, G>(i: I, f: F, g: G) -> IResult<I, O, E>
  • src/number/complete.rs
    • src/number/complete.rs:pub fn be_u16<'a, E: ParseError<&'a[u8]>>(i: &'a[u8]) -> IResult<&'a[u8], u16, E> {
    • src/number/complete.rs:pub fn be_u128<'a, E: ParseError<&'a[u8]>>(i: &'a[u8]) -> IResult<&'a[u8], u128, E> {
    • src/number/complete.rs:pub fn be_i128<'a, E: ParseError<&'a [u8]>>(i: &'a[u8]) -> IResult<&'a[u8], i128, E> {
    • src/number/complete.rs:pub fn le_u128<'a, E: ParseError<&'a [u8]>>(i: &'a[u8]) -> IResult<&'a[u8], u128, E> {
    • src/number/complete.rs:pub fn le_i128<'a, E: ParseError<&'a [u8]>>(i: &'a[u8]) -> IResult<&'a[u8], i128, E> {
    • src/number/complete.rs:pub fn recognize_float<T, E:ParseError<T>>(input: T) -> IResult<T, T, E>
  • src/number/streaming.rs
    • src/number/streaming.rs:pub fn be_u128<'a, E: ParseError<&'a[u8]>>(i: &'a[u8]) -> IResult<&'a[u8], u128, E> {
    • src/number/streaming.rs:pub fn be_i128<'a, E: ParseError<&'a [u8]>>(i: &'a[u8]) -> IResult<&'a[u8], i128, E> {
    • src/number/streaming.rs:pub fn le_u128<'a, E: ParseError<&'a [u8]>>(i: &'a[u8]) -> IResult<&'a[u8], u128, E> {
    • src/number/streaming.rs:pub fn le_i128<'a, E: ParseError<&'a [u8]>>(i: &'a[u8]) -> IResult<&'a[u8], i128, E> {
    • src/number/streaming.rs:pub fn recognize_float<T, E:ParseError<T>>(input: T) -> IResult<T, T, E>
  • src/sequence/mod.rs
    • src/sequence/mod.rs:pub fn pair<I, O1, O2, E: ParseError<I>, F, G>(first: F, second: G) -> impl Fn(I) -> IResult<I, (O1, O2), E>
    • src/sequence/mod.rs:pub fn pairc<I, O1, O2, E: ParseError<I>, F, G>(input: I, first: F, second: G) -> IResult<I, (O1, O2), E>
    • src/sequence/mod.rs:pub fn preceded<I, O1, O2, E: ParseError<I>, F, G>(first: F, second: G) -> impl Fn(I) -> IResult<I, O2, E>
    • src/sequence/mod.rs:pub fn precededc<I, O1, O2, E: ParseError<I>, F, G>(input: I, first: F, second: G) -> IResult<I, O2, E>
    • src/sequence/mod.rs:pub fn terminated<I, O1, O2, E: ParseError<I>, F, G>(first: F, second: G) -> impl Fn(I) -> IResult<I, O1, E>
    • src/sequence/mod.rs:pub fn terminatedc<I, O1, O2, E: ParseError<I>, F, G>(input: I, first: F, second: G) -> IResult<I, O1, E>
    • src/sequence/mod.rs:pub fn separated_pair<I, O1, O2, O3, E: ParseError<I>, F, G, H>(first: F, sep: G, second: H) -> impl Fn(I) -> IResult<I, (O1, O3), E>
    • src/sequence/mod.rs:pub fn separated_pairc<I, O1, O2, O3, E: ParseError<I>, F, G, H>(input: I, first: F, sep: G, second: H) -> IResult<I, (O1, O3), E>
    • src/sequence/mod.rs:pub fn delimited<I, O1, O2, O3, E: ParseError<I>, F, G, H>(first: F, sep: G, second: H) -> impl Fn(I) -> IResult<I, O2, E>
    • src/sequence/mod.rs:pub fn delimitedc<I, O1, O2, O3, E: ParseError<I>, F, G, H>(input: I, first: F, sep: G, second: H) -> IResult<I, O2, E>
    • src/sequence/mod.rs:pub fn tuple<I: Clone, O, E: ParseError<I>, List: Tuple<I,O,E>>(l: List) -> impl Fn(I) -> IResult<I, O, E> {
  • src/str.rs
    • src/str.rs: pub fn is_alphabetic(c: char) -> bool {
  • src/traits.rs
    • src/traits.rs:pub fn need_more<I: AtEof, O, E: ParseError<I>>(input: I, needed: Needed) -> IResult<I, O, E> {
    • src/traits.rs:pub fn need_more_err<I: AtEof, O, E: ParseError<I>>(input: I, needed: Needed, err: ErrorKind) -> IResult<I, O, E> {
  • src/util.rs
    • src/util.rs:pub fn error_to_list<P: Clone, E: Clone>(e: &Context<P, E>) -> Vec<(P, ErrorKind<E>)> {
    • src/util.rs:pub fn compare_error_paths<P: Clone + PartialEq, E: Clone + PartialEq>(e1: &Context<P, E>, e2: &Context<P, E>) -> bool {
    • src/util.rs:pub fn add_error_pattern<'a, I: Clone + Hash + Eq, O, E: Clone + Hash + Eq>(
    • src/util.rs:pub fn slice_to_offsets(input: &[u8], s: &[u8]) -> (usize, usize) {
    • src/util.rs:pub fn prepare_errors<O, E: Clone>(input: &[u8], res: IResult<&[u8], O, E>) -> Option<Vec<(ErrorKind<E>, usize, usize)>> {
    • src/util.rs:pub fn print_error<O, E: Clone>(input: &[u8], res: IResult<&[u8], O, E>) {
    • src/util.rs:pub fn generate_colors<E>(v: &[(ErrorKind<E>, usize, usize)]) -> HashMap<u32, u8> {
    • src/util.rs:pub fn code_from_offset(v: &[(ErrorKind, usize, usize)], offset: usize) -> Option<u32> {
    • src/util.rs:pub fn reset_color(v: &mut Vec<u8>) {
    • src/util.rs:pub fn write_color(v: &mut Vec<u8>, color: u8) {
    • src/util.rs:pub fn print_codes(colors: &HashMap<u32, u8>, names: &HashMap<u32, &str>) -> String {
    • src/util.rs:pub fn print_offsets<E>(input: &[u8], from: usize, offsets: &[(ErrorKind<E>, usize, usize)]) -> String {
  • src/whitespace.rs
    • src/whitespace.rs:pub fn sp<'a, T>(input: T) -> IResult<T, T>
@NamsooCho
Copy link
Contributor

NamsooCho commented Apr 28, 2019

I would like to work on src/multi/mod.rs.(to avoid redundant contributing)
and also src/number/complete.rs, src/number/streaming.rs.

@NamsooCho
Copy link
Contributor

src/number/complete.rs, src/number/streaming.rs functions are very obvious to use.
I wonder it is needed to provide an example.
@Geal How do you think about providing examples to these functions.
Instead I am working on src/sequence/mod.rs.

@Geal
Copy link
Collaborator

Geal commented May 1, 2019

awesome, thank you for your help :)
I think we'll need examples for numbers as well, mainly because of the difference between complete and streaming. Like, for float parsers the expected behaviour is quite different

@Geal
Copy link
Collaborator

Geal commented May 1, 2019

branch functions documentation is done (removed or, added permutation)

@Geal
Copy link
Collaborator

Geal commented May 1, 2019

I went through the list, a few of those did not need to be documented, so there's actually a bit less to do :)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

No branches or pull requests

3 participants