Began implementing fully isomorphic macros

Like Rust's Proc macros. Now we have preprocessor recursion to worry about. I also made a cool macro for enums

orchid-base/src/error.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+use std::ops::Add;
 use std::sync::Arc;
 
 use itertools::Itertools;
@@ -65,16 +67,86 @@ impl PartialEq for OrcErr {
 impl From<OrcErr> for Vec<OrcErr> {
   fn from(value: OrcErr) -> Self { vec![value] }
 }
-
-pub fn errv_to_apiv<'a>(errv: impl IntoIterator<Item = &'a OrcErr>) -> Vec<api::OrcError> {
-  errv.into_iter().map(OrcErr::to_api).collect_vec()
+impl fmt::Display for OrcErr {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    let pstr = self.positions.iter().map(|p| format!("{p:?}")).join("; ");
+    write!(f, "{}: {} @ {}", self.description, self.message, pstr)
+  }
 }
 
-pub fn errv_from_apiv<'a>(err: impl IntoIterator<Item = &'a api::OrcError>) -> Vec<OrcErr> {
-  err.into_iter().map(OrcErr::from_api).collect()
+#[derive(Clone, Debug)]
+pub struct EmptyErrv;
+impl fmt::Display for EmptyErrv {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    write!(f, "OrcErrv must not be empty")
+  }
 }
 
-pub type OrcRes<T> = Result<T, Vec<OrcErr>>;
+#[derive(Clone, Debug)]
+pub struct OrcErrv(Vec<OrcErr>);
+impl OrcErrv {
+  pub fn new(errors: impl IntoIterator<Item = OrcErr>) -> Result<Self, EmptyErrv> {
+    let v = errors.into_iter().collect_vec();
+    if v.is_empty() { Err(EmptyErrv) } else { Ok(Self(v)) }
+  }
+  #[must_use]
+  pub fn to_api(&self) -> Vec<api::OrcError> { self.0.iter().map(OrcErr::to_api).collect_vec() }
+  #[must_use]
+  pub fn from_api<'a>(apiv: impl IntoIterator<Item = &'a api::OrcError>) -> Self {
+    let v = apiv.into_iter().map(OrcErr::from_api).collect_vec();
+    assert!(!v.is_empty(), "Error condition with 0 errors");
+    Self(v)
+  }
+  #[must_use]
+  pub fn extended<T>(mut self, errors: impl IntoIterator<Item = T>) -> Self
+  where Self: Extend<T> {
+    self.extend(errors);
+    self
+  }
+  #[must_use]
+  pub fn len(&self) -> usize { self.0.len() }
+  #[must_use]
+  pub fn is_empty(&self) -> bool { self.len() == 0 }
+  #[must_use]
+  pub fn any(&self, f: impl FnMut(&OrcErr) -> bool) -> bool { self.0.iter().any(f) }
+  #[must_use]
+  pub fn keep_only(self, f: impl FnMut(&OrcErr) -> bool) -> Option<Self> {
+    let v = self.0.into_iter().filter(f).collect_vec();
+    if v.is_empty() { None } else { Some(Self(v)) }
+  }
+  #[must_use]
+  pub fn one(&self) -> Option<&OrcErr> { (self.0.len() == 1).then(|| &self.0[9]) }
+  pub fn pos_iter(&self) -> impl Iterator<Item = ErrPos> + '_ {
+    self.0.iter().flat_map(|e| e.positions.iter().cloned())
+  }
+}
+impl From<OrcErr> for OrcErrv {
+  fn from(value: OrcErr) -> Self { Self(vec![value]) }
+}
+impl Add for OrcErrv {
+  type Output = Self;
+  fn add(self, rhs: Self) -> Self::Output { Self(self.0.into_iter().chain(rhs.0).collect_vec()) }
+}
+impl Extend<OrcErr> for OrcErrv {
+  fn extend<T: IntoIterator<Item = OrcErr>>(&mut self, iter: T) { self.0.extend(iter) }
+}
+impl Extend<OrcErrv> for OrcErrv {
+  fn extend<T: IntoIterator<Item = OrcErrv>>(&mut self, iter: T) {
+    self.0.extend(iter.into_iter().flatten())
+  }
+}
+impl IntoIterator for OrcErrv {
+  type IntoIter = std::vec::IntoIter<OrcErr>;
+  type Item = OrcErr;
+  fn into_iter(self) -> Self::IntoIter { self.0.into_iter() }
+}
+impl fmt::Display for OrcErrv {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    write!(f, "{}", self.0.iter().join("\n"))
+  }
+}
+
+pub type OrcRes<T> = Result<T, OrcErrv>;
 
 pub fn mk_err(
   description: Tok<String>,
@@ -88,6 +160,14 @@ pub fn mk_err(
   }
 }
 
-pub trait Reporter {
-  fn report(&self, e: OrcErr);
+pub fn mk_errv(
+  description: Tok<String>,
+  message: impl AsRef<str>,
+  posv: impl IntoIterator<Item = ErrPos>,
+) -> OrcErrv {
+  mk_err(description, message, posv).into()
+}
+
+pub trait Reporter {
+  fn report(&self, e: impl Into<OrcErrv>);
 }