very elegant extension API and parts of it used in std as POC

orchid-base/src/name.rs

@@ -11,23 +11,23 @@ use std::{fmt, slice, vec};
 use itertools::Itertools;
 use trait_set::trait_set;
 
-use crate::intern::{intern, InternMarker, Token};
+use crate::interner::{intern, InternMarker, Tok};
 
 trait_set! {
   /// Traits that all name iterators should implement
-  pub trait NameIter = Iterator<Item = Token<String>> + DoubleEndedIterator + ExactSizeIterator;
+  pub trait NameIter = Iterator<Item = Tok<String>> + DoubleEndedIterator + ExactSizeIterator;
 }
 
 /// A borrowed name fragment which can be empty. See [VPath] for the owned
 /// variant.
 #[derive(Hash, PartialEq, Eq)]
 #[repr(transparent)]
-pub struct PathSlice([Token<String>]);
+pub struct PathSlice([Tok<String>]);
 impl PathSlice {
   /// Create a new [PathSlice]
-  pub fn new(slice: &[Token<String>]) -> &PathSlice {
+  pub fn new(slice: &[Tok<String>]) -> &PathSlice {
     // SAFETY: This is ok because PathSlice is #[repr(transparent)]
-    unsafe { &*(slice as *const [Token<String>] as *const PathSlice) }
+    unsafe { &*(slice as *const [Tok<String>] as *const PathSlice) }
   }
   /// Convert to an owned name fragment
   pub fn to_vpath(&self) -> VPath { VPath(self.0.to_vec()) }
@@ -57,7 +57,7 @@ impl PathSlice {
   pub fn is_empty(&self) -> bool { self.len() == 0 }
   /// Obtain a reference to the held slice. With all indexing traits shadowed,
   /// this is better done explicitly
-  pub fn as_slice(&self) -> &[Token<String>] { self }
+  pub fn as_slice(&self) -> &[Tok<String>] { self }
   /// Global empty path slice
   pub fn empty() -> &'static Self { PathSlice::new(&[]) }
 }
@@ -69,12 +69,12 @@ impl fmt::Display for PathSlice {
     write!(f, "{}", self.str_iter().join("::"))
   }
 }
-impl Borrow<[Token<String>]> for PathSlice {
-  fn borrow(&self) -> &[Token<String>] { &self.0 }
+impl Borrow<[Tok<String>]> for PathSlice {
+  fn borrow(&self) -> &[Tok<String>] { &self.0 }
 }
 impl<'a> IntoIterator for &'a PathSlice {
-  type IntoIter = Cloned<slice::Iter<'a, Token<String>>>;
-  type Item = Token<String>;
+  type IntoIter = Cloned<slice::Iter<'a, Tok<String>>>;
+  type Item = Tok<String>;
   fn into_iter(self) -> Self::IntoIter { self.0.iter().cloned() }
 }
 
@@ -82,10 +82,10 @@ mod idx_impls {
   use std::ops;
 
   use super::PathSlice;
-  use crate::intern::Token;
+  use crate::interner::Tok;
 
   impl ops::Index<usize> for PathSlice {
-    type Output = Token<String>;
+    type Output = Tok<String>;
     fn index(&self, index: usize) -> &Self::Output { &self.0[index] }
   }
   macro_rules! impl_range_index_for_pathslice {
@@ -106,27 +106,27 @@ mod idx_impls {
 }
 
 impl Deref for PathSlice {
-  type Target = [Token<String>];
+  type Target = [Tok<String>];
 
   fn deref(&self) -> &Self::Target { &self.0 }
 }
-impl Borrow<PathSlice> for [Token<String>] {
+impl Borrow<PathSlice> for [Tok<String>] {
   fn borrow(&self) -> &PathSlice { PathSlice::new(self) }
 }
-impl<const N: usize> Borrow<PathSlice> for [Token<String>; N] {
+impl<const N: usize> Borrow<PathSlice> for [Tok<String>; N] {
   fn borrow(&self) -> &PathSlice { PathSlice::new(&self[..]) }
 }
-impl Borrow<PathSlice> for Vec<Token<String>> {
+impl Borrow<PathSlice> for Vec<Tok<String>> {
   fn borrow(&self) -> &PathSlice { PathSlice::new(&self[..]) }
 }
 
 /// A token path which may be empty. [VName] is the non-empty,
 /// [PathSlice] is the borrowed version
 #[derive(Clone, Default, Hash, PartialEq, Eq)]
-pub struct VPath(pub Vec<Token<String>>);
+pub struct VPath(pub Vec<Tok<String>>);
 impl VPath {
   /// Collect segments into a vector
-  pub fn new(items: impl IntoIterator<Item = Token<String>>) -> Self {
+  pub fn new(items: impl IntoIterator<Item = Tok<String>>) -> Self {
     Self(items.into_iter().collect())
   }
   /// Number of path segments
@@ -135,11 +135,11 @@ impl VPath {
   /// valid name
   pub fn is_empty(&self) -> bool { self.len() == 0 }
   /// Prepend some tokens to the path
-  pub fn prefix(self, items: impl IntoIterator<Item = Token<String>>) -> Self {
+  pub fn prefix(self, items: impl IntoIterator<Item = Tok<String>>) -> Self {
     Self(items.into_iter().chain(self.0).collect())
   }
   /// Append some tokens to the path
-  pub fn suffix(self, items: impl IntoIterator<Item = Token<String>>) -> Self {
+  pub fn suffix(self, items: impl IntoIterator<Item = Tok<String>>) -> Self {
     Self(self.0.into_iter().chain(items).collect())
   }
   /// Partition the string by `::` namespace separators
@@ -154,12 +154,12 @@ impl VPath {
   pub fn into_name(self) -> Result<VName, EmptyNameError> { VName::new(self.0) }
   /// Add a token to the path. Since now we know that it can't be empty, turn it
   /// into a name.
-  pub fn name_with_prefix(self, name: Token<String>) -> VName {
+  pub fn name_with_prefix(self, name: Tok<String>) -> VName {
     VName(self.into_iter().chain([name]).collect())
   }
   /// Add a token to the beginning of the. Since now we know that it can't be
   /// empty, turn it into a name.
-  pub fn name_with_suffix(self, name: Token<String>) -> VName {
+  pub fn name_with_suffix(self, name: Tok<String>) -> VName {
     VName([name].into_iter().chain(self).collect())
   }
 
@@ -182,18 +182,18 @@ impl fmt::Display for VPath {
     write!(f, "{}", self.str_iter().join("::"))
   }
 }
-impl FromIterator<Token<String>> for VPath {
-  fn from_iter<T: IntoIterator<Item = Token<String>>>(iter: T) -> Self {
+impl FromIterator<Tok<String>> for VPath {
+  fn from_iter<T: IntoIterator<Item = Tok<String>>>(iter: T) -> Self {
     Self(iter.into_iter().collect())
   }
 }
 impl IntoIterator for VPath {
-  type Item = Token<String>;
+  type Item = Tok<String>;
   type IntoIter = vec::IntoIter<Self::Item>;
   fn into_iter(self) -> Self::IntoIter { self.0.into_iter() }
 }
-impl Borrow<[Token<String>]> for VPath {
-  fn borrow(&self) -> &[Token<String>] { self.0.borrow() }
+impl Borrow<[Tok<String>]> for VPath {
+  fn borrow(&self) -> &[Tok<String>] { self.0.borrow() }
 }
 impl Borrow<PathSlice> for VPath {
   fn borrow(&self) -> &PathSlice { PathSlice::new(&self.0[..]) }
@@ -218,39 +218,40 @@ where PathSlice: Index<T>
 /// See also [Sym] for the immutable representation, and [VPath] for possibly
 /// empty values
 #[derive(Clone, Hash, PartialEq, Eq)]
-pub struct VName(Vec<Token<String>>);
+pub struct VName(Vec<Tok<String>>);
 impl VName {
   /// Assert that the sequence isn't empty and wrap it in [VName] to represent
   /// this invariant
-  pub fn new(items: impl IntoIterator<Item = Token<String>>) -> Result<Self, EmptyNameError> {
+  pub fn new(items: impl IntoIterator<Item = Tok<String>>) -> Result<Self, EmptyNameError> {
     let data: Vec<_> = items.into_iter().collect();
     if data.is_empty() { Err(EmptyNameError) } else { Ok(Self(data)) }
   }
   /// Unwrap the enclosed vector
-  pub fn into_vec(self) -> Vec<Token<String>> { self.0 }
+  pub fn into_vec(self) -> Vec<Tok<String>> { self.0 }
   /// Get a reference to the enclosed vector
-  pub fn vec(&self) -> &Vec<Token<String>> { &self.0 }
+  pub fn vec(&self) -> &Vec<Tok<String>> { &self.0 }
   /// Mutable access to the underlying vector. To ensure correct results, this
   /// must never be empty.
-  pub fn vec_mut(&mut self) -> &mut Vec<Token<String>> { &mut self.0 }
+  pub fn vec_mut(&mut self) -> &mut Vec<Tok<String>> { &mut self.0 }
   /// Intern the name and return a [Sym]
   pub fn to_sym(&self) -> Sym { Sym(intern(&self.0[..])) }
   /// If this name has only one segment, return it
-  pub fn as_root(&self) -> Option<Token<String>> { self.0.iter().exactly_one().ok().cloned() }
+  pub fn as_root(&self) -> Option<Tok<String>> { self.0.iter().exactly_one().ok().cloned() }
   /// Prepend the segments to this name
   #[must_use = "This is a pure function"]
-  pub fn prefix(self, items: impl IntoIterator<Item = Token<String>>) -> Self {
+  pub fn prefix(self, items: impl IntoIterator<Item = Tok<String>>) -> Self {
     Self(items.into_iter().chain(self.0).collect())
   }
   /// Append the segments to this name
   #[must_use = "This is a pure function"]
-  pub fn suffix(self, items: impl IntoIterator<Item = Token<String>>) -> Self {
+  pub fn suffix(self, items: impl IntoIterator<Item = Tok<String>>) -> Self {
     Self(self.0.into_iter().chain(items).collect())
   }
   /// Read a `::` separated namespaced name
   pub fn parse(s: &str) -> Result<Self, EmptyNameError> { Self::new(VPath::parse(s)) }
+  pub fn literal(s: &'static str) -> Self { Self::parse(s).expect("empty literal !?") }
   /// Obtain an iterator over the segments of the name
-  pub fn iter(&self) -> impl Iterator<Item = Token<String>> + '_ { self.0.iter().cloned() }
+  pub fn iter(&self) -> impl Iterator<Item = Tok<String>> + '_ { self.0.iter().cloned() }
 }
 impl fmt::Debug for VName {
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "VName({self})") }
@@ -261,7 +262,7 @@ impl fmt::Display for VName {
   }
 }
 impl IntoIterator for VName {
-  type Item = Token<String>;
+  type Item = Tok<String>;
   type IntoIter = vec::IntoIter<Self::Item>;
   fn into_iter(self) -> Self::IntoIter { self.0.into_iter() }
 }
@@ -272,8 +273,8 @@ where PathSlice: Index<T>
 
   fn index(&self, index: T) -> &Self::Output { &self.deref()[index] }
 }
-impl Borrow<[Token<String>]> for VName {
-  fn borrow(&self) -> &[Token<String>] { self.0.borrow() }
+impl Borrow<[Tok<String>]> for VName {
+  fn borrow(&self) -> &[Tok<String>] { self.0.borrow() }
 }
 impl Borrow<PathSlice> for VName {
   fn borrow(&self) -> &PathSlice { PathSlice::new(&self.0[..]) }
@@ -287,9 +288,9 @@ impl Deref for VName {
 /// empty sequence
 #[derive(Debug, Copy, Clone, Default, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct EmptyNameError;
-impl TryFrom<&[Token<String>]> for VName {
+impl TryFrom<&[Tok<String>]> for VName {
   type Error = EmptyNameError;
-  fn try_from(value: &[Token<String>]) -> Result<Self, Self::Error> {
+  fn try_from(value: &[Tok<String>]) -> Result<Self, Self::Error> {
     Self::new(value.iter().cloned())
   }
 }
@@ -300,11 +301,11 @@ impl TryFrom<&[Token<String>]> for VName {
 ///
 /// See also [VName]
 #[derive(Clone, Hash, PartialEq, Eq)]
-pub struct Sym(Token<Vec<Token<String>>>);
+pub struct Sym(Tok<Vec<Tok<String>>>);
 impl Sym {
   /// Assert that the sequence isn't empty, intern it and wrap it in a [Sym] to
   /// represent this invariant
-  pub fn new(v: impl IntoIterator<Item = Token<String>>) -> Result<Self, EmptyNameError> {
+  pub fn new(v: impl IntoIterator<Item = Tok<String>>) -> Result<Self, EmptyNameError> {
     let items = v.into_iter().collect_vec();
     Self::from_tok(intern(&items[..]))
   }
@@ -313,11 +314,11 @@ impl Sym {
     Ok(Sym(intern(&VName::parse(s)?.into_vec()[..])))
   }
   /// Assert that a token isn't empty, and wrap it in a [Sym]
-  pub fn from_tok(t: Token<Vec<Token<String>>>) -> Result<Self, EmptyNameError> {
+  pub fn from_tok(t: Tok<Vec<Tok<String>>>) -> Result<Self, EmptyNameError> {
     if t.is_empty() { Err(EmptyNameError) } else { Ok(Self(t)) }
   }
   /// Grab the interner token
-  pub fn tok(&self) -> Token<Vec<Token<String>>> { self.0.clone() }
+  pub fn tok(&self) -> Tok<Vec<Tok<String>>> { self.0.clone() }
   /// Get a number unique to this name suitable for arbitrary ordering.
   pub fn id(&self) -> NonZeroU64 { self.0.marker().get_id() }
   /// Extern the sym for editing
@@ -338,8 +339,8 @@ where PathSlice: Index<T>
 
   fn index(&self, index: T) -> &Self::Output { &self.deref()[index] }
 }
-impl Borrow<[Token<String>]> for Sym {
-  fn borrow(&self) -> &[Token<String>] { &self.0[..] }
+impl Borrow<[Tok<String>]> for Sym {
+  fn borrow(&self) -> &[Tok<String>] { &self.0[..] }
 }
 impl Borrow<PathSlice> for Sym {
   fn borrow(&self) -> &PathSlice { PathSlice::new(&self.0[..]) }
@@ -356,7 +357,7 @@ pub trait NameLike:
   'static + Clone + Eq + Hash + fmt::Debug + fmt::Display + Borrow<PathSlice>
 {
   /// Convert into held slice
-  fn as_slice(&self) -> &[Token<String>] { Borrow::<PathSlice>::borrow(self) }
+  fn as_slice(&self) -> &[Tok<String>] { Borrow::<PathSlice>::borrow(self) }
   /// Get iterator over tokens
   fn iter(&self) -> impl NameIter + '_ { self.as_slice().iter().cloned() }
   /// Get iterator over string segments
@@ -373,19 +374,19 @@ pub trait NameLike:
     NonZeroUsize::try_from(self.iter().count()).expect("NameLike never empty")
   }
   /// Like slice's `split_first` except we know that it always returns Some
-  fn split_first(&self) -> (Token<String>, &PathSlice) {
+  fn split_first(&self) -> (Tok<String>, &PathSlice) {
     let (foot, torso) = self.as_slice().split_last().expect("NameLike never empty");
     (foot.clone(), PathSlice::new(torso))
   }
   /// Like slice's `split_last` except we know that it always returns Some
-  fn split_last(&self) -> (Token<String>, &PathSlice) {
+  fn split_last(&self) -> (Tok<String>, &PathSlice) {
     let (foot, torso) = self.as_slice().split_last().expect("NameLike never empty");
     (foot.clone(), PathSlice::new(torso))
   }
   /// Get the first element
-  fn first(&self) -> Token<String> { self.split_first().0 }
+  fn first(&self) -> Tok<String> { self.split_first().0 }
   /// Get the last element
-  fn last(&self) -> Token<String> { self.split_last().0 }
+  fn last(&self) -> Tok<String> { self.split_last().0 }
 }
 
 impl NameLike for Sym {}
@@ -399,7 +400,7 @@ impl NameLike for VName {}
 #[macro_export]
 macro_rules! sym {
   ($seg1:tt $( :: $seg:tt)*) => {
-    $crate::name::Sym::from_tok($crate::intern!([$crate::intern::Token<String>]: &[
+    $crate::name::Sym::from_tok($crate::intern!([$crate::interner::Tok<String>]: &[
       $crate::intern!(str: stringify!($seg1))
       $( , $crate::intern!(str: stringify!($seg)) )*
     ])).unwrap()
@@ -457,16 +458,16 @@ mod test {
   use std::borrow::Borrow;
 
   use super::{PathSlice, Sym, VName};
-  use crate::intern::{intern, Token};
+  use crate::interner::{intern, Tok};
   use crate::name::VPath;
 
   #[test]
   fn recur() {
     let myname = vname!(foo::bar);
-    let _borrowed_slice: &[Token<String>] = myname.borrow();
+    let _borrowed_slice: &[Tok<String>] = myname.borrow();
     let _borrowed_pathslice: &PathSlice = myname.borrow();
     let _deref_pathslice: &PathSlice = &myname;
-    let _as_slice_out: &[Token<String>] = myname.as_slice();
+    let _as_slice_out: &[Tok<String>] = myname.as_slice();
   }
 
   #[test]