Compiling ufc2 v0.1.0 (/home/sbizna/ufc2)
warning: unused import: `parse::*`
 --> src/lib.rs:6:5
  |
6 | use parse::*;
  |     ^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

error[E0283]: type annotations needed
   --> src/parse.rs:6:24
    |
6   |     let parse_an_int = text::int(10)
    |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
    |
    = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
            - impl<I, S> chumsky::Error<I> for Cheap<I, S>
              where S: Span, S: Clone, S: std::fmt::Debug;
            - impl<I, S> chumsky::Error<I> for Simple<I, S>
              where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
note: required by a bound in `int`
   --> /home/sbizna/.cargo/registry/src/index.crates.io-6f17d22bba15001f/chumsky-0.9.2/src/text.rs:315:29
    |
315 | pub fn int<C: Character, E: Error<C>>(
    |                             ^^^^^^^^ required by this bound in `int`
help: consider specifying the generic arguments
    |
6   |     let parse_an_int = text::int::<char, E>(10)
    |                                 +++++++++++

error[E0283]: type annotations needed
   --> src/parse.rs:6:24
    |
6   |     let parse_an_int = text::int(10)
    |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
7   |         .map(|x: String| -> Ratio { x.parse().unwrap() });
8   |     let parse_a_ratio = text::int(10)
    |                         --------- type must be known at this point
    |
    = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
            - impl<I, S> chumsky::Error<I> for Cheap<I, S>
              where S: Span, S: Clone, S: std::fmt::Debug;
            - impl<I, S> chumsky::Error<I> for Simple<I, S>
              where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
note: required by a bound in `int`
   --> /home/sbizna/.cargo/registry/src/index.crates.io-6f17d22bba15001f/chumsky-0.9.2/src/text.rs:315:29
    |
315 | pub fn int<C: Character, E: Error<C>>(
    |                             ^^^^^^^^ required by this bound in `int`
help: consider specifying the generic arguments
    |
6   |     let parse_an_int = text::int::<char, E>(10)
    |                                 +++++++++++

error[E0283]: type annotations needed
   --> src/parse.rs:6:24
    |
6   |     let parse_an_int = text::int(10)
    |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
...
9   |         .then(just("/"))
    |               ---- type must be known at this point
    |
    = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
            - impl<I, S> chumsky::Error<I> for Cheap<I, S>
              where S: Span, S: Clone, S: std::fmt::Debug;
            - impl<I, S> chumsky::Error<I> for Simple<I, S>
              where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
note: required by a bound in `chumsky::primitive::just`
   --> /home/sbizna/.cargo/registry/src/index.crates.io-6f17d22bba15001f/chumsky-0.9.2/src/primitive.rs:347:43
    |
347 | pub fn just<I, C: OrderedContainer<I>, E: Error<I>>(inputs: C) -> Just<I, C, E> {
    |                                           ^^^^^^^^ required by this bound in `just`
help: consider specifying the generic arguments
    |
6   |     let parse_an_int = text::int::<char, E>(10)
    |                                 +++++++++++

error[E0283]: type annotations needed
   --> src/parse.rs:6:24
    |
6   |     let parse_an_int = text::int(10)
    |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
...
9   |         .then(just("/"))
    |          ---- type must be known at this point
    |
    = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
            - impl<I, S> chumsky::Error<I> for Cheap<I, S>
              where S: Span, S: Clone, S: std::fmt::Debug;
            - impl<I, S> chumsky::Error<I> for Simple<I, S>
              where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
    = note: required for `Just<char, &str, _>` to implement `chumsky::Parser<char, &str>`
note: required by a bound in `then`
   --> /home/sbizna/.cargo/registry/src/index.crates.io-6f17d22bba15001f/chumsky-0.9.2/src/lib.rs:644:12
    |
644 |         P: Parser<I, U, Error = Self::Error>,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Parser::then`
help: consider specifying the generic arguments
    |
6   |     let parse_an_int = text::int::<char, E>(10)
    |                                 +++++++++++

error[E0283]: type annotations needed
  --> src/parse.rs:6:24
   |
6  |     let parse_an_int = text::int(10)
   |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
...
10 |         .then(text::int(10))
   |          ---- type must be known at this point
   |
   = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
           - impl<I, S> chumsky::Error<I> for Cheap<I, S>
             where S: Span, S: Clone, S: std::fmt::Debug;
           - impl<I, S> chumsky::Error<I> for Simple<I, S>
             where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
   = note: required for `Then<impl chumsky::Parser<char, <char as Character>::Collection, Error = _> + Copy + Clone, Just<char, &str, _>>` to implement `chumsky::Parser<char, (std::string::String, &str)>`
help: consider specifying the generic arguments
   |
6  |     let parse_an_int = text::int::<char, E>(10)
   |                                 +++++++++++

error[E0283]: type annotations needed
   --> src/parse.rs:6:24
    |
6   |     let parse_an_int = text::int(10)
    |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
...
10  |         .then(text::int(10))
    |               --------- type must be known at this point
    |
    = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
            - impl<I, S> chumsky::Error<I> for Cheap<I, S>
              where S: Span, S: Clone, S: std::fmt::Debug;
            - impl<I, S> chumsky::Error<I> for Simple<I, S>
              where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
note: required by a bound in `int`
   --> /home/sbizna/.cargo/registry/src/index.crates.io-6f17d22bba15001f/chumsky-0.9.2/src/text.rs:315:29
    |
315 | pub fn int<C: Character, E: Error<C>>(
    |                             ^^^^^^^^ required by this bound in `int`
help: consider specifying the generic arguments
    |
6   |     let parse_an_int = text::int::<char, E>(10)
    |                                 +++++++++++

error[E0283]: type annotations needed
  --> src/parse.rs:6:24
   |
6  |     let parse_an_int = text::int(10)
   |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
...
11 |         .map(|((a, _), b): ((String, _), String)| -> Ratio { (format!("{}/{}", a, b)).parse().unwrap() });
   |          --- type must be known at this point
   |
   = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
           - impl<I, S> chumsky::Error<I> for Cheap<I, S>
             where S: Span, S: Clone, S: std::fmt::Debug;
           - impl<I, S> chumsky::Error<I> for Simple<I, S>
             where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
   = note: required for `Then<Then<impl Parser<char, <char as Character>::Collection, Error = _> + Copy + Clone, ...>, ...>` to implement `chumsky::Parser<char, ((std::string::String, &str), std::string::String)>`
   = note: the full type name has been written to '/home/sbizna/ufc2/target/debug/deps/ufc2-cc7509351e34319b.long-type-14448947526531128519.txt'
help: consider specifying the generic arguments
   |
6  |     let parse_an_int = text::int::<char, E>(10)
   |                                 +++++++++++

error[E0283]: type annotations needed
   --> src/parse.rs:6:24
    |
6   |     let parse_an_int = text::int(10)
    |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
...
12  |     let parse_an_irratio = text::int(10)
    |                            --------- type must be known at this point
    |
    = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
            - impl<I, S> chumsky::Error<I> for Cheap<I, S>
              where S: Span, S: Clone, S: std::fmt::Debug;
            - impl<I, S> chumsky::Error<I> for Simple<I, S>
              where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
note: required by a bound in `int`
   --> /home/sbizna/.cargo/registry/src/index.crates.io-6f17d22bba15001f/chumsky-0.9.2/src/text.rs:315:29
    |
315 | pub fn int<C: Character, E: Error<C>>(
    |                             ^^^^^^^^ required by this bound in `int`
help: consider specifying the generic arguments
    |
6   |     let parse_an_int = text::int::<char, E>(10)
    |                                 +++++++++++

error[E0283]: type annotations needed
   --> src/parse.rs:6:24
    |
6   |     let parse_an_int = text::int(10)
    |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
...
13  |         .then(just("."))
    |               ---- type must be known at this point
    |
    = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
            - impl<I, S> chumsky::Error<I> for Cheap<I, S>
              where S: Span, S: Clone, S: std::fmt::Debug;
            - impl<I, S> chumsky::Error<I> for Simple<I, S>
              where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
note: required by a bound in `chumsky::primitive::just`
   --> /home/sbizna/.cargo/registry/src/index.crates.io-6f17d22bba15001f/chumsky-0.9.2/src/primitive.rs:347:43
    |
347 | pub fn just<I, C: OrderedContainer<I>, E: Error<I>>(inputs: C) -> Just<I, C, E> {
    |                                           ^^^^^^^^ required by this bound in `just`
help: consider specifying the generic arguments
    |
6   |     let parse_an_int = text::int::<char, E>(10)
    |                                 +++++++++++

error[E0283]: type annotations needed
   --> src/parse.rs:6:24
    |
6   |     let parse_an_int = text::int(10)
    |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
...
13  |         .then(just("."))
    |          ---- type must be known at this point
    |
    = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
            - impl<I, S> chumsky::Error<I> for Cheap<I, S>
              where S: Span, S: Clone, S: std::fmt::Debug;
            - impl<I, S> chumsky::Error<I> for Simple<I, S>
              where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
    = note: required for `Just<char, &str, _>` to implement `chumsky::Parser<char, &str>`
note: required by a bound in `then`
   --> /home/sbizna/.cargo/registry/src/index.crates.io-6f17d22bba15001f/chumsky-0.9.2/src/lib.rs:644:12
    |
644 |         P: Parser<I, U, Error = Self::Error>,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Parser::then`
help: consider specifying the generic arguments
    |
6   |     let parse_an_int = text::int::<char, E>(10)
    |                                 +++++++++++

error[E0283]: type annotations needed
  --> src/parse.rs:6:24
   |
6  |     let parse_an_int = text::int(10)
   |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
...
14 |         .then(text::int(10))
   |          ---- type must be known at this point
   |
   = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
           - impl<I, S> chumsky::Error<I> for Cheap<I, S>
             where S: Span, S: Clone, S: std::fmt::Debug;
           - impl<I, S> chumsky::Error<I> for Simple<I, S>
             where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
   = note: required for `Then<impl chumsky::Parser<char, <char as Character>::Collection, Error = _> + Copy + Clone, Just<char, &str, _>>` to implement `chumsky::Parser<char, (std::string::String, &str)>`
help: consider specifying the generic arguments
   |
6  |     let parse_an_int = text::int::<char, E>(10)
   |                                 +++++++++++

error[E0283]: type annotations needed
   --> src/parse.rs:6:24
    |
6   |     let parse_an_int = text::int(10)
    |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
...
14  |         .then(text::int(10))
    |               --------- type must be known at this point
    |
    = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
            - impl<I, S> chumsky::Error<I> for Cheap<I, S>
              where S: Span, S: Clone, S: std::fmt::Debug;
            - impl<I, S> chumsky::Error<I> for Simple<I, S>
              where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
note: required by a bound in `int`
   --> /home/sbizna/.cargo/registry/src/index.crates.io-6f17d22bba15001f/chumsky-0.9.2/src/text.rs:315:29
    |
315 | pub fn int<C: Character, E: Error<C>>(
    |                             ^^^^^^^^ required by this bound in `int`
help: consider specifying the generic arguments
    |
6   |     let parse_an_int = text::int::<char, E>(10)
    |                                 +++++++++++

error[E0283]: type annotations needed
  --> src/parse.rs:6:24
   |
6  |     let parse_an_int = text::int(10)
   |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
...
15 |         .map(|((a, _), b): ((String, _), String)| -> Ratio { (format!("{}.{}", a, b)).parse().unwrap() });
   |          --- type must be known at this point
   |
   = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
           - impl<I, S> chumsky::Error<I> for Cheap<I, S>
             where S: Span, S: Clone, S: std::fmt::Debug;
           - impl<I, S> chumsky::Error<I> for Simple<I, S>
             where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
   = note: required for `Then<Then<impl Parser<char, <char as Character>::Collection, Error = _> + Copy + Clone, ...>, ...>` to implement `chumsky::Parser<char, ((std::string::String, &str), std::string::String)>`
   = note: the full type name has been written to '/home/sbizna/ufc2/target/debug/deps/ufc2-cc7509351e34319b.long-type-16323211740405100899.txt'
help: consider specifying the generic arguments
   |
6  |     let parse_an_int = text::int::<char, E>(10)
   |                                 +++++++++++

error[E0283]: type annotations needed
  --> src/parse.rs:6:24
   |
6  |     let parse_an_int = text::int(10)
   |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
...
16 |     parse_an_irratio.or(parse_a_ratio).or(parse_an_int)
   |                      -- type must be known at this point
   |
   = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
           - impl<I, S> chumsky::Error<I> for Cheap<I, S>
             where S: Span, S: Clone, S: std::fmt::Debug;
           - impl<I, S> chumsky::Error<I> for Simple<I, S>
             where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
   = note: required for `Map<Then<Then<impl Parser<char, ..., Error = ...> + Copy + Clone, ...>, ...>, ..., ...>` to implement `chumsky::Parser<char, ratio::Ratio>`
   = note: the full type name has been written to '/home/sbizna/ufc2/target/debug/deps/ufc2-cc7509351e34319b.long-type-14890904207767287720.txt'
help: consider specifying the generic arguments
   |
6  |     let parse_an_int = text::int::<char, E>(10)
   |                                 +++++++++++

error[E0283]: type annotations needed
  --> src/parse.rs:6:24
   |
6  |     let parse_an_int = text::int(10)
   |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
...
16 |     parse_an_irratio.or(parse_a_ratio).or(parse_an_int)
   |                                        -- type must be known at this point
   |
   = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
           - impl<I, S> chumsky::Error<I> for Cheap<I, S>
             where S: Span, S: Clone, S: std::fmt::Debug;
           - impl<I, S> chumsky::Error<I> for Simple<I, S>
             where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
   = note: required for `Or<Map<Then<Then<impl Parser<char, ..., Error = ...> + Copy + Clone, ...>, ...>, ..., ...>, ...>` to implement `chumsky::Parser<char, ratio::Ratio>`
   = note: the full type name has been written to '/home/sbizna/ufc2/target/debug/deps/ufc2-cc7509351e34319b.long-type-9773343675727782312.txt'
help: consider specifying the generic arguments
   |
6  |     let parse_an_int = text::int::<char, E>(10)
   |                                 +++++++++++

error[E0283]: type annotations needed
 --> src/parse.rs:6:24
  |
5 | fn positive_ratio_parser() -> impl Parser<char, Ratio> {
  |                               ------------------------ type must be known at this point
6 |     let parse_an_int = text::int(10)
  |                        ^^^^^^^^^ cannot infer type of the type parameter `E` declared on the function `int`
  |
  = note: multiple `impl`s satisfying `_: chumsky::Error<char>` found in the `chumsky` crate:
          - impl<I, S> chumsky::Error<I> for Cheap<I, S>
            where S: Span, S: Clone, S: std::fmt::Debug;
          - impl<I, S> chumsky::Error<I> for Simple<I, S>
            where I: Hash, I: Eq, S: Span, S: Clone, S: std::fmt::Debug;
  = note: required for `Or<Or<Map<Then<Then<impl Parser<char, ..., Error = ...> + Copy + Clone, ...>, ...>, ..., ...>, ...>, ...>` to implement `chumsky::Parser<char, ratio::Ratio>`
  = note: the full type name has been written to '/home/sbizna/ufc2/target/debug/deps/ufc2-cc7509351e34319b.long-type-10629349324102940954.txt'
help: consider specifying the generic arguments
  |
6 |     let parse_an_int = text::int::<char, E>(10)
  |                                 +++++++++++

For more information about this error, try `rustc --explain E0283`.
warning: `ufc2` (lib) generated 1 warning
error: could not compile `ufc2` (lib) due to 16 previous errors; 1 warning emitted