diff --git a/benchmarks/benches/json.rs b/benchmarks/benches/json.rs
index 3d4f44a74..6eda885ac 100644
--- a/benchmarks/benches/json.rs
+++ b/benchmarks/benches/json.rs
@@ -95,7 +95,9 @@ fn string(input: &str) -> IResult<&str, String> {
   )(input)
 }
 
-fn ws<'a, O, E: ParseError<&'a str>, F: Parser<&'a str, O, E>>(f: F) -> impl Parser<&'a str, O, E> {
+fn ws<'a, O, E: ParseError<&'a str>, F: Parser<&'a str, Output = O, Error = E>>(
+  f: F,
+) -> impl Parser<&'a str, Output = O, Error = E> {
   delimited(multispace0, f, multispace0)
 }
 
diff --git a/benchmarks/benches/json_streaming.rs b/benchmarks/benches/json_streaming.rs
index 57cc618f3..36b33d85c 100644
--- a/benchmarks/benches/json_streaming.rs
+++ b/benchmarks/benches/json_streaming.rs
@@ -95,7 +95,9 @@ fn string(input: &str) -> IResult<&str, String> {
   )(input)
 }
 
-fn ws<'a, O, E: ParseError<&'a str>, F: Parser<&'a str, O, E>>(f: F) -> impl Parser<&'a str, O, E> {
+fn ws<'a, O, E: ParseError<&'a str>, F: Parser<&'a str, Output = O, Error = E>>(
+  f: F,
+) -> impl Parser<&'a str, Output = O, Error = E> {
   delimited(multispace0, f, multispace0)
 }
 
diff --git a/examples/s_expression.rs b/examples/s_expression.rs
index be2398437..65b6b6df6 100644
--- a/examples/s_expression.rs
+++ b/examples/s_expression.rs
@@ -154,7 +154,7 @@ fn parse_constant(i: &str) -> IResult<&str, Expr, VerboseError<&str>> {
 /// takes a parsing function and returns a new parsing function.
 fn s_exp<'a, O1, F>(inner: F) -> impl FnMut(&'a str) -> IResult<&'a str, O1, VerboseError<&'a str>>
 where
-  F: Parser<&'a str, O1, VerboseError<&'a str>>,
+  F: Parser<&'a str, Output = O1, Error = VerboseError<&'a str>>,
 {
   delimited(
     char('('),
diff --git a/src/bits/mod.rs b/src/bits/mod.rs
index 7f59b1399..f120cb353 100644
--- a/src/bits/mod.rs
+++ b/src/bits/mod.rs
@@ -41,7 +41,7 @@ where
   E1: ParseError<(I, usize)> + ErrorConvert<E2>,
   E2: ParseError<I>,
   I: Input,
-  P: Parser<(I, usize), O, E1>,
+  P: Parser<(I, usize), Output = O, Error = E1>,
 {
   move |input: I| match parser.parse((input, 0)) {
     Ok(((rest, offset), result)) => {
@@ -86,7 +86,7 @@ where
   E1: ParseError<I> + ErrorConvert<E2>,
   E2: ParseError<(I, usize)>,
   I: Input + Clone,
-  P: Parser<I, O, E1>,
+  P: Parser<I, Output = O, Error = E1>,
 {
   move |(input, offset): (I, usize)| {
     let inner = if offset % 8 != 0 {
diff --git a/src/branch/mod.rs b/src/branch/mod.rs
index e03622cb0..7011ea50f 100644
--- a/src/branch/mod.rs
+++ b/src/branch/mod.rs
@@ -128,7 +128,7 @@ macro_rules! alt_trait_impl(
   ($($id:ident)+) => (
     impl<
       Input: Clone, Output, Error: ParseError<Input>,
-      $($id: Parser<Input, Output, Error>),+
+      $($id: Parser<Input, Output = Output, Error = Error>),+
     > Alt<Input, Output, Error> for ( $($id),+ ) {
 
       fn choice(&mut self, input: Input) -> IResult<Input, Output, Error> {
@@ -159,7 +159,7 @@ macro_rules! alt_trait_inner(
 alt_trait!(A B C D E F G H I J K L M N O P Q R S T U);
 
 // Manually implement Alt for (A,), the 1-tuple type
-impl<Input, Output, Error: ParseError<Input>, A: Parser<Input, Output, Error>>
+impl<Input, Output, Error: ParseError<Input>, A: Parser<Input, Output = Output, Error = Error>>
   Alt<Input, Output, Error> for (A,)
 {
   fn choice(&mut self, input: Input) -> IResult<Input, Output, Error> {
@@ -191,7 +191,7 @@ macro_rules! permutation_trait_impl(
   ($($name:ident $ty:ident $item:ident),+) => (
     impl<
       Input: Clone, $($ty),+ , Error: ParseError<Input>,
-      $($name: Parser<Input, $ty, Error>),+
+      $($name: Parser<Input, Output = $ty, Error = Error>),+
     > Permutation<Input, ( $($ty),+ ), Error> for ( $($name),+ ) {
 
       fn permutation(&mut self, mut input: Input) -> IResult<Input, ( $($ty),+ ), Error> {
diff --git a/src/bytes/complete.rs b/src/bytes/complete.rs
index 00a76e544..d70cddb06 100644
--- a/src/bytes/complete.rs
+++ b/src/bytes/complete.rs
@@ -483,7 +483,7 @@ where
 /// assert_eq!(esc(r#"12\"34;"#), Ok((";", r#"12\"34"#)));
 /// ```
 ///
-pub fn escaped<'a, I: 'a, Error, F, G, O1, O2>(
+pub fn escaped<'a, I: 'a, Error, F, G>(
   mut normal: F,
   control_char: char,
   mut escapable: G,
@@ -491,8 +491,8 @@ pub fn escaped<'a, I: 'a, Error, F, G, O1, O2>(
 where
   I: Clone + crate::traits::Offset + Input,
   <I as Input>::Item: crate::traits::AsChar,
-  F: Parser<I, O1, Error>,
-  G: Parser<I, O2, Error>,
+  F: Parser<I, Error = Error>,
+  G: Parser<I, Error = Error>,
   Error: ParseError<I>,
 {
   use crate::traits::AsChar;
@@ -602,8 +602,8 @@ where
   O1: crate::traits::ExtendInto<Item = ExtendItem, Extender = Output>,
   O2: crate::traits::ExtendInto<Item = ExtendItem, Extender = Output>,
   <I as Input>::Item: crate::traits::AsChar,
-  F: Parser<I, O1, Error>,
-  G: Parser<I, O2, Error>,
+  F: Parser<I, Output = O1, Error = Error>,
+  G: Parser<I, Output = O2, Error = Error>,
   Error: ParseError<I>,
 {
   use crate::traits::AsChar;
diff --git a/src/bytes/streaming.rs b/src/bytes/streaming.rs
index 465860ba1..00bf3f228 100644
--- a/src/bytes/streaming.rs
+++ b/src/bytes/streaming.rs
@@ -499,7 +499,7 @@ where
 /// assert_eq!(esc("12\\\"34;"), Ok((";", "12\\\"34")));
 /// ```
 ///
-pub fn escaped<I, Error, F, G, O1, O2>(
+pub fn escaped<I, Error, F, G>(
   mut normal: F,
   control_char: char,
   mut escapable: G,
@@ -507,8 +507,8 @@ pub fn escaped<I, Error, F, G, O1, O2>(
 where
   I: Input + Clone + crate::traits::Offset,
   <I as Input>::Item: crate::traits::AsChar,
-  F: Parser<I, O1, Error>,
-  G: Parser<I, O2, Error>,
+  F: Parser<I, Error = Error>,
+  G: Parser<I, Error = Error>,
   Error: ParseError<I>,
 {
   use crate::traits::AsChar;
@@ -606,8 +606,8 @@ where
   O1: crate::traits::ExtendInto<Item = ExtendItem, Extender = Output>,
   O2: crate::traits::ExtendInto<Item = ExtendItem, Extender = Output>,
   <I as Input>::Item: crate::traits::AsChar,
-  F: Parser<I, O1, Error>,
-  G: Parser<I, O2, Error>,
+  F: Parser<I, Output = O1, Error = Error>,
+  G: Parser<I, Output = O2, Error = Error>,
   Error: ParseError<I>,
 {
   use crate::traits::AsChar;
diff --git a/src/combinator/mod.rs b/src/combinator/mod.rs
index 8b43b91dc..4810568e3 100644
--- a/src/combinator/mod.rs
+++ b/src/combinator/mod.rs
@@ -69,10 +69,10 @@ where
 /// assert_eq!(parser.parse("abc"), Err(Err::Error(("abc", ErrorKind::Digit))));
 /// # }
 /// ```
-pub fn map<I, O1, O2, E, F, G>(mut parser: F, mut f: G) -> impl FnMut(I) -> IResult<I, O2, E>
+pub fn map<I, O, E, F, G>(mut parser: F, mut f: G) -> impl FnMut(I) -> IResult<I, O, E>
 where
-  F: Parser<I, O1, E>,
-  G: FnMut(O1) -> O2,
+  F: Parser<I, Error = E>,
+  G: FnMut(<F as Parser<I>>::Output) -> O,
 {
   move |input: I| {
     let (input, o1) = parser.parse(input)?;
@@ -100,13 +100,13 @@ where
 /// assert_eq!(parse("123456"), Err(Err::Error(("123456", ErrorKind::MapRes))));
 /// # }
 /// ```
-pub fn map_res<I: Clone, O1, O2, E: FromExternalError<I, E2>, E2, F, G>(
+pub fn map_res<I: Clone, O, E: FromExternalError<I, E2>, E2, F, G>(
   mut parser: F,
   mut f: G,
-) -> impl FnMut(I) -> IResult<I, O2, E>
+) -> impl FnMut(I) -> IResult<I, O, E>
 where
-  F: Parser<I, O1, E>,
-  G: FnMut(O1) -> Result<O2, E2>,
+  F: Parser<I, Error = E>,
+  G: FnMut(<F as Parser<I>>::Output) -> Result<O, E2>,
 {
   move |input: I| {
     let i = input.clone();
@@ -138,13 +138,13 @@ where
 /// assert_eq!(parse("123456"), Err(Err::Error(("123456", ErrorKind::MapOpt))));
 /// # }
 /// ```
-pub fn map_opt<I: Clone, O1, O2, E: ParseError<I>, F, G>(
+pub fn map_opt<I: Clone, O, E: ParseError<I>, F, G>(
   mut parser: F,
   mut f: G,
-) -> impl FnMut(I) -> IResult<I, O2, E>
+) -> impl FnMut(I) -> IResult<I, O, E>
 where
-  F: Parser<I, O1, E>,
-  G: FnMut(O1) -> Option<O2>,
+  F: Parser<I, Error = E>,
+  G: FnMut(<F as Parser<I>>::Output) -> Option<O>,
 {
   move |input: I| {
     let i = input.clone();
@@ -172,13 +172,13 @@ where
 /// assert_eq!(parse("123"), Err(Err::Error(("123", ErrorKind::Eof))));
 /// # }
 /// ```
-pub fn map_parser<I, O1, O2, E: ParseError<I>, F, G>(
+pub fn map_parser<I, O, E: ParseError<I>, F, G>(
   mut parser: F,
   mut applied_parser: G,
-) -> impl FnMut(I) -> IResult<I, O2, E>
+) -> impl FnMut(I) -> IResult<I, O, E>
 where
-  F: Parser<I, O1, E>,
-  G: Parser<O1, O2, E>,
+  F: Parser<I, Error = E>,
+  G: Parser<<F as Parser<I>>::Output, Output = O, Error = E>,
 {
   move |input: I| {
     let (input, o1) = parser.parse(input)?;
@@ -202,14 +202,14 @@ where
 /// assert_eq!(parse(&[4, 0, 1, 2][..]), Err(Err::Error((&[0, 1, 2][..], ErrorKind::Eof))));
 /// # }
 /// ```
-pub fn flat_map<I, O1, O2, E: ParseError<I>, F, G, H>(
+pub fn flat_map<I, O, E: ParseError<I>, F, G, H>(
   mut parser: F,
   mut applied_parser: G,
-) -> impl FnMut(I) -> IResult<I, O2, E>
+) -> impl FnMut(I) -> IResult<I, O, E>
 where
-  F: Parser<I, O1, E>,
-  G: FnMut(O1) -> H,
-  H: Parser<I, O2, E>,
+  F: Parser<I, Error = E>,
+  G: FnMut(<F as Parser<I>>::Output) -> H,
+  H: Parser<I, Output = O, Error = E>,
 {
   move |input: I| {
     let (input, o1) = parser.parse(input)?;
@@ -235,9 +235,11 @@ where
 /// assert_eq!(parser("123;"), Ok(("123;", None)));
 /// # }
 /// ```
-pub fn opt<I: Clone, O, E: ParseError<I>, F>(mut f: F) -> impl FnMut(I) -> IResult<I, Option<O>, E>
+pub fn opt<I: Clone, E: ParseError<I>, F>(
+  mut f: F,
+) -> impl FnMut(I) -> IResult<I, Option<<F as Parser<I>>::Output>, E>
 where
-  F: Parser<I, O, E>,
+  F: Parser<I, Error = E>,
 {
   move |input: I| {
     let i = input.clone();
@@ -267,12 +269,12 @@ where
 /// assert_eq!(parser(false, "123;"), Ok(("123;", None)));
 /// # }
 /// ```
-pub fn cond<I, O, E: ParseError<I>, F>(
+pub fn cond<I, E: ParseError<I>, F>(
   b: bool,
   mut f: F,
-) -> impl FnMut(I) -> IResult<I, Option<O>, E>
+) -> impl FnMut(I) -> IResult<I, Option<<F as Parser<I>>::Output>, E>
 where
-  F: Parser<I, O, E>,
+  F: Parser<I, Error = E>,
 {
   move |input: I| {
     if b {
@@ -300,9 +302,11 @@ where
 /// assert_eq!(parser("123;"), Err(Err::Error(("123;", ErrorKind::Alpha))));
 /// # }
 /// ```
-pub fn peek<I: Clone, O, E: ParseError<I>, F>(mut f: F) -> impl FnMut(I) -> IResult<I, O, E>
+pub fn peek<I: Clone, E: ParseError<I>, F>(
+  mut f: F,
+) -> impl FnMut(I) -> IResult<I, <F as Parser<I>>::Output, E>
 where
-  F: Parser<I, O, E>,
+  F: Parser<I, Error = E>,
 {
   move |input: I| {
     let i = input.clone();
@@ -354,7 +358,7 @@ pub fn eof<I: InputLength + Clone, E: ParseError<I>>(input: I) -> IResult<I, I,
 /// ```
 pub fn complete<I: Clone, O, E: ParseError<I>, F>(mut f: F) -> impl FnMut(I) -> IResult<I, O, E>
 where
-  F: Parser<I, O, E>,
+  F: Parser<I, Output = O, Error = E>,
 {
   move |input: I| {
     let i = input.clone();
@@ -380,10 +384,12 @@ where
 /// assert_eq!(parser("123abcd;"),Err(Err::Error(("123abcd;", ErrorKind::Alpha))));
 /// # }
 /// ```
-pub fn all_consuming<I, O, E: ParseError<I>, F>(mut f: F) -> impl FnMut(I) -> IResult<I, O, E>
+pub fn all_consuming<I, E: ParseError<I>, F>(
+  mut f: F,
+) -> impl FnMut(I) -> IResult<I, <F as Parser<I>>::Output, E>
 where
   I: InputLength,
-  F: Parser<I, O, E>,
+  F: Parser<I, Error = E>,
 {
   move |input: I| {
     let (input, res) = f.parse(input)?;
@@ -413,14 +419,14 @@ where
 /// assert_eq!(parser("123abcd;"),Err(Err::Error(("123abcd;", ErrorKind::Alpha))));
 /// # }
 /// ```
-pub fn verify<I: Clone, O1, O2, E: ParseError<I>, F, G>(
+pub fn verify<I: Clone, O2, E: ParseError<I>, F, G>(
   mut first: F,
   second: G,
-) -> impl FnMut(I) -> IResult<I, O1, E>
+) -> impl FnMut(I) -> IResult<I, <F as Parser<I>>::Output, E>
 where
-  F: Parser<I, O1, E>,
+  F: Parser<I, Error = E>,
   G: Fn(&O2) -> bool,
-  O1: Borrow<O2>,
+  <F as Parser<I>>::Output: Borrow<O2>,
   O2: ?Sized,
 {
   move |input: I| {
@@ -449,12 +455,12 @@ where
 /// assert_eq!(parser("123abcd;"), Err(Err::Error(("123abcd;", ErrorKind::Alpha))));
 /// # }
 /// ```
-pub fn value<I, O1: Clone, O2, E: ParseError<I>, F>(
+pub fn value<I, O1: Clone, E: ParseError<I>, F>(
   val: O1,
   mut parser: F,
 ) -> impl FnMut(I) -> IResult<I, O1, E>
 where
-  F: Parser<I, O2, E>,
+  F: Parser<I, Error = E>,
 {
   move |input: I| parser.parse(input).map(|(i, _)| (i, val.clone()))
 }
@@ -473,9 +479,9 @@ where
 /// assert_eq!(parser("abcd"), Err(Err::Error(("abcd", ErrorKind::Not))));
 /// # }
 /// ```
-pub fn not<I: Clone, O, E: ParseError<I>, F>(mut parser: F) -> impl FnMut(I) -> IResult<I, (), E>
+pub fn not<I: Clone, E: ParseError<I>, F>(mut parser: F) -> impl FnMut(I) -> IResult<I, (), E>
 where
-  F: Parser<I, O, E>,
+  F: Parser<I, Error = E>,
 {
   move |input: I| {
     let i = input.clone();
@@ -502,11 +508,11 @@ where
 /// assert_eq!(parser("abcd;"),Err(Err::Error((";", ErrorKind::Char))));
 /// # }
 /// ```
-pub fn recognize<I: Clone + Offset + Input, O, E: ParseError<I>, F>(
+pub fn recognize<I: Clone + Offset + Input, E: ParseError<I>, F>(
   mut parser: F,
 ) -> impl FnMut(I) -> IResult<I, I, E>
 where
-  F: Parser<I, O, E>,
+  F: Parser<I, Error = E>,
 {
   move |input: I| {
     let i = input.clone();
@@ -557,11 +563,13 @@ where
 /// assert_eq!(recognize_parser("abcd"), consumed_parser("abcd"));
 /// # }
 /// ```
-pub fn consumed<I, O, F, E>(mut parser: F) -> impl FnMut(I) -> IResult<I, (I, O), E>
+pub fn consumed<I, F, E>(
+  mut parser: F,
+) -> impl FnMut(I) -> IResult<I, (I, <F as Parser<I>>::Output), E>
 where
   I: Clone + Offset + Input,
   E: ParseError<I>,
-  F: Parser<I, O, E>,
+  F: Parser<I, Error = E>,
 {
   move |input: I| {
     let i = input.clone();
@@ -627,9 +635,11 @@ where
 /// assert_eq!(parser("+"), Err(Err::Failure(Error { input: "", code: ErrorKind::Digit })));
 /// # }
 /// ```
-pub fn cut<I, O, E: ParseError<I>, F>(mut parser: F) -> impl FnMut(I) -> IResult<I, O, E>
+pub fn cut<I, E: ParseError<I>, F>(
+  mut parser: F,
+) -> impl FnMut(I) -> IResult<I, <F as Parser<I>>::Output, E>
 where
-  F: Parser<I, O, E>,
+  F: Parser<I, Error = E>,
 {
   move |input: I| match parser.parse(input) {
     Err(Err::Error(e)) => Err(Err::Failure(e)),
@@ -665,7 +675,7 @@ where
   E1: Into<E2>,
   E1: ParseError<I>,
   E2: ParseError<I>,
-  F: Parser<I, O1, E1>,
+  F: Parser<I, Output = O1, Error = E1>,
 {
   //map(parser, Into::into)
   move |input: I| match parser.parse(input) {
@@ -696,9 +706,9 @@ where
 /// assert_eq!(parsed, [("abc", 3usize), ("defg", 4), ("hijkl", 5), ("mnopqr", 6)].iter().cloned().collect());
 /// assert_eq!(res, Ok(("123", ())));
 /// ```
-pub fn iterator<Input, Output, Error, F>(input: Input, f: F) -> ParserIterator<Input, Error, F>
+pub fn iterator<Input, Error, F>(input: Input, f: F) -> ParserIterator<Input, Error, F>
 where
-  F: Parser<Input, Output, Error>,
+  F: Parser<Input>,
   Error: ParseError<Input>,
 {
   ParserIterator {
diff --git a/src/error.rs b/src/error.rs
index cd9a0273c..4a1193315 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -235,7 +235,7 @@ pub fn context<I: Clone, E: ContextError<I>, F, O>(
   mut f: F,
 ) -> impl FnMut(I) -> IResult<I, O, E>
 where
-  F: Parser<I, O, E>,
+  F: Parser<I, Output = O, Error = E>,
 {
   move |i: I| match f.parse(i.clone()) {
     Ok(o) => Ok(o),
diff --git a/src/internal.rs b/src/internal.rs
index 4ad258c3d..deadd7e07 100644
--- a/src/internal.rs
+++ b/src/internal.rs
@@ -234,82 +234,67 @@ where
 }
 
 /// All nom parsers implement this trait
-pub trait Parser<I, O, E> {
+pub trait Parser<Input> {
+  /// Type of the produced value
+  type Output;
+  /// Error type of this parser
+  type Error: ParseError<Input>;
+
   /// A parser takes in input type, and returns a `Result` containing
   /// either the remaining input and the output value, or an error
-  fn parse(&mut self, input: I) -> IResult<I, O, E>;
+  fn parse(&mut self, input: Input) -> IResult<Input, Self::Output, Self::Error>;
 
   /// Maps a function over the result of a parser
-  fn map<G, O2>(self, g: G) -> Map<Self, G, O>
+  fn map<G, O2>(self, g: G) -> Map<Self, G>
   where
-    G: FnMut(O) -> O2,
+    G: FnMut(Self::Output) -> O2,
     Self: core::marker::Sized,
   {
-    Map {
-      f: self,
-      g,
-      phantom: core::marker::PhantomData,
-    }
+    Map { f: self, g }
   }
 
   /// Applies a function returning a `Result` over the result of a parser.
-  fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G, O>
+  fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G>
   where
-    G: Fn(O) -> Result<O2, E2>,
-    E: FromExternalError<I, E2>,
+    G: Fn(Self::Output) -> Result<O2, E2>,
+    Self::Error: FromExternalError<Input, E2>,
     Self: core::marker::Sized,
   {
-    MapRes {
-      f: self,
-      g,
-      phantom: core::marker::PhantomData,
-    }
+    MapRes { f: self, g }
   }
 
   /// Applies a function returning an `Option` over the result of a parser.
-  fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G, O>
+  fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G>
   where
-    G: Fn(O) -> Option<O2>,
+    G: Fn(Self::Output) -> Option<O2>,
     Self: core::marker::Sized,
   {
-    MapOpt {
-      f: self,
-      g,
-      phantom: core::marker::PhantomData,
-    }
+    MapOpt { f: self, g }
   }
 
   /// Creates a second parser from the output of the first one, then apply over the rest of the input
-  fn flat_map<G, H, O2>(self, g: G) -> FlatMap<Self, G, O>
+  fn flat_map<G, H>(self, g: G) -> FlatMap<Self, G>
   where
-    G: FnMut(O) -> H,
-    H: Parser<I, O2, E>,
+    G: FnMut(Self::Output) -> H,
+    H: Parser<Input, Error = Self::Error>,
     Self: core::marker::Sized,
   {
-    FlatMap {
-      f: self,
-      g,
-      phantom: core::marker::PhantomData,
-    }
+    FlatMap { f: self, g }
   }
 
   /// Applies a second parser over the output of the first one
-  fn and_then<G, O2>(self, g: G) -> AndThen<Self, G, O>
+  fn and_then<G>(self, g: G) -> AndThen<Self, G>
   where
-    G: Parser<O, O2, E>,
+    G: Parser<Self::Output, Error = Self::Error>,
     Self: core::marker::Sized,
   {
-    AndThen {
-      f: self,
-      g,
-      phantom: core::marker::PhantomData,
-    }
+    AndThen { f: self, g }
   }
 
   /// Applies a second parser after the first one, return their results as a tuple
   fn and<G, O2>(self, g: G) -> And<Self, G>
   where
-    G: Parser<I, O2, E>,
+    G: Parser<Input, Output = O2, Error = Self::Error>,
     Self: core::marker::Sized,
   {
     And { f: self, g }
@@ -318,7 +303,7 @@ pub trait Parser<I, O, E> {
   /// Applies a second parser over the input if the first one failed
   fn or<G>(self, g: G) -> Or<Self, G>
   where
-    G: Parser<I, O, E>,
+    G: Parser<Input, Output = Self::Output, Error = Self::Error>,
     Self: core::marker::Sized,
   {
     Or { f: self, g }
@@ -326,24 +311,24 @@ pub trait Parser<I, O, E> {
 
   /// automatically converts the parser's output and error values to another type, as long as they
   /// implement the `From` trait
-  fn into<O2: From<O>, E2: From<E>>(self) -> Into<Self, O, O2, E, E2>
+  fn into<O2: From<Self::Output>, E2: From<Self::Error>>(self) -> Into<Self, O2, E2>
   where
     Self: core::marker::Sized,
   {
     Into {
       f: self,
-      phantom_out1: core::marker::PhantomData,
-      phantom_err1: core::marker::PhantomData,
       phantom_out2: core::marker::PhantomData,
       phantom_err2: core::marker::PhantomData,
     }
   }
 }
 
-impl<I, O, E, F> Parser<I, O, E> for F
+impl<I, O, E: ParseError<I>, F> Parser<I> for F
 where
   F: FnMut(I) -> IResult<I, O, E>,
 {
+  type Output = O;
+  type Error = E;
   fn parse(&mut self, i: I) -> IResult<I, O, E> {
     self(i)
   }
@@ -352,10 +337,12 @@ where
 macro_rules! impl_parser_for_tuple {
   ($($parser:ident $output:ident),+) => (
     #[allow(non_snake_case)]
-    impl<I, $($output),+, E: ParseError<I>, $($parser),+> Parser<I, ($($output),+,), E> for ($($parser),+,)
+    impl<I, $($output),+, E: ParseError<I>, $($parser),+> Parser<I> for ($($parser),+,)
     where
-      $($parser: Parser<I, $output, E>),+
+      $($parser: Parser<I, Output = $output, Error = E>),+
     {
+      type Output = ($($output),+,);
+      type Error = E;
       fn parse(&mut self, i: I) -> IResult<I, ($($output),+,), E> {
         let ($(ref mut $parser),+,) = *self;
 
@@ -386,7 +373,9 @@ impl_parser_for_tuples!(P1 O1, P2 O2, P3 O3, P4 O4, P5 O5, P6 O6, P7 O7, P8 O8,
 use alloc::boxed::Box;
 
 #[cfg(feature = "alloc")]
-impl<I, O, E> Parser<I, O, E> for Box<dyn Parser<I, O, E>> {
+impl<I, O, E: ParseError<I>> Parser<I> for Box<dyn Parser<I, Output = O, Error = E>> {
+  type Output = O;
+  type Error = E;
   fn parse(&mut self, input: I) -> IResult<I, O, E> {
     (**self).parse(input)
   }
@@ -394,13 +383,17 @@ impl<I, O, E> Parser<I, O, E> for Box<dyn Parser<I, O, E>> {
 
 /// Implementation of `Parser::map`
 #[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
-pub struct Map<F, G, O1> {
+pub struct Map<F, G> {
   f: F,
   g: G,
-  phantom: core::marker::PhantomData<O1>,
 }
 
-impl<I, O1, O2, E, F: Parser<I, O1, E>, G: FnMut(O1) -> O2> Parser<I, O2, E> for Map<F, G, O1> {
+impl<I, O2, E: ParseError<I>, F: Parser<I, Error = E>, G: FnMut(<F as Parser<I>>::Output) -> O2>
+  Parser<I> for Map<F, G>
+{
+  type Output = O2;
+  type Error = E;
+
   fn parse(&mut self, i: I) -> IResult<I, O2, E> {
     match self.f.parse(i) {
       Err(e) => Err(e),
@@ -410,65 +403,81 @@ impl<I, O1, O2, E, F: Parser<I, O1, E>, G: FnMut(O1) -> O2> Parser<I, O2, E> for
 }
 
 /// Implementation of `Parser::map_res`
-pub struct MapRes<F, G, O> {
+pub struct MapRes<F, G> {
   f: F,
   g: G,
-  phantom: core::marker::PhantomData<O>,
 }
 
-impl<I, O, O2, E, E2, F, G> Parser<I, O2, E> for MapRes<F, G, O>
+impl<I, O2, E2, F, G> Parser<I> for MapRes<F, G>
 where
   I: Clone,
-  E: FromExternalError<I, E2>,
-  F: Parser<I, O, E>,
-  G: Fn(O) -> Result<O2, E2>,
+  <F as Parser<I>>::Error: FromExternalError<I, E2>,
+  F: Parser<I>,
+  G: Fn(<F as Parser<I>>::Output) -> Result<O2, E2>,
 {
-  fn parse(&mut self, input: I) -> IResult<I, O2, E> {
+  type Output = O2;
+  type Error = <F as Parser<I>>::Error;
+  fn parse(&mut self, input: I) -> IResult<I, O2, <F as Parser<I>>::Error> {
     let i = input.clone();
     let (input, o1) = self.f.parse(input)?;
     match (self.g)(o1) {
       Ok(o2) => Ok((input, o2)),
-      Err(e) => Err(Err::Error(E::from_external_error(i, ErrorKind::MapRes, e))),
+      Err(e) => Err(Err::Error(<F as Parser<I>>::Error::from_external_error(
+        i,
+        ErrorKind::MapRes,
+        e,
+      ))),
     }
   }
 }
 
 /// Implementation of `Parser::map_opt`
-pub struct MapOpt<F, G, O> {
+pub struct MapOpt<F, G> {
   f: F,
   g: G,
-  phantom: core::marker::PhantomData<O>,
 }
 
-impl<I, O, O2, E, F, G> Parser<I, O2, E> for MapOpt<F, G, O>
+impl<I, O2, F, G> Parser<I> for MapOpt<F, G>
 where
   I: Clone,
-  E: ParseError<I>,
-  F: Parser<I, O, E>,
-  G: Fn(O) -> Option<O2>,
+  F: Parser<I>,
+  G: Fn(<F as Parser<I>>::Output) -> Option<O2>,
 {
-  fn parse(&mut self, input: I) -> IResult<I, O2, E> {
+  type Output = O2;
+  type Error = <F as Parser<I>>::Error;
+
+  fn parse(&mut self, input: I) -> IResult<I, O2, <F as Parser<I>>::Error> {
     let i = input.clone();
     let (input, o1) = self.f.parse(input)?;
     match (self.g)(o1) {
       Some(o2) => Ok((input, o2)),
-      None => Err(Err::Error(E::from_error_kind(i, ErrorKind::MapOpt))),
+      None => Err(Err::Error(<F as Parser<I>>::Error::from_error_kind(
+        i,
+        ErrorKind::MapOpt,
+      ))),
     }
   }
 }
 
 /// Implementation of `Parser::flat_map`
 #[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
-pub struct FlatMap<F, G, O1> {
+pub struct FlatMap<F, G> {
   f: F,
   g: G,
-  phantom: core::marker::PhantomData<O1>,
 }
 
-impl<I, O1, O2, E, F: Parser<I, O1, E>, G: FnMut(O1) -> H, H: Parser<I, O2, E>> Parser<I, O2, E>
-  for FlatMap<F, G, O1>
+impl<
+    I,
+    E: ParseError<I>,
+    F: Parser<I, Error = E>,
+    G: FnMut(<F as Parser<I>>::Output) -> H,
+    H: Parser<I, Error = E>,
+  > Parser<I> for FlatMap<F, G>
 {
-  fn parse(&mut self, i: I) -> IResult<I, O2, E> {
+  type Output = <H as Parser<I>>::Output;
+  type Error = E;
+
+  fn parse(&mut self, i: I) -> IResult<I, Self::Output, E> {
     let (i, o1) = self.f.parse(i)?;
     (self.g)(o1).parse(i)
   }
@@ -476,16 +485,18 @@ impl<I, O1, O2, E, F: Parser<I, O1, E>, G: FnMut(O1) -> H, H: Parser<I, O2, E>>
 
 /// Implementation of `Parser::and_then`
 #[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
-pub struct AndThen<F, G, O1> {
+pub struct AndThen<F, G> {
   f: F,
   g: G,
-  phantom: core::marker::PhantomData<O1>,
 }
 
-impl<I, O1, O2, E, F: Parser<I, O1, E>, G: Parser<O1, O2, E>> Parser<I, O2, E>
-  for AndThen<F, G, O1>
+impl<I, F: Parser<I>, G: Parser<<F as Parser<I>>::Output, Error = <F as Parser<I>>::Error>>
+  Parser<I> for AndThen<F, G>
 {
-  fn parse(&mut self, i: I) -> IResult<I, O2, E> {
+  type Output = <G as Parser<<F as Parser<I>>::Output>>::Output;
+  type Error = <F as Parser<I>>::Error;
+
+  fn parse(&mut self, i: I) -> IResult<I, Self::Output, Self::Error> {
     let (i, o1) = self.f.parse(i)?;
     let (_, o2) = self.g.parse(o1)?;
     Ok((i, o2))
@@ -499,8 +510,13 @@ pub struct And<F, G> {
   g: G,
 }
 
-impl<I, O1, O2, E, F: Parser<I, O1, E>, G: Parser<I, O2, E>> Parser<I, (O1, O2), E> for And<F, G> {
-  fn parse(&mut self, i: I) -> IResult<I, (O1, O2), E> {
+impl<I, E: ParseError<I>, F: Parser<I, Error = E>, G: Parser<I, Error = E>> Parser<I>
+  for And<F, G>
+{
+  type Output = (<F as Parser<I>>::Output, <G as Parser<I>>::Output);
+  type Error = E;
+
+  fn parse(&mut self, i: I) -> IResult<I, Self::Output, Self::Error> {
     let (i, o1) = self.f.parse(i)?;
     let (i, o2) = self.g.parse(i)?;
     Ok((i, (o1, o2)))
@@ -514,10 +530,18 @@ pub struct Or<F, G> {
   g: G,
 }
 
-impl<I: Clone, O, E: crate::error::ParseError<I>, F: Parser<I, O, E>, G: Parser<I, O, E>>
-  Parser<I, O, E> for Or<F, G>
+impl<
+    I: Clone,
+    O,
+    E: ParseError<I>,
+    F: Parser<I, Output = O, Error = E>,
+    G: Parser<I, Output = O, Error = E>,
+  > Parser<I> for Or<F, G>
 {
-  fn parse(&mut self, i: I) -> IResult<I, O, E> {
+  type Output = <F as Parser<I>>::Output;
+  type Error = <F as Parser<I>>::Error;
+
+  fn parse(&mut self, i: I) -> IResult<I, Self::Output, Self::Error> {
     match self.f.parse(i.clone()) {
       Err(Err::Error(e1)) => match self.g.parse(i) {
         Err(Err::Error(e2)) => Err(Err::Error(e1.or(e2))),
@@ -530,24 +554,23 @@ impl<I: Clone, O, E: crate::error::ParseError<I>, F: Parser<I, O, E>, G: Parser<
 
 /// Implementation of `Parser::into`
 #[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
-pub struct Into<F, O1, O2: From<O1>, E1, E2: From<E1>> {
+pub struct Into<F, O2, E2> {
   f: F,
-  phantom_out1: core::marker::PhantomData<O1>,
-  phantom_err1: core::marker::PhantomData<E1>,
   phantom_out2: core::marker::PhantomData<O2>,
   phantom_err2: core::marker::PhantomData<E2>,
 }
 
 impl<
     I: Clone,
-    O1,
-    O2: From<O1>,
-    E1,
-    E2: crate::error::ParseError<I> + From<E1>,
-    F: Parser<I, O1, E1>,
-  > Parser<I, O2, E2> for Into<F, O1, O2, E1, E2>
+    O2: From<<F as Parser<I>>::Output>,
+    E2: crate::error::ParseError<I> + From<<F as Parser<I>>::Error>,
+    F: Parser<I>,
+  > Parser<I> for Into<F, O2, E2>
 {
-  fn parse(&mut self, i: I) -> IResult<I, O2, E2> {
+  type Output = O2;
+  type Error = E2;
+
+  fn parse(&mut self, i: I) -> IResult<I, Self::Output, Self::Error> {
     match self.f.parse(i) {
       Ok((i, o)) => Ok((i, o.into())),
       Err(Err::Error(e)) => Err(Err::Error(e.into())),
diff --git a/src/multi/mod.rs b/src/multi/mod.rs
index 1056add83..07f5ba766 100644
--- a/src/multi/mod.rs
+++ b/src/multi/mod.rs
@@ -54,11 +54,12 @@ const MAX_INITIAL_CAPACITY_BYTES: usize = 65536;
 /// ```
 #[cfg(feature = "alloc")]
 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
-pub fn many0<I, O, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+pub fn many0<I, F>(
+  mut f: F,
+) -> impl FnMut(I) -> IResult<I, Vec<<F as Parser<I>>::Output>, <F as Parser<I>>::Error>
 where
   I: Clone + InputLength,
-  F: Parser<I, O, E>,
-  E: ParseError<I>,
+  F: Parser<I>,
 {
   move |mut i: I| {
     let mut acc = crate::lib::std::vec::Vec::with_capacity(4);
@@ -70,7 +71,10 @@ where
         Ok((i1, o)) => {
           // infinite loop check: the parser must always consume
           if i1.input_len() == len {
-            return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many0)));
+            return Err(Err::Error(<F as Parser<I>>::Error::from_error_kind(
+              i,
+              ErrorKind::Many0,
+            )));
           }
 
           i = i1;
@@ -109,14 +113,19 @@ where
 /// ```
 #[cfg(feature = "alloc")]
 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
-pub fn many1<I, O, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+pub fn many1<I, F>(
+  mut f: F,
+) -> impl FnMut(I) -> IResult<I, Vec<<F as Parser<I>>::Output>, <F as Parser<I>>::Error>
 where
   I: Clone + InputLength,
-  F: Parser<I, O, E>,
-  E: ParseError<I>,
+  F: Parser<I>,
 {
   move |mut i: I| match f.parse(i.clone()) {
-    Err(Err::Error(err)) => Err(Err::Error(E::append(i, ErrorKind::Many1, err))),
+    Err(Err::Error(err)) => Err(Err::Error(<F as Parser<I>>::Error::append(
+      i,
+      ErrorKind::Many1,
+      err,
+    ))),
     Err(e) => Err(e),
     Ok((i1, o)) => {
       let mut acc = crate::lib::std::vec::Vec::with_capacity(4);
@@ -131,7 +140,10 @@ where
           Ok((i1, o)) => {
             // infinite loop check: the parser must always consume
             if i1.input_len() == len {
-              return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1)));
+              return Err(Err::Error(<F as Parser<I>>::Error::from_error_kind(
+                i,
+                ErrorKind::Many1,
+              )));
             }
 
             i = i1;
@@ -166,14 +178,14 @@ where
 /// ```
 #[cfg(feature = "alloc")]
 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
-pub fn many_till<I, O, P, E, F, G>(
+pub fn many_till<I, E, F, G>(
   mut f: F,
   mut g: G,
-) -> impl FnMut(I) -> IResult<I, (Vec<O>, P), E>
+) -> impl FnMut(I) -> IResult<I, (Vec<<F as Parser<I>>::Output>, <G as Parser<I>>::Output), E>
 where
   I: Clone + InputLength,
-  F: Parser<I, O, E>,
-  G: Parser<I, P, E>,
+  F: Parser<I, Error = E>,
+  G: Parser<I, Error = E>,
   E: ParseError<I>,
 {
   move |mut i: I| {
@@ -229,14 +241,14 @@ where
 /// ```
 #[cfg(feature = "alloc")]
 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
-pub fn separated_list0<I, O, O2, E, F, G>(
+pub fn separated_list0<I, E, F, G>(
   mut sep: G,
   mut f: F,
-) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+) -> impl FnMut(I) -> IResult<I, Vec<<F as Parser<I>>::Output>, E>
 where
   I: Clone + InputLength,
-  F: Parser<I, O, E>,
-  G: Parser<I, O2, E>,
+  F: Parser<I, Error = E>,
+  G: Parser<I, Error = E>,
   E: ParseError<I>,
 {
   move |mut i: I| {
@@ -303,14 +315,14 @@ where
 /// ```
 #[cfg(feature = "alloc")]
 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
-pub fn separated_list1<I, O, O2, E, F, G>(
+pub fn separated_list1<I, E, F, G>(
   mut sep: G,
   mut f: F,
-) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+) -> impl FnMut(I) -> IResult<I, Vec<<F as Parser<I>>::Output>, E>
 where
   I: Clone + InputLength,
-  F: Parser<I, O, E>,
-  G: Parser<I, O2, E>,
+  F: Parser<I, Error = E>,
+  G: Parser<I, Error = E>,
   E: ParseError<I>,
 {
   move |mut i: I| {
@@ -381,14 +393,14 @@ where
 /// ```
 #[cfg(feature = "alloc")]
 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
-pub fn many_m_n<I, O, E, F>(
+pub fn many_m_n<I, E, F>(
   min: usize,
   max: usize,
   mut parse: F,
-) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+) -> impl FnMut(I) -> IResult<I, Vec<<F as Parser<I>>::Output>, E>
 where
   I: Clone + InputLength,
-  F: Parser<I, O, E>,
+  F: Parser<I, Error = E>,
   E: ParseError<I>,
 {
   move |mut input: I| {
@@ -396,8 +408,8 @@ where
       return Err(Err::Failure(E::from_error_kind(input, ErrorKind::ManyMN)));
     }
 
-    let max_initial_capacity =
-      MAX_INITIAL_CAPACITY_BYTES / crate::lib::std::mem::size_of::<O>().max(1);
+    let max_initial_capacity = MAX_INITIAL_CAPACITY_BYTES
+      / crate::lib::std::mem::size_of::<<F as Parser<I>>::Output>().max(1);
     let mut res = crate::lib::std::vec::Vec::with_capacity(min.min(max_initial_capacity));
     for count in 0..max {
       let len = input.input_len();
@@ -453,10 +465,10 @@ where
 /// assert_eq!(parser("123123"), Ok(("123123", 0)));
 /// assert_eq!(parser(""), Ok(("", 0)));
 /// ```
-pub fn many0_count<I, O, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, usize, E>
+pub fn many0_count<I, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, usize, E>
 where
   I: Clone + InputLength,
-  F: Parser<I, O, E>,
+  F: Parser<I, Error = E>,
   E: ParseError<I>,
 {
   move |i: I| {
@@ -511,10 +523,10 @@ where
 /// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Many1Count))));
 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Many1Count))));
 /// ```
-pub fn many1_count<I, O, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, usize, E>
+pub fn many1_count<I, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, usize, E>
 where
   I: Clone + InputLength,
-  F: Parser<I, O, E>,
+  F: Parser<I, Error = E>,
   E: ParseError<I>,
 {
   move |i: I| {
@@ -570,16 +582,19 @@ where
 /// ```
 #[cfg(feature = "alloc")]
 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
-pub fn count<I, O, E, F>(mut f: F, count: usize) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+pub fn count<I, E, F>(
+  mut f: F,
+  count: usize,
+) -> impl FnMut(I) -> IResult<I, Vec<<F as Parser<I>>::Output>, E>
 where
   I: Clone + PartialEq,
-  F: Parser<I, O, E>,
+  F: Parser<I, Error = E>,
   E: ParseError<I>,
 {
   move |i: I| {
     let mut input = i.clone();
-    let max_initial_capacity =
-      MAX_INITIAL_CAPACITY_BYTES / crate::lib::std::mem::size_of::<O>().max(1);
+    let max_initial_capacity = MAX_INITIAL_CAPACITY_BYTES
+      / crate::lib::std::mem::size_of::<<F as Parser<I>>::Output>().max(1);
     let mut res = crate::lib::std::vec::Vec::with_capacity(count.min(max_initial_capacity));
 
     for _ in 0..count {
@@ -626,10 +641,13 @@ where
 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
 /// assert_eq!(parser("abcabcabc"), Ok(("abc", ["abc", "abc"])));
 /// ```
-pub fn fill<'a, I, O, E, F>(mut f: F, buf: &'a mut [O]) -> impl FnMut(I) -> IResult<I, (), E> + 'a
+pub fn fill<'a, I, E, F>(
+  mut f: F,
+  buf: &'a mut [<F as Parser<I>>::Output],
+) -> impl FnMut(I) -> IResult<I, (), E> + 'a
 where
   I: Clone + PartialEq,
-  F: Parser<I, O, E> + 'a,
+  F: Parser<I, Error = E> + 'a,
   E: ParseError<I>,
 {
   move |i: I| {
@@ -690,15 +708,15 @@ where
 /// assert_eq!(parser("123123"), Ok(("123123", vec![])));
 /// assert_eq!(parser(""), Ok(("", vec![])));
 /// ```
-pub fn fold_many0<I, O, E, F, G, H, R>(
+pub fn fold_many0<I, E, F, G, H, R>(
   mut f: F,
   mut init: H,
   mut g: G,
 ) -> impl FnMut(I) -> IResult<I, R, E>
 where
   I: Clone + InputLength,
-  F: Parser<I, O, E>,
-  G: FnMut(R, O) -> R,
+  F: Parser<I, Error = E>,
+  G: FnMut(R, <F as Parser<I>>::Output) -> R,
   H: FnMut() -> R,
   E: ParseError<I>,
 {
@@ -766,15 +784,15 @@ where
 /// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Many1))));
 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Many1))));
 /// ```
-pub fn fold_many1<I, O, E, F, G, H, R>(
+pub fn fold_many1<I, E, F, G, H, R>(
   mut f: F,
   mut init: H,
   mut g: G,
 ) -> impl FnMut(I) -> IResult<I, R, E>
 where
   I: Clone + InputLength,
-  F: Parser<I, O, E>,
-  G: FnMut(R, O) -> R,
+  F: Parser<I, Error = E>,
+  G: FnMut(R, <F as Parser<I>>::Output) -> R,
   H: FnMut() -> R,
   E: ParseError<I>,
 {
@@ -855,7 +873,7 @@ where
 /// assert_eq!(parser(""), Ok(("", vec![])));
 /// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
 /// ```
-pub fn fold_many_m_n<I, O, E, F, G, H, R>(
+pub fn fold_many_m_n<I, E, F, G, H, R>(
   min: usize,
   max: usize,
   mut parse: F,
@@ -864,8 +882,8 @@ pub fn fold_many_m_n<I, O, E, F, G, H, R>(
 ) -> impl FnMut(I) -> IResult<I, R, E>
 where
   I: Clone + InputLength,
-  F: Parser<I, O, E>,
-  G: FnMut(R, O) -> R,
+  F: Parser<I, Error = E>,
+  G: FnMut(R, <F as Parser<I>>::Output) -> R,
   H: FnMut() -> R,
   E: ParseError<I>,
 {
@@ -921,11 +939,11 @@ where
 /// assert_eq!(parser(b"\x00\x03abcefg"), Ok((&b"efg"[..], &b"abc"[..])));
 /// assert_eq!(parser(b"\x00\x03a"), Err(Err::Incomplete(Needed::new(2))));
 /// ```
-pub fn length_data<I, N, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, I, E>
+pub fn length_data<I, E, F>(mut f: F) -> impl FnMut(I) -> IResult<I, I, E>
 where
   I: Input,
-  N: ToUsize,
-  F: Parser<I, N, E>,
+  <F as Parser<I>>::Output: ToUsize,
+  F: Parser<I, Error = E>,
   E: ParseError<I>,
 {
   move |i: I| {
@@ -966,12 +984,15 @@ where
 /// assert_eq!(parser(b"\x00\x03123123"), Err(Err::Error(Error::new(&b"123"[..], ErrorKind::Tag))));
 /// assert_eq!(parser(b"\x00\x03a"), Err(Err::Incomplete(Needed::new(2))));
 /// ```
-pub fn length_value<I, O, N, E, F, G>(mut f: F, mut g: G) -> impl FnMut(I) -> IResult<I, O, E>
+pub fn length_value<I, E, F, G>(
+  mut f: F,
+  mut g: G,
+) -> impl FnMut(I) -> IResult<I, <G as Parser<I>>::Output, E>
 where
   I: Clone + Input,
-  N: ToUsize,
-  F: Parser<I, N, E>,
-  G: Parser<I, O, E>,
+  <F as Parser<I>>::Output: ToUsize,
+  F: Parser<I, Error = E>,
+  G: Parser<I, Error = E>,
   E: ParseError<I>,
 {
   move |i: I| {
@@ -1018,12 +1039,15 @@ where
 /// assert_eq!(parser(b"\x03123123123"), Err(Err::Error(Error::new(&b"123123123"[..], ErrorKind::Tag))));
 /// ```
 #[cfg(feature = "alloc")]
-pub fn length_count<I, O, N, E, F, G>(mut f: F, mut g: G) -> impl FnMut(I) -> IResult<I, Vec<O>, E>
+pub fn length_count<I, E, F, G>(
+  mut f: F,
+  mut g: G,
+) -> impl FnMut(I) -> IResult<I, Vec<<G as Parser<I>>::Output>, E>
 where
   I: Clone,
-  N: ToUsize,
-  F: Parser<I, N, E>,
-  G: Parser<I, O, E>,
+  <F as Parser<I>>::Output: ToUsize,
+  F: Parser<I, Error = E>,
+  G: Parser<I, Error = E>,
   E: ParseError<I>,
 {
   move |i: I| {
@@ -1136,14 +1160,14 @@ where
 /// ```
 #[cfg(feature = "alloc")]
 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))]
-pub fn many<I, O, E, Collection, F, G>(
+pub fn many<I, E, Collection, F, G>(
   range: G,
   mut parse: F,
 ) -> impl FnMut(I) -> IResult<I, Collection, E>
 where
   I: Clone + InputLength,
-  F: Parser<I, O, E>,
-  Collection: Extend<O> + Default,
+  F: Parser<I, Error = E>,
+  Collection: Extend<<F as Parser<I>>::Output> + Default,
   E: ParseError<I>,
   G: NomRange<usize>,
 {
@@ -1221,7 +1245,7 @@ where
 /// assert_eq!(parser(""), Ok(("", vec![])));
 /// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
 /// ```
-pub fn fold<I, O, E, F, G, H, J, R>(
+pub fn fold<I, E, F, G, H, J, R>(
   range: J,
   mut parse: F,
   mut init: H,
@@ -1229,8 +1253,8 @@ pub fn fold<I, O, E, F, G, H, J, R>(
 ) -> impl FnMut(I) -> IResult<I, R, E>
 where
   I: Clone + InputLength,
-  F: Parser<I, O, E>,
-  G: FnMut(R, O) -> R,
+  F: Parser<I, Error = E>,
+  G: FnMut(R, <F as Parser<I>>::Output) -> R,
   H: FnMut() -> R,
   E: ParseError<I>,
   J: NomRange<usize>,
diff --git a/src/sequence/mod.rs b/src/sequence/mod.rs
index 23079534d..fd322f526 100644
--- a/src/sequence/mod.rs
+++ b/src/sequence/mod.rs
@@ -31,8 +31,8 @@ pub fn pair<I, O1, O2, E: ParseError<I>, F, G>(
   mut second: G,
 ) -> impl FnMut(I) -> IResult<I, (O1, O2), E>
 where
-  F: Parser<I, O1, E>,
-  G: Parser<I, O2, E>,
+  F: Parser<I, Output = O1, Error = E>,
+  G: Parser<I, Output = O2, Error = E>,
 {
   move |input: I| {
     let (input, o1) = first.parse(input)?;
@@ -60,13 +60,13 @@ where
 /// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Tag))));
 /// assert_eq!(parser("123"), Err(Err::Error(("123", ErrorKind::Tag))));
 /// ```
-pub fn preceded<I, O1, O2, E: ParseError<I>, F, G>(
+pub fn preceded<I, O, E: ParseError<I>, F, G>(
   mut first: F,
   mut second: G,
-) -> impl FnMut(I) -> IResult<I, O2, E>
+) -> impl FnMut(I) -> IResult<I, O, E>
 where
-  F: Parser<I, O1, E>,
-  G: Parser<I, O2, E>,
+  F: Parser<I, Error = E>,
+  G: Parser<I, Output = O, Error = E>,
 {
   move |input: I| {
     let (input, _) = first.parse(input)?;
@@ -94,13 +94,13 @@ where
 /// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Tag))));
 /// assert_eq!(parser("123"), Err(Err::Error(("123", ErrorKind::Tag))));
 /// ```
-pub fn terminated<I, O1, O2, E: ParseError<I>, F, G>(
+pub fn terminated<I, O, E: ParseError<I>, F, G>(
   mut first: F,
   mut second: G,
-) -> impl FnMut(I) -> IResult<I, O1, E>
+) -> impl FnMut(I) -> IResult<I, O, E>
 where
-  F: Parser<I, O1, E>,
-  G: Parser<I, O2, E>,
+  F: Parser<I, Output = O, Error = E>,
+  G: Parser<I, Error = E>,
 {
   move |input: I| {
     let (input, o1) = first.parse(input)?;
@@ -130,15 +130,15 @@ where
 /// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Tag))));
 /// assert_eq!(parser("123"), Err(Err::Error(("123", ErrorKind::Tag))));
 /// ```
-pub fn separated_pair<I, O1, O2, O3, E: ParseError<I>, F, G, H>(
+pub fn separated_pair<I, O1, O2, E: ParseError<I>, F, G, H>(
   mut first: F,
   mut sep: G,
   mut second: H,
-) -> impl FnMut(I) -> IResult<I, (O1, O3), E>
+) -> impl FnMut(I) -> IResult<I, (O1, O2), E>
 where
-  F: Parser<I, O1, E>,
-  G: Parser<I, O2, E>,
-  H: Parser<I, O3, E>,
+  F: Parser<I, Output = O1, Error = E>,
+  G: Parser<I, Error = E>,
+  H: Parser<I, Output = O2, Error = E>,
 {
   move |input: I| {
     let (input, o1) = first.parse(input)?;
@@ -169,15 +169,15 @@ where
 /// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Tag))));
 /// assert_eq!(parser("123"), Err(Err::Error(("123", ErrorKind::Tag))));
 /// ```
-pub fn delimited<I, O1, O2, O3, E: ParseError<I>, F, G, H>(
+pub fn delimited<I, O, E: ParseError<I>, F, G, H>(
   mut first: F,
   mut second: G,
   mut third: H,
-) -> impl FnMut(I) -> IResult<I, O2, E>
+) -> impl FnMut(I) -> IResult<I, O, E>
 where
-  F: Parser<I, O1, E>,
-  G: Parser<I, O2, E>,
-  H: Parser<I, O3, E>,
+  F: Parser<I, Error = E>,
+  G: Parser<I, Output = O, Error = E>,
+  H: Parser<I, Error = E>,
 {
   move |input: I| {
     let (input, _) = first.parse(input)?;
@@ -197,7 +197,7 @@ pub trait Tuple<I, O, E> {
 }
 
 #[allow(deprecated)]
-impl<Input, Output, Error: ParseError<Input>, F: Parser<Input, Output, Error>>
+impl<Input, Output, Error: ParseError<Input>, F: Parser<Input, Output = Output, Error = Error>>
   Tuple<Input, (Output,), Error> for (F,)
 {
   fn parse(&mut self, input: Input) -> IResult<Input, (Output,), Error> {
@@ -224,9 +224,8 @@ macro_rules! tuple_trait_impl(
     #[allow(deprecated)]
     impl<
       Input: Clone, $($ty),+ , Error: ParseError<Input>,
-      $($name: Parser<Input, $ty, Error>),+
+      $($name: Parser<Input, Output = $ty, Error = Error>),+
     > Tuple<Input, ( $($ty),+ ), Error> for ( $($name),+ ) {
-
       fn parse(&mut self, input: Input) -> IResult<Input, ( $($ty),+ ), Error> {
         tuple_trait_inner!(0, self, input, (), $($name)+)
 
diff --git a/src/str.rs b/src/str.rs
index 93d4c164c..496f47fa8 100644
--- a/src/str.rs
+++ b/src/str.rs
@@ -493,7 +493,10 @@ mod test {
     let b = "ababcd";
 
     fn f(i: &str) -> IResult<&str, &str> {
-      recognize::<_, Vec<&str>, _, _>(many(1.., alt((tag("a"), tag("b")))))(i)
+      recognize(many::<_, _, Vec<&str>, _, _>(
+        1..,
+        alt((tag("a"), tag("b"))),
+      ))(i)
     }
 
     assert_eq!(f(a), Ok((&a[6..], a)));
diff --git a/tests/fnmut.rs b/tests/fnmut.rs
index 976a47d7b..30ca9f0b2 100644
--- a/tests/fnmut.rs
+++ b/tests/fnmut.rs
@@ -8,7 +8,7 @@ fn parse() {
   let mut counter = 0;
 
   let res = {
-    let mut parser = many::<_, _, (), Vec<&str>, _, _>(0.., |i| {
+    let mut parser = many::<_, (), Vec<&str>, _, _>(0.., |i| {
       counter += 1;
       tag("abc")(i)
     });
@@ -25,7 +25,7 @@ fn accumulate() {
   let mut v = Vec::new();
 
   let (_, count) = {
-    let mut parser = many0_count::<_, _, (), _>(|i| {
+    let mut parser = many0_count::<_, (), _>(|i| {
       let (i, o) = tag("abc")(i)?;
       v.push(o);
       Ok((i, ()))
diff --git a/tests/issues.rs b/tests/issues.rs
index 80d3e4e2e..a0755f764 100644
--- a/tests/issues.rs
+++ b/tests/issues.rs
@@ -172,7 +172,7 @@ fn issue_942() {
 fn issue_many_m_n_with_zeros() {
   use nom::character::complete::char;
   use nom::multi::many;
-  let mut parser = many::<_, _, (), Vec<char>, _, _>(0..=0, char('a'));
+  let mut parser = many::<_, (), Vec<char>, _, _>(0..=0, char('a'));
   assert_eq!(parser("aaa"), Ok(("aaa", vec!())));
 }
 
@@ -248,12 +248,12 @@ fn issue_1459_clamp_capacity() {
 
   // shouldn't panic
   use nom::multi::many_m_n;
-  let mut parser = many_m_n::<_, _, (), _>(usize::MAX, usize::MAX, char('a'));
+  let mut parser = many_m_n::<_, (), _>(usize::MAX, usize::MAX, char('a'));
   assert_eq!(parser("a"), Err(nom::Err::Error(())));
 
   // shouldn't panic
   use nom::multi::count;
-  let mut parser = count::<_, _, (), _>(char('a'), usize::MAX);
+  let mut parser = count::<_, (), _>(char('a'), usize::MAX);
   assert_eq!(parser("a"), Err(nom::Err::Error(())));
 }
 
diff --git a/tests/json.rs b/tests/json.rs
index 417fe4bbc..0d11bdbd0 100644
--- a/tests/json.rs
+++ b/tests/json.rs
@@ -90,7 +90,9 @@ fn string(input: &str) -> IResult<&str, String> {
   )(input)
 }
 
-fn ws<'a, O, E: ParseError<&'a str>, F: Parser<&'a str, O, E>>(f: F) -> impl Parser<&'a str, O, E> {
+fn ws<'a, O, E: ParseError<&'a str>, F: Parser<&'a str, Output = O, Error = E>>(
+  f: F,
+) -> impl Parser<&'a str, Output = O, Error = E> {
   delimited(multispace0, f, multispace0)
 }