mode::inlining

src/mode.rs

@@ -1,3 +1,4 @@
+mod inlining;
 mod regular;
 mod serialization;
 mod slice_deserializer;
@@ -5,6 +6,7 @@ mod stream;
 
 use std::marker::PhantomData;
 
+pub use self::inlining::InliningMode;
 pub use self::regular::RegularMode;
 pub use self::serialization::{Deserializer, DeserializerExt, Serializable, Serializer};
 pub use self::slice_deserializer::SliceDeserializer;
@@ -33,7 +35,6 @@ pub type ModeResult<M, A, E, I> = Result<ParseSuccess<M, A, I>, E>;
 /// | [`RegularMode`]  | `A`                          | [`Result<A, E>`]                | `A`                          |
 /// | [`InliningMode`] | [`(A, I)`]                   | `E`                             | [`()`]                       |
 ///
-/// [`InliningMode`]: crate::rstd::inlining::InliningMode
 /// [`(A, I)`]: tuple
 /// [`()`]: unit
 pub trait Mode {

src/mode/inlining.rs

@@ -0,0 +1,74 @@
+use super::*;
+
+/// [`Mode`] for [`InliningFactory`].
+///
+/// [`InliningFactory`]: crate::rstd::inlining::InliningFactory
+/// [`InliningAtomic`]: crate::rstd::atomic::InliningAtomic
+pub struct InliningMode;
+
+impl Mode for InliningMode {
+    /// Keeps the parser.
+    type ParseSuccess<A, I> = (A, I);
+
+    /// Always fails.
+    type ExtensionResult<A, E> = E;
+
+    /// Discards the value.
+    type ExtensionSource<A> = ();
+
+    fn bind<A0, A1, E, I>(
+        s: Self::ParseSuccess<A0, I>,
+        f: impl FnOnce(A0) -> Result<A1, E>,
+    ) -> ModeResult<Self, A1, E, I> {
+        let (a0, i) = s;
+        let a1 = f(a0)?;
+        Ok((a1, i))
+    }
+
+    fn map<A0, A1, I>(
+        s: Self::ParseSuccess<A0, I>,
+        f: impl FnOnce(A0) -> A1,
+    ) -> Self::ParseSuccess<A1, I> {
+        (f(s.0), s.1)
+    }
+
+    fn seal<A, I>(s: Self::ParseSuccess<A, I>) -> A {
+        s.0
+    }
+
+    fn xmap_err<A, E0, E1>(
+        result: Self::ExtensionResult<A, E0>,
+        f: impl FnOnce(E0) -> E1,
+    ) -> Self::ExtensionResult<A, E1> {
+        f(result)
+    }
+
+    fn xbind<A0, A1, E>(
+        result: Self::ExtensionResult<A0, E>,
+        _f: impl FnOnce(A0) -> Result<A1, E>,
+    ) -> Self::ExtensionResult<A1, E> {
+        result
+    }
+
+    fn xseal<A, E>(result: Self::ExtensionResult<A, E>) -> Result<A, E> {
+        Err(result)
+    }
+
+    fn smap<A0, A1>(
+        source: Self::ExtensionSource<A0>,
+        _f: impl FnOnce(A0) -> A1,
+    ) -> Self::ExtensionSource<A1> {
+        source
+    }
+
+    fn prepare<A>(_a: A) -> Self::ExtensionSource<A> {}
+
+    fn xsbind<AB, A, B, E>(
+        _ab: Self::ExtensionSource<AB>,
+        _t2ab: impl FnOnce(AB) -> (A, B),
+        ce: impl FnOnce(Self::ExtensionSource<B>) -> Self::ExtensionResult<B, E>,
+        _ab2t: impl FnOnce(A, B) -> Result<AB, E>,
+    ) -> Self::ExtensionResult<AB, E> {
+        ce(())
+    }
+}

src/rstd/inlining.rs

@@ -11,8 +11,6 @@ use super::{
     *,
 };
 
-pub use self::modes::InliningMode;
-
 pub type IParseResult<'a, Ctx, F, I> = Result<(Mtbl<'a, Ctx, F>, I), ParseError<'a, Ctx, F>>;
 
 pub trait CInliningFactory<'a, Ctx: Context<'a>>:

src/rstd/inlining/modes.rs

@@ -2,76 +2,6 @@ use crate::mode::*;
 
 use super::*;
 
-/// [`Mode`] for [`InliningFactory`].
-pub struct InliningMode;
-
-impl Mode for InliningMode {
-    /// Keeps the parser.
-    type ParseSuccess<A, I> = (A, I);
-
-    /// Always fails.
-    type ExtensionResult<A, E> = E;
-
-    /// Discards the value.
-    type ExtensionSource<A> = ();
-
-    fn bind<A0, A1, E, I>(
-        s: Self::ParseSuccess<A0, I>,
-        f: impl FnOnce(A0) -> Result<A1, E>,
-    ) -> ModeResult<Self, A1, E, I> {
-        let (a0, i) = s;
-        let a1 = f(a0)?;
-        Ok((a1, i))
-    }
-
-    fn map<A0, A1, I>(
-        s: Self::ParseSuccess<A0, I>,
-        f: impl FnOnce(A0) -> A1,
-    ) -> Self::ParseSuccess<A1, I> {
-        (f(s.0), s.1)
-    }
-
-    fn seal<A, I>(s: Self::ParseSuccess<A, I>) -> A {
-        s.0
-    }
-
-    fn xmap_err<A, E0, E1>(
-        result: Self::ExtensionResult<A, E0>,
-        f: impl FnOnce(E0) -> E1,
-    ) -> Self::ExtensionResult<A, E1> {
-        f(result)
-    }
-
-    fn xbind<A0, A1, E>(
-        result: Self::ExtensionResult<A0, E>,
-        _f: impl FnOnce(A0) -> Result<A1, E>,
-    ) -> Self::ExtensionResult<A1, E> {
-        result
-    }
-
-    fn xseal<A, E>(result: Self::ExtensionResult<A, E>) -> Result<A, E> {
-        Err(result)
-    }
-
-    fn smap<A0, A1>(
-        source: Self::ExtensionSource<A0>,
-        _f: impl FnOnce(A0) -> A1,
-    ) -> Self::ExtensionSource<A1> {
-        source
-    }
-
-    fn prepare<A>(_a: A) -> Self::ExtensionSource<A> {}
-
-    fn xsbind<AB, A, B, E>(
-        _ab: Self::ExtensionSource<AB>,
-        _t2ab: impl FnOnce(AB) -> (A, B),
-        ce: impl FnOnce(Self::ExtensionSource<B>) -> Self::ExtensionResult<B, E>,
-        _ab2t: impl FnOnce(A, B) -> Result<AB, E>,
-    ) -> Self::ExtensionResult<AB, E> {
-        ce(())
-    }
-}
-
 impl<'a, Ctx: Context<'a>, F: CInliningFactory<'a, Ctx>> FactoryModeProxy<'a, Ctx>
     for WithMode<F, InliningMode>
 {