1 file, 300 lines, many worries

dsl/src/lib.rs

@@ -14,7 +14,110 @@ pub(crate) use konst::string::{split_at, str_range, char_indices};
 pub(crate) use thiserror::Error;
 pub(crate) use self::DslError::*;
 #[cfg(test)] mod test;
-/// A DSL expression. Generic over string and expression storage.
+/// Enumeration of values that may figure in an expression.
+/// Generic over string and expression storage.
+#[derive(Clone, Debug, PartialEq, Default)]
+pub enum Val<Str, Exp> {
+    /// Empty expression
+    #[default] Nil,
+    /// Unsigned integer literal
+    Num(usize),
+    /// An identifier that starts with `.`
+    Sym(Str),
+    /// An identifier that doesn't start with `:`
+    Key(Str),
+    /// A quoted string literal
+    Str(Str),
+    /// A DSL expression.
+    Exp(
+        /// Number of unclosed parentheses. Must be 0 to be valid.
+        isize,
+        /// Expression content.
+        Exp
+    ),
+    /// An error.
+    Error(DslError),
+}
+impl<Str: Copy, Exp: Copy> Copy for Val<Str, Exp> {}
+impl<Str: DslStr, Exp: DslExp> Val<Str, Exp> {
+    pub fn convert <T: Dsl> (&self) -> Val<T::Str, T::Exp> where
+        T::Str: for<'a> From<&'a Str>,
+        T::Exp: for<'a> From<&'a Exp>
+    {
+        match self { Val::Nil       => Val::Nil,
+                     Val::Num(u)    => Val::Num(*u),
+                     Val::Sym(s)    => Val::Sym(s.into()),
+                     Val::Key(s)    => Val::Key(s.into()),
+                     Val::Str(s)    => Val::Str(s.into()),
+                     Val::Exp(d, x) => Val::Exp(*d, x.into()),
+                     Val::Error(e)  => Val::Error(*e) } }
+}
+/// The expression representation for a [Dsl] implementation.
+/// [Cst] uses [CstIter]. [Ast] uses [VecDeque].
+pub trait DslExp: PartialEq + Clone + Default + Debug + Dsl {}
+impl<T: PartialEq + Clone + Default + Debug + Dsl> DslExp for T {}
+/// The string representation for a [Dsl] implementation.
+/// [Cst] uses `&'s str`. [Ast] uses `Arc<str>`.
+pub trait DslStr: PartialEq + Clone + Default + Debug + AsRef<str> + std::ops::Deref<Target = str> {}
+impl<T: PartialEq + Clone + Default + Debug + AsRef<str> + std::ops::Deref<Target = str>> DslStr for T {}
+impl<Str: DslStr, Exp: DslExp + Dsl<Str=Str, Exp=Exp>> Val<Str, Exp> {
+    pub const fn err (&self)       -> Option<DslError> {match self{Val::Error(e)=>Some(*e),        _=>None}}
+    pub const fn nil (&self)       -> bool             {match self{Val::Nil=>true,                 _=>false}}
+    pub const fn num (&self)       -> Option<usize>    {match self{Val::Num(n)=>Some(*n),          _=>None}}
+    pub const fn sym (&self)       -> Option<&Str>     {match self{Val::Sym(s)=>Some(s),   _=>None}}
+    pub const fn key (&self)       -> Option<&Str>     {match self{Val::Key(k)=>Some(k),   _=>None}}
+    pub const fn str (&self)       -> Option<&Str>     {match self{Val::Str(s)=>Some(s),   _=>None}}
+    pub const fn exp (&self)       -> Option<&Exp>     {match self{Val::Exp(_, x)=>Some(x),_=>None}}
+    pub const fn exp_depth (&self) -> Option<isize>    {match self{Val::Exp(d, _)=>Some(*d),       _=>None}}
+}
+/// Parsed substring with range and value.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Token<Str, Exp> {
+    /// Meaning of token.
+    pub value: Val<Str, Exp>,
+    /// Reference to source text.
+    pub source: Str,
+    /// Index of 1st character of span.
+    pub start:  usize,
+    /// Length of span.
+    pub length: usize,
+}
+impl<Str: Copy, Exp: Copy> Copy for Token<Str, Exp> {}
+impl<Str, Exp> Token<Str, Exp> {
+    pub const fn end (&self) -> usize {
+        self.start.saturating_add(self.length) }
+    pub const fn value (&self)
+        -> &Val<Str, Exp> { &self.value }
+    pub const fn err (&self)
+        -> Option<DslError> { if let Val::Error(e) = self.value { Some(e) } else { None } }
+    pub const fn new (source: Str, start: usize, length: usize, value: Val<Str, Exp>)
+        -> Self { Self { value, start, length, source } }
+    pub const fn copy (&self) -> Self where Val<Str, Exp>: Copy, Str: Copy, Exp: Copy {
+        Self { value: self.value, ..*self }
+    }
+}
+impl<'s> CstToken<'s> {
+    pub const fn slice (&self) -> &str {
+        str_range(self.source, self.start, self.end()) }
+    pub const fn slice_exp (&self) -> &str {
+        str_range(self.source, self.start.saturating_add(1), self.end()) }
+    pub const fn grow (&mut self) -> &mut Self {
+        let max_length = self.source.len().saturating_sub(self.start);
+        self.length    = self.length + 1;
+        if self.length > max_length { self.length = max_length }
+        self
+    }
+    pub const fn grow_exp (&'s mut self, depth: isize, source: &'s str) -> &mut Self {
+        self.value = Val::Exp(depth, Cst(CstConstIter(source)));
+        self
+    }
+}
+/// To the [Dsl], a token is equivalent to its `value` field.
+impl<Str: DslStr, Exp: DslExp> Dsl for Token<Str, Exp> {
+    type Str = Str; type Exp = Exp;
+    fn dsl (&self) -> Val<Str, Exp> { self.value.clone() }
+}
+/// Coerce to [Val] for predefined [Self::Str] and [Self::Exp].
 pub trait Dsl: Clone + Debug {
     /// The string representation for a dizzle.
     type Str: DslStr;
@@ -22,139 +125,48 @@ pub trait Dsl: Clone + Debug {
     type Exp: DslExp;
     /// Request the top-level DSL [Val]ue.
     /// May perform cloning or parsing.
-    fn dsl (&self) -> Val<Self>;
+    fn dsl (&self) -> Val<Self::Str, Self::Exp>;
-    fn err (&self) -> Option<DslError>  {self.dsl().err()}
+    fn err (&self) -> Option<DslError>           {self.dsl().err()}
-    fn nil (&self) -> bool              {self.dsl().nil()}
+    fn nil (&self) -> bool                       {self.dsl().nil()}
-    fn num (&self) -> Option<usize>     {self.dsl().num()}
+    fn num (&self) -> Option<usize>              {self.dsl().num()}
-    fn sym (&self) -> Option<Self::Str> {self.dsl().sym()}
+    fn sym (&self) -> Option<Self::Str>          {self.dsl().sym()}
-    fn key (&self) -> Option<Self::Str> {self.dsl().key()}
+    fn key (&self) -> Option<Self::Str>          {self.dsl().key()}
-    fn str (&self) -> Option<Self::Str> {self.dsl().str()}
+    fn str (&self) -> Option<Self::Str>          {self.dsl().str()}
-    fn exp (&self) -> Option<Self::Exp> {self.dsl().exp()}
+    fn exp (&self) -> Option<Self::Exp>          {self.dsl().exp()}
+    fn exp_depth (&self) -> Option<isize>            {self.dsl().exp_depth()}
+    fn exp_head (&self) -> Val<Self::Str, Self::Exp> {self.dsl().exp_head()}
+    fn exp_tail (&self) -> Val<Self::Str, Self::Exp> {self.dsl().exp_tail()}
 }
-/// Enumeration of values that may figure in an expression.
+/// The most basic implementor of the [Dsl] trait.
-/// Generic over [Dsl] implementation.
+impl<Str: DslStr, Exp: DslExp> Dsl for Val<Str, Exp> {
-#[derive(Clone, Debug, PartialEq, Default)]
+    type Str = Str; type Exp = Exp;
-pub enum Val<D: Dsl> {
+    fn dsl (&self) -> Val<Str, Exp> { self.clone() }
-    /// Empty expression
-    #[default] Nil,
-    /// Unsigned integer literal
-    Num(usize),
-    /// An identifier that starts with `.`
-    Sym(D::Str),
-    /// An identifier that doesn't start with `:`
-    Key(D::Str),
-    /// A quoted string literal
-    Str(D::Str),
-    /// A sub-expression.
-    Exp(
-        /// Expression depth checksum. Must be 0, otherwise you have an unclosed delimiter.
-        isize,
-        /// Expression content.
-        D::Exp
-    ),
-    /// An error.
-    Error(DslError),
-}
-impl<D: Dsl> Val<D> {
-    pub fn err (&self) -> Option<DslError> {match self{Val::Error(e)=>Some(*e),        _=>None}}
-    pub fn nil (&self) -> bool             {match self{Val::Nil=>true,                 _=>false}}
-    pub fn num (&self) -> Option<usize>    {match self{Val::Num(n)=>Some(*n),          _=>None}}
-    pub fn sym (&self) -> Option<D::Str>   {match self{Val::Sym(s)=>Some(s.clone()),   _=>None}}
-    pub fn key (&self) -> Option<D::Str>   {match self{Val::Key(k)=>Some(k.clone()),   _=>None}}
-    pub fn str (&self) -> Option<D::Str>   {match self{Val::Str(s)=>Some(s.clone()),   _=>None}}
-    pub fn exp (&self) -> Option<D::Exp>   {match self{Val::Exp(_, x)=>Some(x.clone()),_=>None}}
 }
 /// The abstract syntax tree (AST) can be produced from the CST
 /// by cloning source slices into owned ([Arc]) string slices.
 #[derive(Debug, Clone, Default, PartialEq)]
-pub struct Ast(Arc<VecDeque<Arc<Token<Ast>>>>);
+pub struct Ast(Arc<VecDeque<Arc<Token<Arc<str>, Ast>>>>);
 impl Dsl for Ast {
-    type Str = Arc<str>;
+    type Str = Arc<str>; type Exp = Ast;
-    type Exp = Arc<VecDeque<Arc<Token<Ast>>>>;
+    fn dsl (&self) -> Val<Arc<str>, Ast> { Val::Exp(0, Ast(self.0.clone())) }
-    fn dsl (&self) -> Val<Self> { Val::Exp(0, self.0.clone()) }
 }
 /// The concrete syntax tree (CST) implements zero-copy
 /// parsing of the DSL from a string reference. CST items
 /// preserve info about their location in the source.
 /// CST stores strings as source references and expressions as [CstIter] instances.
 #[derive(Debug, Copy, Clone, Default, PartialEq)]
-pub struct Cst<'s>(CstConstIter<'s>);
+pub struct Cst<'s>(pub CstConstIter<'s>);
+pub type CstVal<'s> = Val<&'s str, Cst<'s>>;
+pub type CstToken<'s> = Token<&'s str, Cst<'s>>;
 impl<'s> Dsl for Cst<'s> {
-    type Str = &'s str;
+    type Str = &'s str; type Exp = Cst<'s>;
-    type Exp = CstConstIter<'s>;
+    fn dsl (&self) -> Val<Self::Str, Self::Exp> { Val::Exp(0, Cst(self.0)) }
-    fn dsl (&self) -> Val<Self> { Val::Exp(0, self.0) }
 }
 impl<'s> From<&'s str> for Cst<'s> {
     fn from (source: &'s str) -> Self {
         Self(CstConstIter(source))
     }
 }
-/// The string representation for a [Dsl] implementation.
-/// [Cst] uses `&'s str`. [Ast] uses `Arc<str>`.
-pub trait DslStr: PartialEq + Clone + Default + Debug + AsRef<str> + std::ops::Deref<Target = str> {}
-impl<T: PartialEq + Clone + Default + Debug + AsRef<str> + std::ops::Deref<Target = str>> DslStr for T {}
-/// The expression representation for a [Dsl] implementation.
-/// [Cst] uses [CstIter]. [Ast] uses [VecDeque].
-pub trait DslExp: PartialEq + Clone + Default + Debug {
-    fn head <D: Dsl> (&self) -> Val<D>;
-    fn tail (&self) -> Self;
-}
-impl DslExp for Arc<VecDeque<Arc<Token<Ast>>>> {
-    fn head <D: Dsl> (&self) -> Val<D> {
-        self.get(0).cloned().unwrap_or_else(||Arc::new(Default::default())).value.into()
-    }
-    fn tail (&self) -> Self {
-        Self::new(self.iter().skip(1).cloned().collect())
-    }
-}
-impl<'s> DslExp for CstConstIter<'s> {
-    fn head <D: Dsl> (&self) -> Val<D> {
-        peek(self.0).value.into()
-    }
-    fn tail (&self) -> Self {
-        let Token { span: Span { start, length, source }, .. } = peek(self.0);
-        Self(&source[(start+length)..])
-    }
-}
-impl<Str: Copy, Exp: Copy, D: Dsl<Str=Str,Exp=Exp> + Copy> Copy for Val<D> {}
-impl<D: Dsl> Val<D> {
-    pub fn is_nil        (&self) -> bool { matches!(self, Self::Nil) }
-    pub fn as_error      (&self) -> Option<&DslError> { if let Self::Error(e) = self { Some(e) } else { None } }
-    pub fn as_num        (&self) -> Option<usize>   {match self{Self::Num(n)=>Some(*n),_=>None}}
-    pub fn as_sym        (&self) -> Option<&str>    {match self{Self::Sym(s )=>Some(s.as_ref()),_=>None}}
-    pub fn as_key        (&self) -> Option<&str>    {match self{Self::Key(k )=>Some(k.as_ref()),_=>None}}
-    pub fn as_str        (&self) -> Option<&str>    {match self{Self::Str(s )=>Some(s.as_ref()),_=>None}}
-    //pub fn as_exp        (&self) -> Option<&D::Exp> {match self{Self::Exp(_, x)=>Some(x),_=>None}}
-    pub fn exp_depth     (&self) -> Option<usize> { todo!() }
-    pub fn exp_head_tail (&self) -> (Option<&Self>, Option<&D::Exp>) { (self.exp_head(), self.exp_tail()) }
-    pub fn exp_head      (&self) -> Option<&Self> { todo!() } // TODO
-    pub fn exp_tail      (&self) -> Option<&D::Exp> { todo!() }
-    pub fn peek          (&self) -> Option<Self> { todo!() }
-    pub fn next          (&mut self) -> Option<Self> { todo!() }
-    pub fn rest          (self) -> Vec<Self> { todo!() }
-    //pub fn convert <T: Dsl> (&self) -> Val<T> where
-        //T::Str: for<'a> From<&'a D::Str>,
-        //T::Exp: for<'a> From<&'a D::Exp>
-    //{
-        //match self { Val::Nil       => Val::Nil,
-                     //Val::Num(u)    => Val::Num(*u),
-                     //Val::Sym(s)    => Val::Sym(s.into()),
-                     //Val::Key(s)    => Val::Key(s.into()),
-                     //Val::Str(s)    => Val::Str(s.into()),
-                     //Val::Exp(d, x) => Val::Exp(*d, x.into()),
-                     //Val::Error(e)  => Val::Error(*e) } }
-    //pub fn exp_match <T, F> (&self, namespace: &str, cb: F) -> DslPerhaps<T>
-    //where F: Fn(&str, &Exp)-> DslPerhaps<T> {
-        //if let Some(Self::Key(key)) = self.exp_head()
-        //&& key.as_ref().starts_with(namespace)
-        //&& let Some(tail) = self.exp_tail() {
-            //cb(key.as_ref().split_at(namespace.len()).1, tail)
-        //} else {
-            //Ok(None)
-        //}
-    //}
-}
-
 /// DSL-specific error codes.
 #[derive(Error, Debug, Copy, Clone, PartialEq, PanicFmt)] pub enum DslError {
     #[error("parse failed: not implemented")]
@@ -175,15 +187,15 @@ impl<D: Dsl> Val<D> {
 /// [Cst::next] returns just the [Cst] and mutates `self`,
 /// instead of returning an updated version of the struct as [CstConstIter::next] does.
 #[derive(Copy, Clone, Debug, Default, PartialEq)]
-pub struct CstIter<'s>(CstConstIter<'s>);
+pub struct CstIter<'s>(pub CstConstIter<'s>);
 impl<'s> CstIter<'s> {
     pub const fn new (source: &'s str) -> Self { Self(CstConstIter::new(source)) }
 }
 impl<'s> Iterator for CstIter<'s> {
-    type Item = Token<Cst<'s>>;
+    type Item = CstToken<'s>;
     fn next (&mut self) -> Option<Self::Item> {
         match self.0.advance() {
-            Some((item, rest)) => { self.0 = rest; item.into() },
+            Some((item, rest)) => { self.0 = rest; Some(item.into()) },
             None => None,
         }
     }
@@ -199,8 +211,8 @@ impl<'s> From <&'s str> for CstConstIter<'s> {
     fn from (src: &'s str) -> Self { Self(src) }
 }
 impl<'s> Iterator for CstConstIter<'s> {
-    type Item = Token<Cst<'s>>;
+    type Item = CstToken<'s>;
-    fn next (&mut self) -> Option<Token<Cst<'s>>> { self.advance().map(|x|x.0) }
+    fn next (&mut self) -> Option<CstToken<'s>> { self.advance().map(|x|x.0) }
 }
 impl<'s> ConstIntoIter for CstConstIter<'s> {
     type Kind = IsIteratorKind;
@@ -210,17 +222,100 @@ impl<'s> ConstIntoIter for CstConstIter<'s> {
 impl<'s> CstConstIter<'s> {
     pub const fn new (source: &'s str) -> Self { Self(source) }
     pub const fn chomp (&self, index: usize) -> Self { Self(split_at(self.0, index).1) }
-    pub const fn advance (&mut self) -> Option<(Token<Cst<'s>>, Self)> {
+    pub const fn advance (&mut self) -> Option<(CstToken<'s>, Self)> {
-        match peek(self.0) {
+        match peek(Val::Nil, self.0) {
             Token { value: Val::Nil, .. } => None,
             token => {
-                let end = self.chomp(token.span.end());
+                let end = self.chomp(token.end());
                 Some((token.copy(), end))
             },
         }
     }
 }
 
+pub const fn peek <'s> (mut value: CstVal<'s>, source: &'s str) -> CstToken<'s> {
+    use Val::*;
+    let mut start  = 0;
+    let mut length = 0;
+    let mut source = source;
+    loop {
+        if let Some(((i, c), next)) = char_indices(source).next() {
+            if matches!(value, Error(_)) {
+                break
+            } else if matches!(value, Nil) {
+                if is_whitespace(c) {
+                    length += 1;
+                    continue
+                }
+                start  = i;
+                length = 1;
+                if is_exp_start(c) {
+                    value = Exp(1, Cst(CstConstIter(str_range(source, i, i+1))));
+                } else if is_str_start(c) {
+                    value = Str(str_range(source, i, i+1));
+                } else if is_sym_start(c) {
+                    value = Sym(str_range(source, i, i+1));
+                } else if is_key_start(c) {
+                    value = Key(str_range(source, i, i+1));
+                } else if is_digit(c) {
+                    value = match to_digit(c) { Ok(c) => Num(c), Err(e) => Error(e) };
+                } else {
+                    value = Error(Unexpected(c));
+                    break
+                }
+            } else if matches!(value, Str(_)) {
+                if is_str_end(c) {
+                    break
+                } else {
+                    value = Str(str_range(source, start, start + length + 1));
+                }
+            } else if matches!(value, Sym(_)) {
+                if is_sym_end(c) {
+                    break
+                } else if is_sym_char(c) {
+                    value = Sym(str_range(source, start, start + length + 1));
+                } else {
+                    value = Error(Unexpected(c));
+                }
+            } else if matches!(value, Key(_)) {
+                if is_key_end(c) {
+                    break
+                }
+                length += 1;
+                if is_key_char(c) {
+                    value = Key(str_range(source, start, start + length + 1));
+                } else {
+                    value = Error(Unexpected(c));
+                }
+            } else if let Exp(depth, exp) = value {
+                if depth == 0 {
+                    value = Exp(0, Cst(CstConstIter(str_range(source, start, start + length))));
+                    break
+                }
+                length += 1;
+                if c == ')' {
+                    value = Exp(depth-1, Cst(CstConstIter(str_range(source, start, start + length))));
+                } else if c == '(' {
+                    value = Exp(depth+1, Cst(CstConstIter(str_range(source, start, start + length))));
+                } else {
+                    value = Exp(depth, Cst(CstConstIter(str_range(source, start, start + length))));
+                }
+            } else if let Num(m) = value {
+                if is_num_end(c) {
+                    break
+                }
+                length += 1;
+                match to_digit(c) {
+                    Ok(n)  => { value = Num(n+10*m); },
+                    Err(e) => { value = Error(e); }
+                }
+            }
+        } else {
+            break
+        }
+    }
+    return Token { value, source, start, length }
+}
 const fn is_whitespace (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t') }
 const fn is_digit      (c: char) -> bool { matches!(c, '0'..='9') }
 const fn is_num_end    (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') }
@@ -233,48 +328,6 @@ const fn is_sym_end    (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') }
 const fn is_str_start  (c: char) -> bool { matches!(c, '"') }
 const fn is_str_end    (c: char) -> bool { matches!(c, '"') }
 const fn is_exp_start  (c: char) -> bool { matches!(c, '(') }
-
-pub const fn peek <'s> (src: &'s str) -> Token<Cst<'s>> {
-    use Val::*;
-    let mut t    = Token { value: Val::Nil, span: Span { source: src, start: 0, length: 0 } };
-    let mut iter = char_indices(src);
-    while let Some(((i, c), next)) = iter.next() {
-        t = match (t.value(), c) {
-            (Error(_), _)                 => return t,
-
-            (Nil, _) if is_exp_start(c)   => Token::new(src, i, 1, Exp(1, CstConstIter(str_range(src, i, i+1)))),
-            (Nil, _) if is_str_start(c)   => Token::new(src, i, 1, Str(str_range(src, i, i+1))),
-            (Nil, _) if is_sym_start(c)   => Token::new(src, i, 1, Sym(str_range(src, i, i+1))),
-            (Nil, _) if is_key_start(c)   => Token::new(src, i, 1, Key(str_range(src, i, i+1))),
-            (Nil, _) if is_digit(c)       => Token::new(src, i, 1, match to_digit(c) { Ok(c) => Num(c), Err(e) => Error(e) }),
-            (Nil, _) if is_whitespace(c)  => t.grown(),
-            (Nil, _)                      => { t.value = Val::Error(Unexpected(c)); t },
-
-            (Str(_), _) if is_str_end(c)  => return t,
-            (Str(_), _)                   => { t.value = Str(t.span.grow().slice()); t },
-
-            (Sym(_), _) if is_sym_end(c)  => return t,
-            (Sym(_), _) if is_sym_char(c) => { t.value = Sym(t.span.grow().slice()); t },
-            (Sym(_), _)                   => { t.value = Error(Unexpected(c)); t },
-
-            (Key(_), _) if is_key_end(c)  => return t,
-            (Key(_), _) if is_key_char(c) => { t.value = Key(t.span.grow().slice()); t },
-            (Key(_), _)                   => { t.value = Error(Unexpected(c)); t },
-
-            (Exp(0, _),  _)  => { t.value = Exp(0,      CstConstIter(t.span.grow().slice_exp())); return t },
-            (Exp(d, _), ')') => { t.value = Exp((*d)-1, CstConstIter(t.span.grow().slice_exp())); t },
-            (Exp(d, _), '(') => { t.value = Exp((*d)+1, CstConstIter(t.span.grow().slice_exp())); t },
-            (Exp(d, _),  _ ) => { t.value = Exp(*d,     CstConstIter(t.span.grow().slice_exp())); t },
-
-            (Num(m), _) if is_num_end(c)  => return t,
-            (Num(m), _)                   => match to_digit(c) {
-                Ok(n)  => { let m = *m; t.span.grow(); t.value = Num(n+10*m); t },
-                Err(e) => { t.span.grow(); t.value = Error(e); t } },
-        };
-        iter = next;
-    }
-    t
-}
 pub const fn to_number <D: Dsl> (digits: &str) -> Result<usize, DslError> {
     let mut iter = char_indices(digits);
     let mut value = 0;
@@ -294,60 +347,6 @@ pub const fn to_digit (c: char) -> Result<usize, DslError> {
         _ => return Err(Unexpected(c))
     })
 }
-/// Parsed substring with range and value.
-#[derive(Debug, Clone, Default, PartialEq)]
-pub struct Token<D: Dsl> {
-    /// Source span of token.
-    span:  Span<D>,
-    /// Meaning of token.
-    value: Val<D>,
-}
-#[derive(Debug, Copy, Clone, Default, PartialEq)]
-pub struct Span<D: Dsl> {
-    /// Reference to source text.
-    pub source: D::Str,
-    /// Index of 1st character of span.
-    pub start:  usize,
-    /// Length of span.
-    pub length: usize,
-}
-impl<'s, D: Dsl> Span<D> {
-    pub const fn end (&self) -> usize { self.start.saturating_add(self.length) }
-}
-impl<'s, D: Dsl<Str=&'s str>> Span<D> {
-    pub const fn slice (&self) -> &'s str {
-        str_range(self.source, self.start, self.end()) }
-    pub const fn slice_exp (&self) -> &'s str {
-        str_range(self.source, self.start.saturating_add(1), self.end()) }
-    pub const fn grow (&mut self) -> &mut Self {
-        let max_length = self.source.len().saturating_sub(self.start);
-        self.length    = self.length + 1;
-        if self.length > max_length { self.length = max_length }
-        self }
-}
-
-impl<D: Dsl> Token<D> {
-    pub const fn value (&self) -> &Val<D> { &self.value }
-    pub const fn span (&self) -> &Span<D> { &self.span }
-    pub const fn err (&self) -> Option<DslError> {
-        if let Val::Error(e) = self.value { Some(e) } else { None } }
-    pub const fn new (source: D::Str, start: usize, length: usize, value: Val<D>) -> Self { 
-        Self { value, span: Span { source, start, length } } }
-    pub const fn copy (&self) -> Self where D::Str: Copy, D::Exp: Copy, Val<D>: Copy {
-        Self { span: Span { ..self.span }, value: self.value } }
-}
-impl<'s, D: Dsl<Str = &'s str, Exp = CstConstIter<'s>>> Token<D> {
-    pub const fn grown (mut self) -> Self { self.span.grow(); self }
-    pub const fn grow_exp (&mut self, d: isize) -> &mut Self where D::Exp: From<&'s str> {
-        if let Val::Exp(depth, _) = self.value() {
-            self.value = Val::Exp(*depth as isize + d, CstConstIter(self.span.slice_exp()));
-            self
-        } else {
-            unreachable!()
-        }
-    }
-}
-
 /// `State` + [Dsl] -> `Self`.
 pub trait FromDsl<State>: Sized {
     fn try_from_dsl (state: &State, dsl: &impl Dsl) -> Perhaps<Self>;

input/src/input_dsl.rs

@@ -30,37 +30,34 @@ impl<'s, I: Debug + Ord, D: Dsl + From<Cst<'s>>> InputMap<I, D> {
         Self::from_source(read_and_leak(path)?)
     }
     /// Create input layer collection from string.
-    pub fn from_source (source: impl AsRef<str>) -> Usually<Self> {
+    pub fn from_source (source: &'s str) -> Usually<Self> {
-        Self::from_dsl(D::from(Cst::from(source.as_ref())))
+        Self::from_dsl(D::from(Cst(CstConstIter(source))))
     }
     /// Create input layer collection from DSL.
     pub fn from_dsl (dsl: D) -> Usually<Self> {
         use Val::*;
         let mut input_map: BTreeMap<I, Vec<InputBinding<D>>> = Default::default();
-        match dsl.exp() {
+        match dsl.exp_head() {
-            Some(exp) => match exp.head() {
+            Str(path) => {
-                Some(Str(path)) => {
+                let path = PathBuf::from(path.as_ref());
-                    let path = PathBuf::from(path.as_ref());
+                for (key, val) in InputMap::<I, D>::from_path(&path)?.0.into_iter() {
-                    for (key, val) in InputMap::<I, D>::from_path(&path)?.0.into_iter() {
+                    todo!("import {path:?} {key:?} {val:?}");
-                        todo!("import {path:?} {key:?} {val:?}");
+                    if !input_map.contains_key(&key) {
-                        if !input_map.contains_key(&key) {
+                        input_map.insert(key, vec![]);
-                            input_map.insert(key, vec![]);
-                        }
                     }
-                },
+                }
-                Some(Sym(sym)) => {
-                    //let key: I = sym.into();
-                    //if !input_map.contains_key(&key) {
-                        //input_map.insert(key, vec![]);
-                    //}
-                    todo!("binding {sym:?} {:?}", exp.tail());
-                },
-                Some(Key("if")) => {
-                    todo!("conditional binding {:?}", exp.tail());
-                },
-                _ => return Err(format!("invalid form in keymap: {exp:?}").into())
             },
-            _ => return Err(format!("not an expression: {dsl:?}").into())
+            Sym(sym) => {
+                //let key: I = sym.into();
+                //if !input_map.contains_key(&key) {
+                    //input_map.insert(key, vec![]);
+                //}
+                todo!("binding {sym:?} {:?}", dsl.exp_tail());
+            },
+            Key(s) if s.as_ref() == "if" => {
+                todo!("conditional binding {:?}", dsl.exp_tail());
+            },
+            _ => return Err(format!("invalid form in keymap: {dsl:?}").into())
         }
         Ok(Self(input_map))
     }