partway through fixes, macro system needs resdesign

orchid-std/src/std/binary/binary_atom.rs

@@ -4,8 +4,7 @@ use std::rc::Rc;
 
 use futures::AsyncWrite;
 use orchid_api_traits::Encode;
-use orchid_extension::Atomic;
-use orchid_extension::{DeserializeCtx, OwnedAtom, OwnedVariant};
+use orchid_extension::{Atomic, DeserializeCtx, OwnedAtom, OwnedVariant};
 
 #[derive(Clone)]
 pub struct BlobAtom(pub(crate) Rc<Vec<u8>>);

orchid-std/src/std/boolean.rs

@@ -1,10 +1,8 @@
 use orchid_api_derive::Coding;
 use orchid_base::{FmtUnit, OrcRes, sym};
-use orchid_extension::{ToExpr, TryFromExpr};
-use orchid_extension::Expr;
 use orchid_extension::gen_expr::GExpr;
 use orchid_extension::tree::{GenMember, cnst, comments, fun, prefix};
-use orchid_extension::{Atomic, TAtom, ThinAtom, ThinVariant};
+use orchid_extension::{Atomic, Expr, TAtom, ThinAtom, ThinVariant, ToExpr, TryFromExpr};
 
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Coding)]
 pub struct Bool(pub bool);

orchid-std/src/std/ops/subscript_lexer.rs

@@ -1,8 +1,7 @@
-use orchid_base::{name_char, name_start};
-use orchid_base::{OrcRes, is};
+use orchid_base::{OrcRes, is, name_char, name_start};
 use orchid_extension::gen_expr::new_atom;
-use orchid_extension::{LexContext, LexedData, Lexer, err_not_applicable};
 use orchid_extension::tree::GenTok;
+use orchid_extension::{LexContext, LexedData, Lexer, err_not_applicable};
 
 use crate::std::string::str_atom::IntStrAtom;
 

orchid-std/src/std/option.rs

@@ -4,11 +4,12 @@ use std::pin::Pin;
 use futures::AsyncWrite;
 use orchid_api_traits::Encode;
 use orchid_base::{is, mk_errv, sym};
-use orchid_extension::{ToExpr, TryFromExpr};
-use orchid_extension::{Expr, ExprHandle};
 use orchid_extension::gen_expr::{call, new_atom};
 use orchid_extension::tree::{GenMember, cnst, fun, prefix};
-use orchid_extension::{Atomic, DeserializeCtx, ForeignAtom, OwnedAtom, OwnedVariant, TAtom};
+use orchid_extension::{
+	Atomic, DeserializeCtx, Expr, ExprHandle, ForeignAtom, OwnedAtom, OwnedVariant, TAtom, ToExpr,
+	TryFromExpr,
+};
 
 use crate::{OrcString, api};
 

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

@@ -1,13 +1,9 @@
 use itertools::{Itertools, chain};
-use orchid_base::Sym;
 use orchid_base::{
-	Import, Parsed, Snippet, expect_tok, line_items, parse_multiname, token_errv,
-};
-use orchid_base::{Paren, Token};
-use orchid_base::{IStr, OrcRes, is, mk_errv};
-use orchid_extension::{
-	PTokTree, ParsCtx, ParsedLine, ParsedLineKind, p_tree2gen, p_v2gen,
+	IStr, Import, OrcRes, Paren, Parsed, Snippet, Sym, Token, expect_tok, is, line_items, mk_errv,
+	parse_multiname, token_errv,
 };
+use orchid_extension::{PTokTree, ParsCtx, ParsedLine, ParsedLineKind, p_tree2gen, p_v2gen};
 
 pub async fn parse_impls(
 	_: &ParsCtx<'_>,

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

@@ -2,9 +2,8 @@ use std::rc::Rc;
 
 use hashbrown::HashMap;
 use orchid_base::{Comment, OrcRes, Parsed, Token, expect_end, is, mk_errv, sym, try_pop_no_fluff};
-use orchid_extension::ToExpr;
 use orchid_extension::gen_expr::{call, new_atom};
-use orchid_extension::{PSnippet, ParsCtx, ParsedLine, Parser};
+use orchid_extension::{PSnippet, ParsCtx, ParsedLine, Parser, ToExpr};
 
 use crate::std::protocol::parse_impls::parse_impls;
 use crate::std::protocol::types::Tag;

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

@@ -2,9 +2,8 @@ use std::rc::Rc;
 
 use hashbrown::HashMap;
 use orchid_base::{Comment, OrcRes, Parsed, Token, expect_end, is, mk_errv, sym, try_pop_no_fluff};
-use orchid_extension::ToExpr;
 use orchid_extension::gen_expr::{call, new_atom};
-use orchid_extension::{PSnippet, ParsCtx, ParsedLine, Parser};
+use orchid_extension::{PSnippet, ParsCtx, ParsedLine, Parser, ToExpr};
 
 use crate::std::protocol::parse_impls::parse_impls;
 use crate::std::protocol::types::Tag;

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

@@ -9,10 +9,8 @@ use hashbrown::HashMap;
 use orchid_api_derive::Coding;
 use orchid_api_traits::{Encode, Request};
 use orchid_base::{IStr, Receipt, ReqHandle, ReqHandleExt, Sym, es, sym};
-use orchid_extension::ToExpr;
-use orchid_extension::Expr;
 use orchid_extension::{
-	Atomic, DeserializeCtx, MethodSetBuilder, OwnedAtom, OwnedVariant, Supports,
+	Atomic, DeserializeCtx, Expr, MethodSetBuilder, OwnedAtom, OwnedVariant, Supports, ToExpr,
 };
 
 use crate::api;

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

@@ -3,10 +3,9 @@ use std::rc::Rc;
 use hashbrown::HashMap;
 use itertools::Itertools;
 use orchid_base::{is, mk_errv};
-use orchid_extension::TAtom;
-use orchid_extension::Expr;
-use orchid_extension::gen_expr::{arg, new_atom};
+use orchid_extension::gen_expr::new_atom;
 use orchid_extension::tree::{GenMember, cnst, fun, prefix};
+use orchid_extension::{Expr, TAtom, get_arg_posv};
 
 use crate::std::record::record_atom::RecordAtom;
 use crate::std::string::str_atom::IntStrAtom;
@@ -26,7 +25,7 @@ pub fn gen_record_lib() -> Vec<GenMember> {
 				None => Err(mk_errv(
 					is("Key not found in record").await,
 					format!("{} is not in this record, valid keys are {}", key.0, record.0.keys().join(", ")),
-					[arg(0).pos.clone(), arg(1).pos.clone()],
+					get_arg_posv([0, 1]).await,
 				)),
 			}
 		}),

orchid-std/src/std/std_system.rs

@@ -4,10 +4,10 @@ use futures::future::join_all;
 use orchid_api_derive::{Coding, Hierarchy};
 use orchid_base::{Receipt, ReqHandle, ReqHandleExt, Sym, es, sym};
 use orchid_extension::gen_expr::new_atom;
-use orchid_extension::ParserObj;
 use orchid_extension::tree::{GenMember, merge_trivial};
 use orchid_extension::{
-	AtomOps, AtomicFeatures, Expr, LexerObj, ReqForSystem, System, SystemCard, SystemCtor, ToExpr,
+	AtomOps, AtomicFeatures, Expr, LexerObj, ParserObj, ReqForSystem, System, SystemCard, SystemCtor,
+	ToExpr,
 };
 
 use super::number::num_lib::gen_num_lib;

orchid-std/src/std/stream/stream_cmds.rs

@@ -4,7 +4,7 @@ use std::rc::Rc;
 
 use never::Never;
 use orchid_base::{ReqHandleExt, fmt, is, mk_errv};
-use orchid_extension::gen_expr::{bot, call, new_atom};
+use orchid_extension::gen_expr::{bot, call, new_atom, serialize};
 use orchid_extension::std_reqs::{ReadLimit, ReadReq, RunCommand};
 use orchid_extension::{Atomic, Expr, ForeignAtom, OwnedAtom, OwnedVariant, Supports, ToExpr};
 
@@ -50,6 +50,6 @@ impl Supports<RunCommand> for ReadStreamCmd {
 			),
 			Some(Ok(v)) => Ok(call(self.succ.clone(), new_atom(BlobAtom(Rc::new(v)))).await),
 		};
-		hand.reply(&req, &Some(ret.to_gen().await.serialize().await)).await
+		hand.reply(&req, &Some(serialize(ret.to_gen().await).await)).await
 	}
 }

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

@@ -10,10 +10,9 @@ use orchid_api_traits::{Encode, Request};
 use orchid_base::{
 	FmtCtx, FmtUnit, IStr, OrcRes, Receipt, ReqHandle, ReqHandleExt, Sym, es, is, mk_errv, sym,
 };
-use orchid_extension::{ToExpr, TryFromExpr};
-use orchid_extension::Expr;
 use orchid_extension::{
-	AtomMethod, Atomic, DeserializeCtx, MethodSetBuilder, OwnedAtom, OwnedVariant, Supports, TAtom,
+	AtomMethod, Atomic, DeserializeCtx, Expr, MethodSetBuilder, OwnedAtom, OwnedVariant, Supports,
+	TAtom, ToExpr, TryFromExpr,
 };
 
 use crate::std::protocol::types::{GetImpl, ProtocolMethod};

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

@@ -1,10 +1,8 @@
 use itertools::Itertools;
 use orchid_base::{OrcErr, OrcErrv, OrcRes, Paren, SrcRange, Sym, is, mk_errv, sym, wrap_tokv};
-use orchid_extension::ToExpr;
 use orchid_extension::gen_expr::new_atom;
-use orchid_extension::{LexContext, Lexer, err_not_applicable};
-use orchid_extension::p_tree2gen;
 use orchid_extension::tree::{GenTok, GenTokTree, ref_tok, x_tok};
+use orchid_extension::{LexContext, Lexer, ToExpr, err_not_applicable, p_tree2gen};
 
 use super::str_atom::IntStrAtom;
 

orchid-std/src/std/time.rs

@@ -1,15 +1,14 @@
 use std::borrow::Cow;
 use std::io;
-use std::time::Instant;
 
-use chrono::TimeDelta;
+use chrono::{DateTime, TimeDelta, Utc};
 use never::Never;
 use orchid_api::ExprTicket;
 use orchid_api_derive::{Coding, Hierarchy};
 use orchid_api_traits::Request;
 use orchid_base::{Numeric, OrcRes, Receipt, ReqHandle, ReqHandleExt};
-use orchid_extension::gen_expr::{GExpr, call, new_atom};
-use orchid_extension::std_reqs::{AsDuration, RunCommand};
+use orchid_extension::gen_expr::{GExpr, call, new_atom, serialize};
+use orchid_extension::std_reqs::{AsInstant, RunCommand};
 use orchid_extension::tree::{GenMember, fun, prefix};
 use orchid_extension::{
 	Atomic, Expr, MethodSetBuilder, OwnedAtom, OwnedVariant, Supports, TAtom, ThinAtom, ThinVariant,
@@ -44,18 +43,9 @@ impl TryFromExpr for OrcDT {
 		Ok(TAtom::<OrcDT>::try_from_expr(expr).await?.value)
 	}
 }
-impl Supports<AsDuration> for OrcDT {
-	async fn handle<'a>(
-		&self,
-		hand: Box<dyn ReqHandle<'a> + '_>,
-		req: AsDuration,
-	) -> std::io::Result<Receipt<'a>> {
-		hand.reply(&req, &self.0.to_std().unwrap()).await
-	}
-}
 
 #[derive(Clone)]
-pub struct InstantAtom(Instant);
+pub struct InstantAtom(DateTime<Utc>);
 impl Atomic for InstantAtom {
 	type Variant = OwnedVariant;
 	type Data = ();
@@ -64,6 +54,15 @@ impl OwnedAtom for InstantAtom {
 	type Refs = Never;
 	async fn val(&self) -> Cow<'_, Self::Data> { Cow::Owned(()) }
 }
+impl Supports<AsInstant> for InstantAtom {
+	async fn handle<'a>(
+		&self,
+		hand: Box<dyn ReqHandle<'a> + '_>,
+		req: AsInstant,
+	) -> std::io::Result<Receipt<'a>> {
+		hand.reply(&req, &self.0).await
+	}
+}
 
 #[derive(Clone)]
 struct Now(Expr);
@@ -82,7 +81,7 @@ impl Supports<RunCommand> for Now {
 		hand: Box<dyn ReqHandle<'a> + '_>,
 		req: RunCommand,
 	) -> io::Result<Receipt<'a>> {
-		let cont = call(self.0.clone(), new_atom(InstantAtom(Instant::now()))).await.serialize().await;
+		let cont = serialize(call(self.0.clone(), new_atom(InstantAtom(Utc::now()))).await).await;
 		hand.reply(&req, &Some(cont)).await
 	}
 }