use Mode re-exports more

src/rcore/modes.rs

@@ -127,68 +127,66 @@ pub type ModeResultP<F, A, E, I> = ModeResult<<F as ParseMode>::Mode, A, E, I>;
 pub trait ParseModeExt: ParseMode {
     /// [`Mode::bind`].
     fn bind<A0, A1, E, I>(
-        s: <Self::Mode as Mode>::ParseSuccess<A0, I>,
+        s: ParseSuccessP<Self, A0, I>,
         f: impl FnOnce(A0) -> Result<A1, E>,
-    ) -> ModeResult<Self::Mode, A1, E, I> {
+    ) -> ModeResultP<Self, A1, E, I> {
         <Self::Mode as Mode>::bind(s, f)
     }
 
     /// [`Mode::map`].
     fn map<A0, A1, I>(
-        s: <Self::Mode as Mode>::ParseSuccess<A0, I>,
+        s: ParseSuccessP<Self, A0, I>,
         f: impl FnOnce(A0) -> A1,
-    ) -> <Self::Mode as Mode>::ParseSuccess<A1, I> {
+    ) -> ParseSuccessP<Self, A1, I> {
         <Self::Mode as Mode>::map(s, f)
     }
 
     /// [`Mode::seal`].
-    fn seal<A, I>(s: <Self::Mode as Mode>::ParseSuccess<A, I>) -> A {
+    fn seal<A, I>(s: ParseSuccessP<Self, A, I>) -> A {
         <Self::Mode as Mode>::seal(s)
     }
 
     /// [`Mode::xmap_err`].
     fn xmap_err<A, E0, E1>(
-        result: <Self::Mode as Mode>::ExtensionResult<A, E0>,
+        result: ExtensionResultP<Self, A, E0>,
         f: impl FnOnce(E0) -> E1,
-    ) -> <Self::Mode as Mode>::ExtensionResult<A, E1> {
+    ) -> ExtensionResultP<Self, A, E1> {
         <Self::Mode as Mode>::xmap_err(result, f)
     }
 
     /// [`Mode::xbind`].
     fn xbind<A0, A1, E>(
-        result: <Self::Mode as Mode>::ExtensionResult<A0, E>,
+        result: ExtensionResultP<Self, A0, E>,
         f: impl FnOnce(A0) -> Result<A1, E>,
-    ) -> <Self::Mode as Mode>::ExtensionResult<A1, E> {
+    ) -> ExtensionResultP<Self, A1, E> {
         <Self::Mode as Mode>::xbind(result, f)
     }
 
     /// [`Mode::xseal`].
-    fn xseal<A, E>(result: <Self::Mode as Mode>::ExtensionResult<A, E>) -> Result<A, E> {
+    fn xseal<A, E>(result: ExtensionResultP<Self, A, E>) -> Result<A, E> {
         <Self::Mode as Mode>::xseal(result)
     }
 
     /// [`Mode::smap`].
     fn smap<A0, A1>(
-        source: <Self::Mode as Mode>::ExtensionSource<A0>,
+        source: ExtensionSourceP<Self, A0>,
         f: impl FnOnce(A0) -> A1,
-    ) -> <Self::Mode as Mode>::ExtensionSource<A1> {
+    ) -> ExtensionSourceP<Self, A1> {
         <Self::Mode as Mode>::smap(source, f)
     }
 
     /// [`Mode::prepare`].
-    fn prepare<A>(a: A) -> <Self::Mode as Mode>::ExtensionSource<A> {
+    fn prepare<A>(a: A) -> ExtensionSourceP<Self, A> {
         <Self::Mode as Mode>::prepare(a)
     }
 
     /// [`Mode::xsbind`].
     fn xsbind<AB, A, B, E>(
-        ab: <Self::Mode as Mode>::ExtensionSource<AB>,
+        ab: ExtensionSourceP<Self, AB>,
         t2ab: impl FnOnce(AB) -> (A, B),
-        ce: impl FnOnce(
+        ce: impl FnOnce(ExtensionSourceP<Self, B>) -> ExtensionResultP<Self, B, E>,
-            <Self::Mode as Mode>::ExtensionSource<B>,
-        ) -> <Self::Mode as Mode>::ExtensionResult<B, E>,
         ab2t: impl FnOnce(A, B) -> Result<AB, E>,
-    ) -> <Self::Mode as Mode>::ExtensionResult<AB, E> {
+    ) -> ExtensionResultP<Self, AB, E> {
         <Self::Mode as Mode>::xsbind(ab, t2ab, ce, ab2t)
     }
 }
@@ -219,10 +217,7 @@ impl<'a, Ctx: Context<'a>, F: FactoryModeParse<'a, Ctx>> FactoryParse<'a, Ctx> f
     }
 
     fn extend(&self, mentionable: Self::Mtbl, tail: &[u8]) -> ParseResult<'a, Ctx, Self> {
-        <<Self as ParseMode>::Mode as Mode>::xseal(self.mextend(
+        Self::xseal(self.mextend(Self::prepare(mentionable), tail))
-            <<Self as ParseMode>::Mode as Mode>::prepare(mentionable),
-            tail,
-        ))
     }
 }
 
@@ -233,14 +228,12 @@ where
     type _Mtbl = Self::Mtbl;
 }
 
-pub type ParseResultM<'a, Ctx, F, I> =
+pub type ParseResultM<'a, Ctx, F, I> = ModeResultP<F, Mtbl<'a, Ctx, F>, ParseError<'a, Ctx, F>, I>;
-    ModeResult<<F as ParseMode>::Mode, Mtbl<'a, Ctx, F>, ParseError<'a, Ctx, F>, I>;
 
 pub type ExtensionResultM<'a, Ctx, F> =
-    <<F as ParseMode>::Mode as Mode>::ExtensionResult<Mtbl<'a, Ctx, F>, ParseError<'a, Ctx, F>>;
+    ExtensionResultP<F, Mtbl<'a, Ctx, F>, ParseError<'a, Ctx, F>>;
 
-pub type ExtensionSourceM<'a, Ctx, F> =
+pub type ExtensionSourceM<'a, Ctx, F> = ExtensionSourceP<F, Mtbl<'a, Ctx, F>>;
-    <<F as ParseMode>::Mode as Mode>::ExtensionSource<Mtbl<'a, Ctx, F>>;
 
 pub trait FactoryModeParse<'a, Ctx: Context<'a>>: FactoryBase<'a, Ctx> + ParseMode {
     fn mdeserialize<I: InCtx<'a, Ctx>>(&self, inctx: I) -> ParseResultM<'a, Ctx, Self, I>;

src/rstd/atomic/modes.rs

@@ -10,12 +10,11 @@ impl<A: AtomicModeParse> Atomic for A {
     }
 }
 
-pub type AParseResultM<A, I> = ModeResult<<A as ParseMode>::Mode, A, AParseError<A>, I>;
+pub type AParseResultM<A, I> = ModeResultP<A, A, AParseError<A>, I>;
 
-pub type AExtensionResultM<A> =
+pub type AExtensionResultM<A> = ExtensionResultP<A, A, AParseError<A>>;
-    <<A as ParseMode>::Mode as Mode>::ExtensionResult<A, AParseError<A>>;
 
-pub type AExtensionSourceM<A> = <<A as ParseMode>::Mode as Mode>::ExtensionSource<A>;
+pub type AExtensionSourceM<A> = ExtensionSourceP<A, A>;
 
 pub trait AtomicModeParse: AtomicBase + ParseMode {
     fn ma_deserialize<I: Inlining>(inlining: I) -> AParseResultM<Self, I>;