ParseSealed was a mistake

src/atomic.rs

@@ -56,19 +56,19 @@ pub trait Atomic: AtomicModeParse {
     fn a_extend(self, tail: &[u8]) -> AParseResult<Self>;
 }
 
-fn _parse_slice<A: AtomicModeParse>(slice: &[u8]) -> AParseResult<A> {
+fn _parse_slice<A: Atomic>(slice: &[u8]) -> AParseResult<A> {
     let mut deserializer = SliceDeserializer::from(slice);
-    let atomic = A::seal(A::ma_deserialize(&mut deserializer)?);
+    let atomic = A::a_deserialize(&mut deserializer)?;
     let tail = deserializer.read_all();
     if tail.is_empty() {
         Ok(atomic)
     } else {
-        A::xseal(A::ma_extend(A::prepare(atomic), tail))
+        atomic.a_extend(tail)
     }
 }
 
 /// Extension trait to provide method-like utilities associated with [Atomic]s.
-pub trait AtomicExt: AtomicModeParse {
+pub trait AtomicExt: Atomic {
     /// Static equivalent of [`FactoryExt::parse_slice`].
     ///
     /// [`FactoryExt::parse_slice`]: crate::rcore::FactoryExt::parse_slice

src/mode.rs

@@ -29,8 +29,6 @@ pub use self::stream::{Stream, StreamExt, StreamResultExt};
 /// See [`ModeResult`].
 pub type ParseSuccess<M, A, I> = <M as Mode>::ParseSuccess<A, I>;
 
-pub type ParseSealed<M, A> = <M as Mode>::ParseSealed<A>;
-
 /// [`Mode`] equivalent of [`ParseResult`] for extension.
 ///
 /// [`ParseResult`]: crate::rcore::ParseResult
@@ -61,9 +59,6 @@ pub trait Mode {
     /// (`I`, usually [`Stream`]).
     type ParseSuccess<A, I>;
 
-    /// Parse success with parser discarded.
-    type ParseSealed<A>;
-
     /// Result of extending the value, failing sometimes or always.
     type ExtensionResult<A, E>;
 
@@ -145,9 +140,6 @@ pub trait ParseMode {
 /// [`ParseMode`] equivalent of [`ParseSuccess`].
 pub type ParseSuccessP<F, A, I> = ParseSuccess<<F as ParseMode>::Mode, A, I>;
 
-/// [`ParseMode`] equivalent of [`ParseSealed`].
-pub type ParseSealedP<F, A> = ParseSealed<<F as ParseMode>::Mode, A>;
-
 /// [`ParseMode`] equivalent of [`ExtensionResult`].
 pub type ExtensionResultP<F, A, E> = ExtensionResult<<F as ParseMode>::Mode, A, E>;
 

src/mode/inlining.rs

@@ -10,9 +10,6 @@ impl Mode for InliningMode {
     /// Keeps the parser.
     type ParseSuccess<A, I> = (A, I);
 
-    /// Keep value as is.
-    type ParseSealed<A> = A;
-
     /// Always fails.
     type ExtensionResult<A, E> = E;
 

src/mode/regular.rs

@@ -10,9 +10,6 @@ impl Mode for RegularMode {
     /// Discards the parser.
     type ParseSuccess<A, I> = A;
 
-    /// Keep value as is.
-    type ParseSealed<A> = A;
-
     /// Tries to extend the value.
     type ExtensionResult<A, E> = Result<A, E>;
 

src/rcore.rs

@@ -136,7 +136,7 @@ pub type ParseError<'a, Ctx, F> = <F as FactoryBase<'a, Ctx>>::ParseError;
 pub type ParseErrorA<'a, Ctx, A> = ParseError<'a, Ctx, Fctr<'a, Ctx, A>>;
 
 /// Extension trait for factories.
-pub trait FactoryExt<'a, Ctx: Context<'a>>: FactoryModeParse<'a, Ctx> {
+pub trait FactoryExt<'a, Ctx: Context<'a>>: FactoryParse<'a, Ctx> {
     /// Parse the object from a slice.
     fn parse_slice(
         &self,

src/rcore/addresses.rs

@@ -55,26 +55,26 @@ pub(super) trait InliningAddresses<E>: Stream {
 
 impl<E, D: ?Sized + Stream> InliningAddresses<E> for D {}
 
-fn _parse_slice<'a, Ctx: Context<'a>, F: FactoryModeParse<'a, Ctx>>(
+fn _parse_slice<'a, Ctx: Context<'a>, F: FactoryParse<'a, Ctx>>(
     factory: &F,
     slice: &[u8],
     resolver: &Rc<dyn Resolver<'a, Ctx>>,
 ) -> ParseResult<'a, Ctx, F> {
     let mut deserializer = SliceDeserializer::from(slice);
-    let mentionable = F::seal(factory.mdeserialize(&mut DeCtxT {
+    let mentionable = factory.deserialize(&mut DeCtxT {
         deserializer: &mut deserializer,
         resolver,
         addresses: &mut Addresses::start(),
-    } as &mut dyn DeCtx<'a, Ctx>)?);
+    } as &mut dyn DeCtx<'a, Ctx>)?;
     let tail = deserializer.read_all();
     if tail.is_empty() {
         Ok(mentionable)
     } else {
-        F::xseal(factory.mextend(F::prepare(mentionable), tail))
+        factory.extend(mentionable, tail)
     }
 }
 
-impl<'a, Ctx: Context<'a>, F: FactoryModeParse<'a, Ctx>> FactoryExt<'a, Ctx> for F {
+impl<'a, Ctx: Context<'a>, F: FactoryParse<'a, Ctx>> FactoryExt<'a, Ctx> for F {
     fn parse_slice(
         &self,
         slice: &[u8],