Formatter introduced

orchid-extension/src/atom.rs

@@ -15,6 +15,7 @@ use futures::{FutureExt, StreamExt};
 use orchid_api_traits::{Coding, Decode, Encode, Request, enc_vec};
 use orchid_base::clone;
 use orchid_base::error::{OrcErr, OrcRes, mk_err};
+use orchid_base::format::{FmtCtx, FmtUnit, Format};
 use orchid_base::interner::Interner;
 use orchid_base::location::Pos;
 use orchid_base::name::Sym;
@@ -117,15 +118,17 @@ impl fmt::Display for ForeignAtom<'_> {
 impl fmt::Debug for ForeignAtom<'_> {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "ForeignAtom({self})") }
 }
+impl Format for ForeignAtom<'_> {
+	async fn print<'a>(&'a self, _c: &'a (impl FmtCtx + ?Sized + 'a)) -> FmtUnit {
+		FmtUnit::from_api(&self.ctx.reqnot.request(api::ExtAtomPrint(self.atom.clone())).await)
+	}
+}
 impl AtomRepr for ForeignAtom<'_> {
 	type Ctx = SysCtx;
 	async fn from_api(atom: &api::Atom, pos: Pos, ctx: &mut Self::Ctx) -> Self {
 		Self { atom: atom.clone(), _life: PhantomData, ctx: ctx.clone(), expr: None, pos }
 	}
 	async fn to_api(&self) -> orchid_api::Atom { self.atom.clone() }
-	async fn print(&self) -> String {
-		self.ctx.reqnot.request(api::ExtAtomPrint(self.atom.clone())).await
-	}
 }
 
 pub struct NotTypAtom {
@@ -266,6 +269,9 @@ impl<A: AtomicFeatures> Deref for TypAtom<'_, A> {
 }
 
 pub struct AtomCtx<'a>(pub &'a [u8], pub Option<api::AtomId>, pub SysCtx);
+impl FmtCtx for AtomCtx<'_> {
+	fn i(&self) -> &Interner { &self.2.i }
+}
 
 pub trait AtomDynfo: 'static {
 	fn tid(&self) -> TypeId;
@@ -273,7 +279,7 @@ pub trait AtomDynfo: 'static {
 	fn decode<'a>(&'a self, ctx: AtomCtx<'a>) -> LocalBoxFuture<'a, Box<dyn Any>>;
 	fn call<'a>(&'a self, ctx: AtomCtx<'a>, arg: api::ExprTicket) -> LocalBoxFuture<'a, GExpr>;
 	fn call_ref<'a>(&'a self, ctx: AtomCtx<'a>, arg: api::ExprTicket) -> LocalBoxFuture<'a, GExpr>;
-	fn print<'a>(&'a self, ctx: AtomCtx<'a>) -> LocalBoxFuture<'a, String>;
+	fn print<'a>(&'a self, ctx: AtomCtx<'a>) -> LocalBoxFuture<'a, FmtUnit>;
 	fn handle_req<'a, 'b: 'a, 'c: 'a>(
 		&'a self,
 		ctx: AtomCtx<'a>,
@@ -317,6 +323,11 @@ impl fmt::Debug for AtomFactory {
 impl fmt::Display for AtomFactory {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "AtomFactory") }
 }
+impl Format for AtomFactory {
+	async fn print<'a>(&'a self, _c: &'a (impl FmtCtx + ?Sized + 'a)) -> FmtUnit {
+		"AtomFactory".to_string().into()
+	}
+}
 
 pub async fn err_not_callable(i: &Interner) -> OrcErr {
 	mk_err(i.i("This atom is not callable").await, "Attempted to apply value as function", [])

orchid-extension/src/atom_owned.rs

@@ -13,6 +13,7 @@ use never::Never;
 use orchid_api_traits::{Decode, Encode, enc_vec};
 use orchid_base::clone;
 use orchid_base::error::OrcRes;
+use orchid_base::format::FmtUnit;
 use orchid_base::id_store::{IdRecord, IdStore};
 use orchid_base::name::Sym;
 
@@ -76,7 +77,7 @@ impl<T: OwnedAtom> AtomDynfo for OwnedAtomDynfo<T> {
 		}
 		.boxed_local()
 	}
-	fn print(&self, AtomCtx(_, id, ctx): AtomCtx<'_>) -> LocalBoxFuture<'_, String> {
+	fn print(&self, AtomCtx(_, id, ctx): AtomCtx<'_>) -> LocalBoxFuture<'_, FmtUnit> {
 		async move {
 			with_atom(id.unwrap(), &ctx, |a| clone!(ctx; async move { a.dyn_print(ctx).await })).await
 		}
@@ -227,8 +228,8 @@ pub trait OwnedAtom: Atomic<Variant = OwnedVariant> + Any + Clone + 'static {
 	#[allow(unused_variables)]
 	fn free(self, ctx: SysCtx) -> impl Future<Output = ()> { async {} }
 	#[allow(unused_variables)]
-	fn print(&self, ctx: SysCtx) -> impl Future<Output = String> {
-		async { format!("OwnedAtom({})", type_name::<Self>()) }
+	fn print(&self, ctx: SysCtx) -> impl Future<Output = FmtUnit> {
+		async { format!("OwnedAtom({})", type_name::<Self>()).into() }
 	}
 	#[allow(unused_variables)]
 	fn serialize(
@@ -262,7 +263,7 @@ pub trait DynOwnedAtom: 'static {
 	-> LocalBoxFuture<'static, GExpr>;
 	fn dyn_command(self: Box<Self>, ctx: SysCtx) -> LocalBoxFuture<'static, OrcRes<Option<GExpr>>>;
 	fn dyn_free(self: Box<Self>, ctx: SysCtx) -> LocalBoxFuture<'static, ()>;
-	fn dyn_print(&self, ctx: SysCtx) -> LocalBoxFuture<'_, String>;
+	fn dyn_print(&self, ctx: SysCtx) -> LocalBoxFuture<'_, FmtUnit>;
 	fn dyn_serialize<'a>(
 		&'a self,
 		ctx: SysCtx,
@@ -291,7 +292,7 @@ impl<T: OwnedAtom> DynOwnedAtom for T {
 	fn dyn_free(self: Box<Self>, ctx: SysCtx) -> LocalBoxFuture<'static, ()> {
 		self.free(ctx).boxed_local()
 	}
-	fn dyn_print(&self, ctx: SysCtx) -> LocalBoxFuture<'_, String> { self.print(ctx).boxed_local() }
+	fn dyn_print(&self, ctx: SysCtx) -> LocalBoxFuture<'_, FmtUnit> { self.print(ctx).boxed_local() }
 	fn dyn_serialize<'a>(
 		&'a self,
 		ctx: SysCtx,

orchid-extension/src/atom_thin.rs

@@ -8,6 +8,7 @@ use futures::FutureExt;
 use futures::future::LocalBoxFuture;
 use orchid_api_traits::{Coding, enc_vec};
 use orchid_base::error::OrcRes;
+use orchid_base::format::FmtUnit;
 use orchid_base::name::Sym;
 
 use crate::api;
@@ -39,7 +40,7 @@ pub struct ThinAtomDynfo<T: ThinAtom> {
 	ms: OnceCell<MethodSet<T>>,
 }
 impl<T: ThinAtom> AtomDynfo for ThinAtomDynfo<T> {
-	fn print<'a>(&self, AtomCtx(buf, _, ctx): AtomCtx<'a>) -> LocalBoxFuture<'a, String> {
+	fn print<'a>(&self, AtomCtx(buf, _, ctx): AtomCtx<'a>) -> LocalBoxFuture<'a, FmtUnit> {
 		async move { T::decode(Pin::new(&mut &buf[..])).await.print(ctx).await }.boxed_local()
 	}
 	fn tid(&self) -> TypeId { TypeId::of::<T>() }
@@ -123,7 +124,7 @@ pub trait ThinAtom:
 		async move { Err(err_not_command(&ctx.i).await.into()) }
 	}
 	#[allow(unused_variables)]
-	fn print(&self, ctx: SysCtx) -> impl Future<Output = String> {
-		async { format!("ThinAtom({})", type_name::<Self>()) }
+	fn print(&self, ctx: SysCtx) -> impl Future<Output = FmtUnit> {
+		async { format!("ThinAtom({})", type_name::<Self>()).into() }
 	}
 }

orchid-extension/src/entrypoint.rs

@@ -343,7 +343,7 @@ pub async fn extension_main_logic(data: ExtensionData, spawner: Spawner) {
 											hand.handle(ser, &refs_opt.map(|refs| (buf, refs))).await
 										},
 										api::AtomReq::AtomPrint(print @ api::AtomPrint(_)) =>
-											hand.handle(print, &nfo.print(actx).await).await,
+											hand.handle(print, &nfo.print(actx).await.to_api()).await,
 										api::AtomReq::Fwded(fwded) => {
 											let api::Fwded(_, key, payload) = &fwded;
 											let mut reply = Vec::new();