Fixed a very nasty deadlock

orchid-std/src/macros/stdlib/tuple.rs

@@ -0,0 +1,133 @@
+use futures::{StreamExt, stream};
+use orchid_base::error::OrcRes;
+use orchid_base::sym;
+use orchid_extension::atom::TAtom;
+use orchid_extension::atom_owned::own;
+use orchid_extension::conv::ToExpr;
+use orchid_extension::coroutine_exec::exec;
+use orchid_extension::expr::Expr;
+use orchid_extension::gen_expr::{GExpr, call, sym_ref};
+use orchid_extension::tree::{GenMember, fun, prefix};
+
+use crate::macros::match_macros::MatcherAtom;
+use crate::macros::utils::{build_macro, mactree, mactreev};
+use crate::{HomoTpl, MacTree, OrcOpt};
+
+pub async fn gen_tuple_macro_lib() -> Vec<GenMember> {
+	prefix("std::tuple", [
+			build_macro(None, ["t"])
+				.rule(mactreev!(std::tuple::t [ "...$" elements 0 ]), [|[elements]: [_; _]| {
+					exec(async move |mut h| {
+						let tup = h
+							.exec::<HomoTpl<TAtom<MacTree>>>(call(sym_ref(sym!(macros::resolve)), [
+								mactree!((macros::common::comma_list "push" elements ;)).to_gen().await,
+							]))
+							.await?;
+						let val = stream::iter(&tup.0[..])
+							.fold(sym_ref(sym!(std::tuple::empty)), async |head, new| {
+								call(sym_ref(sym!(std::tuple::cat)), [
+									head,
+									call(sym_ref(sym!(std::tuple::one)), [call(
+										sym_ref(sym!(macros::resolve)),
+										[new.clone().to_gen().await],
+									)]),
+								])
+							})
+							.await;
+						Ok(val)
+					})
+				}])
+				.rule(
+					mactreev!(pattern::match_rule(std::tuple::t[ "...$" elements 0 macros::common::, macros::common::..])),
+					[async |[elements]: [_; _]| parse_tpl(elements, Some(mactree!(macros::common::_))).await],
+				)
+				.rule(
+					mactreev!(pattern::match_rule(
+						std::tuple::t[ "...$" elements 1 macros::common::, macros::common::.. "...$" tail 0]
+					)),
+					[async |[elements, tail]: [_; _]| parse_tpl(elements, Some(tail)).await],
+				)
+				.rule(mactreev!(pattern::match_rule(std::tuple::t[ "...$" elements 0])), [
+					|[elements]: [_; _]| parse_tpl(elements, None),
+				])
+				.finish(),
+			fun(false, "matcher_body", tuple_matcher_body),
+		])
+}
+
+fn parse_tpl(elements: MacTree, tail_matcher: Option<MacTree>) -> impl Future<Output = GExpr> {
+	exec(async move |mut h| -> OrcRes<MatcherAtom> {
+		let tup = h
+			.exec::<HomoTpl<TAtom<MacTree>>>(call(sym_ref(sym!(macros::resolve)), [
+				mactree!((macros::common::comma_list "push" elements ;)).to_gen().await,
+			]))
+			.await?;
+		let mut subs = Vec::with_capacity(tup.0.len());
+		for mac_a in &tup.0[..] {
+			let mac = own(mac_a).await;
+			let sub = h
+				.exec::<TAtom<MatcherAtom>>(call(sym_ref(sym!(macros::resolve)), [
+					mactree!(pattern::match_rule ("push" mac ;)).to_gen().await,
+				]))
+				.await?;
+			subs.push(sub);
+		}
+		let tail_matcher = match tail_matcher {
+			Some(mac) => Some(
+				h.exec::<TAtom<MatcherAtom>>(call(sym_ref(sym!(macros::resolve)), [
+					mactree!(pattern::match_rule "push" mac ;).to_gen().await,
+				]))
+				.await?,
+			),
+			None => None,
+		};
+		Ok(MatcherAtom {
+			keys: stream::iter(&subs[..])
+				.flat_map(|t| t.keys())
+				.chain(stream::iter(&tail_matcher).flat_map(|mat| mat.keys()))
+				.collect()
+				.await,
+			matcher: call(sym_ref(sym!(std::tuple::matcher_body)), [
+				HomoTpl(subs).to_gen().await,
+				OrcOpt(tail_matcher).to_gen().await,
+			])
+			.to_expr()
+			.await,
+		})
+	})
+}
+
+fn tuple_matcher_body(
+	children: HomoTpl<TAtom<MatcherAtom>>,
+	tail: OrcOpt<TAtom<MatcherAtom>>,
+	value: HomoTpl<Expr>,
+) -> impl Future<Output = GExpr> {
+	exec(async move |mut h| -> OrcRes<OrcOpt<HomoTpl<Expr>>> {
+		if value.0.len() < children.0.len() {
+			return Ok(OrcOpt(None));
+		}
+		let mut binds = Vec::new();
+		for (sub_mat, sub_val) in children.0.iter().zip(&value.0) {
+			match sub_mat.run_matcher(&mut h, sub_val.clone()).await? {
+				OrcOpt(None) => return Ok(OrcOpt(None)),
+				OrcOpt(Some(subres)) => binds.extend(subres.0),
+			}
+		}
+		match tail.0 {
+			None if children.0.len() < value.0.len() => return Ok(OrcOpt(None)),
+			None => (),
+			Some(tail_mat) => {
+				let tail_tpl = stream::iter(&value.0[children.0.len()..])
+					.fold(sym_ref(sym!(std::tuple::empty)), async |prefix, new| {
+						call(sym_ref(sym!(std::tuple::cat)), [prefix, new.clone().to_gen().await])
+					})
+					.await;
+				match tail_mat.run_matcher(&mut h, tail_tpl).await? {
+					OrcOpt(Some(tail_binds)) => binds.extend(tail_binds.0),
+					OrcOpt(None) => return Ok(OrcOpt(None)),
+				}
+			},
+		};
+		Ok(OrcOpt(Some(HomoTpl(binds))))
+	})
+}