core: downcast::<Option<_>>().take() hack in userspace

Author: oscartbeaumont

crates/binario/src/lib.rs

@@ -50,8 +50,11 @@ impl<T: Decode + Type + Send + 'static> ResolverInput for TypedBinarioInput<T> {
         T::inline(types, Generics::Definition)
     }
 
-    fn from_input(input: DynInput) -> Result<Self, ProcedureError> {
-        Ok(Self(input.value()?, PhantomData))
+    fn from_input(mut input: DynInput) -> Result<Self, ProcedureError> {
+        Ok(Self(
+            input.value::<Option<_>>()?.take().expect("unreachable"),
+            PhantomData,
+        ))
     }
 }
 

crates/procedure/src/dyn_input.rs

@@ -21,8 +21,8 @@ enum Repr<'a, 'de> {
 }
 
 impl<'a, 'de> DynInput<'a, 'de> {
-    // TODO: Explain invariant on `Option` + enforce it
-    pub fn new_value<T: Send + 'static>(value: &'a mut Option<T>) -> Self {
+    // TODO: Discuss using `Option` as a workaround for ownership
+    pub fn new_value<T: Send + 'static>(value: &'a mut T) -> Self {
         Self {
             inner: Repr::Value(value),
             type_name: type_name::<T>(),
@@ -55,23 +55,18 @@ impl<'a, 'de> DynInput<'a, 'de> {
     }
 
     /// TODO
-    pub fn value<T: 'static>(self) -> Result<T, ProcedureError> {
-        let Repr::Value(value) = self.inner else {
+    pub fn value<T: 'static>(&mut self) -> Result<&mut T, ProcedureError> {
+        let Repr::Value(ref mut value) = self.inner else {
             return Err(DowncastError {
                 from: None,
                 to: type_name::<T>(),
             }
             .into());
         };
-        Ok(value
-            .downcast_mut::<Option<T>>()
-            .ok_or(DowncastError {
-                from: Some(self.type_name),
-                to: type_name::<T>(),
-            })?
-            .take()
-            // This takes method takes `self` and it's not `Clone` so it's not possible to double take the value.
-            .expect("unreachable"))
+        Ok(value.downcast_mut::<T>().ok_or(DowncastError {
+            from: Some(self.type_name),
+            to: type_name::<T>(),
+        })?)
     }
 }
 

crates/procedure/src/procedure.rs

@@ -50,15 +50,6 @@ impl<TCtx> Procedure<TCtx> {
             .map_err(|err| ProcedureError::Unwind(err).into());
         v
     }
-
-    pub fn exec_with_value<T: Send + 'static>(&self, ctx: TCtx, input: T) -> ProcedureStream {
-        let mut input = Some(input);
-        let value = DynInput::new_value(&mut input);
-
-        let (Ok(v) | Err(v)) = catch_unwind(AssertUnwindSafe(|| (self.handler)(ctx, value)))
-            .map_err(|err| ProcedureError::Unwind(err).into());
-        v
-    }
 }
 
 impl<TCtx> Clone for Procedure<TCtx> {