Method refactor now compiles

orchid-std/src/std/number/num_atom.rs

@@ -1,9 +1,12 @@
+use std::io;
+
 use orchid_api_derive::{Coding, Hierarchy};
 use orchid_api_traits::Request;
 use orchid_base::error::OrcRes;
 use orchid_base::format::FmtUnit;
 use orchid_base::name::Sym;
 use orchid_base::number::Numeric;
+use orchid_base::reqnot::{Receipt, ReqHandle, ReqHandleExt};
 use orchid_base::sym;
 use orchid_extension::atom::{Atomic, MethodSetBuilder, Supports, TAtom};
 use orchid_extension::atom_thin::{ThinAtom, ThinVariant};
@@ -14,7 +17,7 @@ use orchid_extension::system::sys_req;
 use ordered_float::NotNan;
 use rust_decimal::prelude::Zero;
 
-use crate::std::protocol::types::{GetImplMethod, GetTagIdMethod};
+use crate::std::protocol::types::{GetImpl, ProtocolMethod};
 use crate::std::std_system::StdReq;
 use crate::std::string::to_string::ToStringMethod;
 use crate::{StdSystem, api};
@@ -32,10 +35,7 @@ impl Atomic for Int {
 	type Variant = ThinVariant;
 	type Data = Self;
 	fn reg_reqs() -> MethodSetBuilder<Self> {
-		MethodSetBuilder::new()
-			.handle::<GetTagIdMethod>()
-			.handle::<GetImplMethod>()
-			.handle::<ToStringMethod>()
+		MethodSetBuilder::new().handle::<ProtocolMethod>().handle::<ToStringMethod>()
 	}
 }
 impl ThinAtom for Int {
@@ -51,33 +51,41 @@ impl ToExpr for Int {
 		Expr::deserialize(sys_req::<StdSystem, _>(CreateInt(self)).await).await.to_gen().await
 	}
 }
-impl Supports<GetTagIdMethod> for Int {
-	async fn handle(&self, _: GetTagIdMethod) -> <GetTagIdMethod as Request>::Response {
-		sym!(std::number::Int).to_api()
-	}
-}
-impl Supports<GetImplMethod> for Int {
-	async fn handle(&self, req: GetImplMethod) -> <GetImplMethod as Request>::Response {
-		let name = Sym::from_api(req.0).await;
-		let val = if name == sym!(std::ops::add) {
-			sym_ref(sym!(std::number::add))
-		} else if name == sym!(std::ops::sub) {
-			sym_ref(sym!(std::number::sub))
-		} else if name == sym!(std::ops::mul) {
-			sym_ref(sym!(std::number::mul))
-		} else if name == sym!(std::ops::div) {
-			sym_ref(sym!(std::number::idiv))
-		} else if name == sym!(std::ops::mod) {
-			sym_ref(sym!(std::number::imod))
-		} else {
-			return None;
-		};
-		Some(val.create().await.serialize().await)
+impl Supports<ProtocolMethod> for Int {
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn ReqHandle<'a> + '_>,
+		req: ProtocolMethod,
+	) -> io::Result<Receipt<'a>> {
+		match req {
+			ProtocolMethod::GetTagId(req) => hand.reply(&req, &sym!(std::number::Int).to_api()).await,
+			ProtocolMethod::GetImpl(ref req @ GetImpl(key)) => {
+				let name = Sym::from_api(key).await;
+				let val = if name == sym!(std::ops::add) {
+					sym_ref(sym!(std::number::add))
+				} else if name == sym!(std::ops::sub) {
+					sym_ref(sym!(std::number::sub))
+				} else if name == sym!(std::ops::mul) {
+					sym_ref(sym!(std::number::mul))
+				} else if name == sym!(std::ops::div) {
+					sym_ref(sym!(std::number::idiv))
+				} else if name == sym!(std::ops::mod) {
+					sym_ref(sym!(std::number::imod))
+				} else {
+					return hand.reply(req, &None).await;
+				};
+				hand.reply(req, &Some(val.create().await.serialize().await)).await
+			},
+		}
 	}
 }
 impl Supports<ToStringMethod> for Int {
-	async fn handle(&self, _: ToStringMethod) -> <ToStringMethod as Request>::Response {
-		self.0.to_string()
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn ReqHandle<'a> + '_>,
+		req: ToStringMethod,
+	) -> io::Result<Receipt<'a>> {
+		hand.reply(&req, &self.0.to_string()).await
 	}
 }
 
@@ -94,10 +102,7 @@ impl Atomic for Float {
 	type Variant = ThinVariant;
 	type Data = Self;
 	fn reg_reqs() -> MethodSetBuilder<Self> {
-		MethodSetBuilder::new()
-			.handle::<GetTagIdMethod>()
-			.handle::<GetImplMethod>()
-			.handle::<ToStringMethod>()
+		MethodSetBuilder::new().handle::<ProtocolMethod>().handle::<ToStringMethod>()
 	}
 }
 impl ThinAtom for Float {
@@ -113,33 +118,41 @@ impl ToExpr for Float {
 		Expr::deserialize(sys_req::<StdSystem, _>(CreateFloat(self)).await).await.to_gen().await
 	}
 }
-impl Supports<GetTagIdMethod> for Float {
-	async fn handle(&self, _: GetTagIdMethod) -> <GetTagIdMethod as Request>::Response {
-		sym!(std::number::Float).to_api()
-	}
-}
-impl Supports<GetImplMethod> for Float {
-	async fn handle(&self, req: GetImplMethod) -> <GetImplMethod as Request>::Response {
-		let name = Sym::from_api(req.0).await;
-		let val = if name == sym!(std::ops::add) {
-			sym_ref(sym!(std::number::add))
-		} else if name == sym!(std::ops::sub) {
-			sym_ref(sym!(std::number::sub))
-		} else if name == sym!(std::ops::mul) {
-			sym_ref(sym!(std::number::mul))
-		} else if name == sym!(std::ops::div) {
-			sym_ref(sym!(std::number::fdiv))
-		} else if name == sym!(std::ops::mod) {
-			sym_ref(sym!(std::number::fmod))
-		} else {
-			return None;
-		};
-		Some(val.create().await.serialize().await)
+impl Supports<ProtocolMethod> for Float {
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn ReqHandle<'a> + '_>,
+		req: ProtocolMethod,
+	) -> io::Result<Receipt<'a>> {
+		match req {
+			ProtocolMethod::GetTagId(req) => hand.reply(&req, &sym!(std::number::Float).to_api()).await,
+			ProtocolMethod::GetImpl(ref req @ GetImpl(key)) => {
+				let name = Sym::from_api(key).await;
+				let val = if name == sym!(std::ops::add) {
+					sym_ref(sym!(std::number::add))
+				} else if name == sym!(std::ops::sub) {
+					sym_ref(sym!(std::number::sub))
+				} else if name == sym!(std::ops::mul) {
+					sym_ref(sym!(std::number::mul))
+				} else if name == sym!(std::ops::div) {
+					sym_ref(sym!(std::number::fdiv))
+				} else if name == sym!(std::ops::mod) {
+					sym_ref(sym!(std::number::fmod))
+				} else {
+					return hand.reply(req, &None).await;
+				};
+				hand.reply(req, &Some(val.create().await.serialize().await)).await
+			},
+		}
 	}
 }
 impl Supports<ToStringMethod> for Float {
-	async fn handle(&self, _: ToStringMethod) -> <ToStringMethod as Request>::Response {
-		self.0.to_string()
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn ReqHandle<'a> + '_>,
+		req: ToStringMethod,
+	) -> io::Result<Receipt<'a>> {
+		hand.reply(&req, &self.0.to_string()).await
 	}
 }
 

orchid-std/src/std/protocol/types.rs

@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 use std::cell::RefCell;
+use std::io;
 use std::rc::Rc;
 
 use futures::FutureExt;
@@ -13,6 +14,7 @@ use orchid_base::error::{OrcRes, mk_errv};
 use orchid_base::format::fmt;
 use orchid_base::interner::{ev, is};
 use orchid_base::name::{NameLike, Sym, VName};
+use orchid_base::reqnot::ReqHandleExt;
 use orchid_extension::atom::{AtomMethod, Atomic, ForeignAtom, MethodSetBuilder, Supports, TAtom};
 use orchid_extension::atom_owned::{OwnedAtom, OwnedVariant, own};
 use orchid_extension::conv::{ClonableToExprDyn, ToExpr};
@@ -33,40 +35,48 @@ pub struct Tag {
 impl Atomic for Tag {
 	type Data = api::TStrv;
 	type Variant = OwnedVariant;
-	fn reg_reqs() -> MethodSetBuilder<Self> {
-		MethodSetBuilder::new().handle::<GetTagIdMethod>().handle::<GetImplMethod>()
-	}
+	fn reg_reqs() -> MethodSetBuilder<Self> { MethodSetBuilder::new().handle::<ProtocolMethod>() }
 }
 impl OwnedAtom for Tag {
 	type Refs = Never;
 	async fn val(&self) -> Cow<'_, Self::Data> { Cow::Owned(self.id.to_api()) }
 }
-impl Supports<GetTagIdMethod> for Tag {
-	async fn handle(&self, _: GetTagIdMethod) -> <GetTagIdMethod as Request>::Response {
-		self.id.to_api()
-	}
-}
-impl Supports<GetImplMethod> for Tag {
-	async fn handle(&self, req: GetImplMethod) -> <GetImplMethod as Request>::Response {
-		self.impls.get(&Sym::from_api(req.0).await).map(|expr| expr.handle().ticket())
+impl Supports<ProtocolMethod> for Tag {
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn orchid_base::reqnot::ReqHandle<'a> + '_>,
+		req: ProtocolMethod,
+	) -> std::io::Result<orchid_base::reqnot::Receipt<'a>> {
+		match req {
+			ProtocolMethod::GetTagId(req) => hand.reply(&req, &self.id.to_api()).await,
+			ProtocolMethod::GetImpl(ref req @ GetImpl(key)) =>
+				hand
+					.reply(req, &self.impls.get(&Sym::from_api(key).await).map(|expr| expr.handle().ticket()))
+					.await,
+		}
 	}
 }
 
-#[derive(Clone, Debug, Coding)]
-pub struct GetImplMethod(pub api::TStrv);
-impl Request for GetImplMethod {
+#[derive(Clone, Debug, Coding, Hierarchy)]
+#[extends(ProtocolMethod)]
+pub struct GetImpl(pub api::TStrv);
+impl Request for GetImpl {
 	type Response = Option<api::ExprTicket>;
 }
-impl AtomMethod for GetImplMethod {
-	const NAME: &str = "std::protocol::get_impl";
-}
-#[derive(Clone, Debug, Coding)]
-pub struct GetTagIdMethod;
-impl Request for GetTagIdMethod {
+#[derive(Clone, Debug, Coding, Hierarchy)]
+#[extends(ProtocolMethod)]
+pub struct GetTagId;
+impl Request for GetTagId {
 	type Response = api::TStrv;
 }
-impl AtomMethod for GetTagIdMethod {
-	const NAME: &str = "std::protocol::get_tag_id";
+#[derive(Clone, Debug, Coding, Hierarchy)]
+#[extendable]
+pub enum ProtocolMethod {
+	GetTagId(GetTagId),
+	GetImpl(GetImpl),
+}
+impl AtomMethod for ProtocolMethod {
+	const NAME: &str = "std::protocol";
 }
 
 #[derive(Clone, Debug)]
@@ -82,21 +92,25 @@ impl OwnedAtom for Tagged {
 	type Refs = Never;
 	async fn val(&self) -> Cow<'_, Self::Data> { Cow::Owned(self.tag.id.to_api()) }
 }
-impl Supports<GetImplMethod> for Tagged {
-	async fn handle(&self, req: GetImplMethod) -> <GetImplMethod as Request>::Response {
-		self.tag.handle(req).await
+impl Supports<ProtocolMethod> for Tagged {
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn orchid_base::reqnot::ReqHandle<'a> + '_>,
+		req: ProtocolMethod,
+	) -> io::Result<orchid_base::reqnot::Receipt<'a>> {
+		self.tag.handle(hand, req).await
 	}
 }
 
 pub async fn get_impl(receiver: ForeignAtom, proto: ForeignAtom) -> OrcRes<Expr> {
-	let Some(proto_id) = proto.request(GetTagIdMethod).await else {
+	let Some(proto_id) = proto.request(GetTagId).await else {
 		return Err(mk_errv(
 			is("Not a protocol").await,
 			format!("Protocol ({}) does not have a tag ID", fmt(&proto).await),
 			[proto.pos()],
 		));
 	};
-	let Some(impl_val_opt) = receiver.request(GetImplMethod(proto_id)).await else {
+	let Some(impl_val_opt) = receiver.request(GetImpl(proto_id)).await else {
 		return Err(mk_errv(
 			is("Receiver not tagged").await,
 			format!("The receiver ({}) does not have a type tag", fmt(&receiver).await),
@@ -106,14 +120,14 @@ pub async fn get_impl(receiver: ForeignAtom, proto: ForeignAtom) -> OrcRes<Expr>
 	if let Some(impl_val) = impl_val_opt {
 		return Ok(Expr::deserialize(impl_val).await);
 	}
-	let Some(type_id) = receiver.request(GetTagIdMethod).await else {
+	let Some(type_id) = receiver.request(GetTagId).await else {
 		return Err(mk_errv(
 			is("Incorrect protocols implementation in extension").await,
 			format!("The receiver ({}) provides an impl table but no tag ID", fmt(&receiver).await),
 			[receiver.pos()],
 		));
 	};
-	let Some(impl_val_opt) = proto.request(GetImplMethod(type_id)).await else {
+	let Some(impl_val_opt) = proto.request(GetImpl(type_id)).await else {
 		return Err(mk_errv(
 			is("Incorrect protocols implementation in extension").await,
 			format!("Protocol ({}) provides a tag ID but no impl table", fmt(&proto).await),

orchid-std/src/std/record/record_atom.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::io;
 use std::pin::Pin;
 use std::rc::Rc;
 
@@ -9,6 +10,7 @@ use orchid_api_derive::Coding;
 use orchid_api_traits::{Encode, Request};
 use orchid_base::interner::{IStr, es};
 use orchid_base::name::Sym;
+use orchid_base::reqnot::{Receipt, ReqHandle, ReqHandleExt};
 use orchid_base::sym;
 use orchid_extension::atom::{Atomic, MethodSetBuilder, Supports};
 use orchid_extension::atom_owned::{DeserializeCtx, OwnedAtom, OwnedVariant};
@@ -16,16 +18,14 @@ use orchid_extension::expr::Expr;
 use orchid_extension::gen_expr::sym_ref;
 
 use crate::api;
-use crate::std::protocol::types::{GetImplMethod, GetTagIdMethod};
+use crate::std::protocol::types::{GetImpl, ProtocolMethod};
 
 #[derive(Clone)]
 pub struct RecordAtom(pub Rc<HashMap<IStr, Expr>>);
 impl Atomic for RecordAtom {
 	type Data = ();
 	type Variant = OwnedVariant;
-	fn reg_reqs() -> MethodSetBuilder<Self> {
-		MethodSetBuilder::new().handle::<GetTagIdMethod>().handle::<GetImplMethod>()
-	}
+	fn reg_reqs() -> MethodSetBuilder<Self> { MethodSetBuilder::new().handle::<ProtocolMethod>() }
 }
 impl OwnedAtom for RecordAtom {
 	type Refs = Vec<Expr>;
@@ -43,22 +43,26 @@ impl OwnedAtom for RecordAtom {
 
 	async fn val(&self) -> Cow<'_, Self::Data> { Cow::Owned(()) }
 }
-impl Supports<GetTagIdMethod> for RecordAtom {
-	async fn handle(&self, _: GetTagIdMethod) -> <GetTagIdMethod as Request>::Response {
-		sym!(std::record::Record).to_api()
-	}
-}
-impl Supports<GetImplMethod> for RecordAtom {
-	async fn handle(&self, req: GetImplMethod) -> <GetImplMethod as Request>::Response {
-		let name = Sym::from_api(req.0).await;
-		let val = if name == sym!(std::ops::get) {
-			sym_ref(sym!(std::record::get))
-		} else if name == sym!(std::ops::set) {
-			sym_ref(sym!(std::record::set))
-		} else {
-			return None;
-		};
-		Some(val.create().await.serialize().await)
+impl Supports<ProtocolMethod> for RecordAtom {
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn ReqHandle<'a> + '_>,
+		req: ProtocolMethod,
+	) -> io::Result<Receipt<'a>> {
+		match req {
+			ProtocolMethod::GetTagId(req) => hand.reply(&req, &sym!(std::record::Record).to_api()).await,
+			ProtocolMethod::GetImpl(ref req @ GetImpl(key)) => {
+				let name = Sym::from_api(key).await;
+				let val = if name == sym!(std::ops::get) {
+					sym_ref(sym!(std::record::get))
+				} else if name == sym!(std::ops::set) {
+					sym_ref(sym!(std::record::set))
+				} else {
+					return hand.reply(req, &None).await;
+				};
+				return hand.reply(req, &Some(val.create().await.serialize().await)).await;
+			},
+		}
 	}
 }
 

orchid-std/src/std/reflection/sym_atom.rs

@@ -5,6 +5,7 @@ use orchid_api_traits::Request;
 use orchid_base::error::mk_errv;
 use orchid_base::interner::{es, is};
 use orchid_base::name::{NameLike, Sym};
+use orchid_base::reqnot::ReqHandleExt;
 use orchid_extension::atom::{Atomic, Supports, TAtom};
 use orchid_extension::atom_owned::{OwnedAtom, OwnedVariant, own};
 use orchid_extension::expr::{Expr, ExprHandle};
@@ -30,8 +31,12 @@ impl OwnedAtom for SymAtom {
 	async fn val(&self) -> Cow<'_, Self::Data> { Cow::Owned(SymAtomData(self.0.tok().to_api())) }
 }
 impl Supports<ToStringMethod> for SymAtom {
-	async fn handle(&self, _: ToStringMethod) -> <ToStringMethod as Request>::Response {
-		self.0.to_string()
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn orchid_base::reqnot::ReqHandle<'a> + '_>,
+		req: ToStringMethod,
+	) -> std::io::Result<orchid_base::reqnot::Receipt<'a>> {
+		hand.reply(&req, &self.0.to_string()).await
 	}
 }
 

orchid-std/src/std/string/str_atom.rs

@@ -1,15 +1,17 @@
 use std::borrow::Cow;
+use std::io;
 use std::ops::Deref;
 use std::pin::Pin;
 use std::rc::Rc;
 
 use futures::AsyncWrite;
-use orchid_api_derive::Coding;
+use orchid_api_derive::{Coding, Hierarchy};
 use orchid_api_traits::{Encode, Request};
 use orchid_base::error::{OrcRes, mk_errv};
 use orchid_base::format::{FmtCtx, FmtUnit};
 use orchid_base::interner::{IStr, es, is};
 use orchid_base::name::Sym;
+use orchid_base::reqnot::{Receipt, ReqHandle, ReqHandleExt};
 use orchid_base::sym;
 use orchid_extension::atom::{AtomMethod, Atomic, MethodSetBuilder, Supports, TAtom};
 use orchid_extension::atom_owned::{DeserializeCtx, OwnedAtom, OwnedVariant};
@@ -17,10 +19,10 @@ use orchid_extension::conv::TryFromExpr;
 use orchid_extension::expr::Expr;
 use orchid_extension::gen_expr::sym_ref;
 
-use crate::std::protocol::types::{GetImplMethod, GetTagIdMethod};
+use crate::std::protocol::types::{GetImpl, ProtocolMethod};
 use crate::std::string::to_string::ToStringMethod;
 
-#[derive(Copy, Clone, Debug, Coding)]
+#[derive(Copy, Clone, Debug, Coding, Hierarchy)]
 pub struct StringGetValMethod;
 impl Request for StringGetValMethod {
 	type Response = Rc<String>;
@@ -38,8 +40,7 @@ impl Atomic for StrAtom {
 		MethodSetBuilder::new()
 			.handle::<StringGetValMethod>()
 			.handle::<ToStringMethod>()
-			.handle::<GetTagIdMethod>()
-			.handle::<GetImplMethod>()
+			.handle::<ProtocolMethod>()
 	}
 }
 impl StrAtom {
@@ -63,29 +64,41 @@ impl OwnedAtom for StrAtom {
 	}
 }
 impl Supports<StringGetValMethod> for StrAtom {
-	async fn handle(&self, _: StringGetValMethod) -> <StringGetValMethod as Request>::Response {
-		self.0.clone()
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn ReqHandle<'a> + '_>,
+		req: StringGetValMethod,
+	) -> io::Result<Receipt<'a>> {
+		hand.reply(&req, &self.0).await
 	}
 }
 impl Supports<ToStringMethod> for StrAtom {
-	async fn handle(&self, _: ToStringMethod) -> <ToStringMethod as Request>::Response {
-		self.0.as_str().to_string()
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn ReqHandle<'a> + '_>,
+		req: ToStringMethod,
+	) -> io::Result<Receipt<'a>> {
+		hand.reply(&req, &self.0).await
 	}
 }
-impl Supports<GetTagIdMethod> for StrAtom {
-	async fn handle(&self, _: GetTagIdMethod) -> <GetTagIdMethod as Request>::Response {
-		sym!(std::string::StrAtom).to_api()
-	}
-}
-impl Supports<GetImplMethod> for StrAtom {
-	async fn handle(&self, req: GetImplMethod) -> <GetImplMethod as Request>::Response {
-		let name = Sym::from_api(req.0).await;
-		let val = if name == sym!(std::ops::add) {
-			sym_ref(sym!(std::string::concat))
-		} else {
-			return None;
-		};
-		Some(val.create().await.serialize().await)
+impl Supports<ProtocolMethod> for StrAtom {
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn ReqHandle<'a> + '_>,
+		req: ProtocolMethod,
+	) -> io::Result<Receipt<'a>> {
+		match req {
+			ProtocolMethod::GetTagId(req) => hand.reply(&req, &sym!(std::string::StrAtom).to_api()).await,
+			ProtocolMethod::GetImpl(ref req @ GetImpl(key)) => {
+				let name = Sym::from_api(key).await;
+				let val = if name == sym!(std::ops::add) {
+					sym_ref(sym!(std::string::concat))
+				} else {
+					return hand.reply(req, &None).await;
+				};
+				hand.reply(req, &Some(val.create().await.serialize().await)).await
+			},
+		}
 	}
 }
 
@@ -95,10 +108,7 @@ impl Atomic for IntStrAtom {
 	type Variant = OwnedVariant;
 	type Data = orchid_api::TStr;
 	fn reg_reqs() -> MethodSetBuilder<Self> {
-		MethodSetBuilder::new()
-			.handle::<GetTagIdMethod>()
-			.handle::<GetImplMethod>()
-			.handle::<ToStringMethod>()
+		MethodSetBuilder::new().handle::<ProtocolMethod>().handle::<ToStringMethod>()
 	}
 }
 impl From<IStr> for IntStrAtom {
@@ -124,27 +134,35 @@ impl TryFromExpr for IntStrAtom {
 	}
 }
 impl Supports<ToStringMethod> for IntStrAtom {
-	async fn handle(&self, _: ToStringMethod) -> <ToStringMethod as Request>::Response {
-		self.0.to_string()
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn ReqHandle<'a> + '_>,
+		req: ToStringMethod,
+	) -> io::Result<Receipt<'a>> {
+		hand.reply(&req, &self.0.rc()).await
 	}
 }
-impl Supports<GetTagIdMethod> for IntStrAtom {
-	async fn handle(&self, _: GetTagIdMethod) -> <GetTagIdMethod as Request>::Response {
-		sym!(std::string::IntStrAtom).to_api()
+impl Supports<ProtocolMethod> for IntStrAtom {
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn ReqHandle<'a> + '_>,
+		req: ProtocolMethod,
+	) -> io::Result<Receipt<'a>> {
+		match req {
+			ProtocolMethod::GetTagId(req) =>
+				hand.reply(&req, &sym!(std::string::IntStrAtom).to_api()).await,
+			ProtocolMethod::GetImpl(ref req @ GetImpl(key)) => {
+				let name = Sym::from_api(key).await;
+				let val = if name == sym!(std::ops::add) {
+					sym_ref(sym!(std::string::concat))
+				} else {
+					return hand.reply(req, &None).await;
+				};
+				hand.reply(req, &Some(val.create().await.serialize().await)).await
+			},
+		}
 	}
 }
-impl Supports<GetImplMethod> for IntStrAtom {
-	async fn handle(&self, req: GetImplMethod) -> <GetImplMethod as Request>::Response {
-		let name = Sym::from_api(req.0).await;
-		let val = if name == sym!(std::ops::add) {
-			sym_ref(sym!(std::string::concat))
-		} else {
-			return None;
-		};
-		Some(val.create().await.serialize().await)
-	}
-}
-
 #[derive(Clone)]
 pub struct OrcString {
 	kind: OrcStringKind,

orchid-std/src/std/string/to_string.rs

@@ -1,9 +1,9 @@
-use orchid_api_derive::Coding;
+use orchid_api_derive::{Coding, Hierarchy};
 use orchid_api_traits::Request;
 use orchid_extension::atom::AtomMethod;
 
 /// Method version of std::string::to_string protocol for atoms
-#[derive(Coding, Clone, Debug)]
+#[derive(Coding, Clone, Debug, Hierarchy)]
 pub struct ToStringMethod;
 impl Request for ToStringMethod {
 	type Response = String;

orchid-std/src/std/tuple.rs

@@ -12,6 +12,7 @@ use orchid_base::error::{OrcRes, mk_errv};
 use orchid_base::format::{FmtCtx, FmtUnit, Format, Variants};
 use orchid_base::interner::is;
 use orchid_base::name::Sym;
+use orchid_base::reqnot::ReqHandleExt;
 use orchid_base::sym;
 use orchid_extension::atom::{Atomic, MethodSetBuilder, Supports, TAtom};
 use orchid_extension::atom_owned::{DeserializeCtx, OwnedAtom, OwnedVariant, own};
@@ -21,7 +22,7 @@ use orchid_extension::gen_expr::{GExpr, new_atom, sym_ref};
 use orchid_extension::system::sys_req;
 use orchid_extension::tree::{GenMember, cnst, fun, prefix};
 
-use crate::std::protocol::types::{GetImplMethod, GetTagIdMethod};
+use crate::std::protocol::types::{GetImpl, ProtocolMethod};
 use crate::std::std_system::StdReq;
 use crate::{Int, StdSystem, api};
 
@@ -32,7 +33,7 @@ impl Atomic for Tuple {
 	type Data = Vec<api::ExprTicket>;
 	type Variant = OwnedVariant;
 	fn reg_reqs() -> orchid_extension::atom::MethodSetBuilder<Self> {
-		MethodSetBuilder::new().handle::<GetTagIdMethod>().handle::<GetImplMethod>()
+		MethodSetBuilder::new().handle::<ProtocolMethod>()
 	}
 }
 
@@ -52,22 +53,26 @@ impl OwnedAtom for Tuple {
 			.units_own(join_all(self.0.iter().map(|x| x.print(c))).await)
 	}
 }
-impl Supports<GetTagIdMethod> for Tuple {
-	async fn handle(&self, _: GetTagIdMethod) -> <GetTagIdMethod as Request>::Response {
-		sym!(std::tuple).to_api()
-	}
-}
-impl Supports<GetImplMethod> for Tuple {
-	async fn handle(&self, req: GetImplMethod) -> <GetImplMethod as Request>::Response {
-		let name = Sym::from_api(req.0).await;
-		let val = if name == sym!(std::ops::get) {
-			sym_ref(sym!(std::tuple::get))
-		} else if name == sym!(std::ops::set) {
-			sym_ref(sym!(std::tuple::set))
-		} else {
-			return None;
-		};
-		Some(val.create().await.serialize().await)
+impl Supports<ProtocolMethod> for Tuple {
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn orchid_base::reqnot::ReqHandle<'a> + '_>,
+		req: ProtocolMethod,
+	) -> std::io::Result<orchid_base::reqnot::Receipt<'a>> {
+		match req {
+			ProtocolMethod::GetTagId(req) => hand.reply(&req, &sym!(std::tuple).to_api()).await,
+			ProtocolMethod::GetImpl(ref req @ GetImpl(key)) => {
+				let name = Sym::from_api(key).await;
+				let val = if name == sym!(std::ops::get) {
+					sym_ref(sym!(std::tuple::get))
+				} else if name == sym!(std::ops::set) {
+					sym_ref(sym!(std::tuple::set))
+				} else {
+					return hand.reply(req, &None).await;
+				};
+				hand.reply(req, &Some(val.create().await.serialize().await)).await
+			},
+		}
 	}
 }