wip: overcomplicating it on the way to simplifying it ultimately

edn/src/lib.rs

@@ -1,8 +1,45 @@
+#![feature(adt_const_params)]
 #![feature(type_alias_impl_trait)]
 #![feature(impl_trait_in_fn_trait_return)]
-mod token; pub use self::token::*;
-pub(crate) use std::fmt::{Debug, Display, Formatter, Error as FormatError};
+mod error;    pub use self::error::*;
+mod token;    pub use self::token::*;
+mod atom;     pub use self::atom::*;
+mod atom_ref; pub use self::atom_ref::*;
+mod atom_arc; pub use self::atom_arc::*;
+mod context;  pub use self::context::*;
+pub(crate) use self::ParseError::*;
+//pub(crate) use self::TokenKind::*;
 pub(crate) use std::sync::Arc;
+//pub(crate) use std::marker::ConstParamTy;
+pub(crate) use itertools::join;
+pub(crate) use konst::iter::{ConstIntoIter, IsIteratorKind};
+pub(crate) use konst::string::{split_at, str_range, char_indices};
+pub(crate) use std::error::Error;
+pub(crate) use std::fmt::{Debug, Display, Formatter, Result as FormatResult, Error as FormatError};
+/// Static iteration helper.
+#[macro_export] macro_rules! iterate {
+    ($expr:expr => $arg: pat => $body:expr) => {
+        let mut iter = $expr;
+        while let Some(($arg, next)) = iter.next() {
+            $body;
+            iter = next;
+        }
+    }
+}
+/// Implement the const iterator pattern.
+#[macro_export] macro_rules! const_iter {
+    ($(<$l:lifetime>)?|$self:ident: $Struct:ty| => $Item:ty => $expr:expr) => {
+        impl$(<$l>)? Iterator for $Struct {
+            type Item = $Item;
+            fn next (&mut $self) -> Option<$Item> { $expr }
+        }
+        impl$(<$l>)? ConstIntoIter for $Struct {
+            type Kind = IsIteratorKind;
+            type Item = $Item;
+            type IntoIter = Self;
+        }
+    }
+}
 #[cfg(test)] #[test] fn test_lang () -> Result<(), ParseError> {
     use Atom::*;
     assert_eq!(Atom::read_all("")?,
@@ -34,14 +71,3 @@ pub(crate) use std::sync::Arc;
     }
     Ok(())
 }
-#[cfg(test)] #[test] fn test_token () -> Result<(), Box<dyn std::error::Error>> {
-    use Token::*;
-    assert_eq!(Nil, Token::chomp_one("")?);
-    assert_eq!(Nil, Token::chomp_one("  \n    \r   \t  ")?);
-    assert_eq!(Num("8", 0, 1), Token::chomp_one("8")?);
-    assert_eq!(Num("   8     ", 3, 1), Token::chomp_one("   8     ")?);
-    assert_eq!(Sym(":foo", 0, 4), Token::chomp_one(":foo")?);
-    assert_eq!(Sym("@bar", 0, 4), Token::chomp_one("@bar")?);
-    assert_eq!(Key("foo/bar", 0, 7), Token::chomp_one("foo/bar")?);
-    Ok(())
-}