wip: fix(dsl): kinda patch it up

dsl/src/lib.rs

@@ -14,72 +14,135 @@ 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.
-pub type DslUsually<T> = Result<T, DslError>;
-pub type DslPerhaps<T> = Result<Option<T>, DslError>;
-
-/// Pronounced dizzle.
 pub trait Dsl: Clone + Debug {
     /// The string representation for a dizzle.
     type Str: DslStr;
     /// The expression representation for a dizzle.
     type Exp: DslExp;
-    /// Return a token iterator for this dizzle.
+    /// Request the top-level DSL [Val]ue.
-    fn dsl (&self) -> DslUsually<&Val<Self>>;
+    /// May perform cloning or parsing.
+    fn dsl (&self) -> Val<Self>;
+    fn err (&self) -> Option<DslError>  {self.dsl().err()}
+    fn nil (&self) -> bool              {self.dsl().nil()}
+    fn num (&self) -> Option<usize>     {self.dsl().num()}
+    fn sym (&self) -> Option<Self::Str> {self.dsl().sym()}
+    fn key (&self) -> Option<Self::Str> {self.dsl().key()}
+    fn str (&self) -> Option<Self::Str> {self.dsl().str()}
+    fn exp (&self) -> Option<Self::Exp> {self.dsl().exp()}
 }
-
+/// Enumeration of values that may figure in an expression.
-/// Enumeration of values representable by a DSL [Token]s.
+/// Generic over [Dsl] implementation.
-/// Generic over string and expression storage.
 #[derive(Clone, Debug, PartialEq, Default)]
 pub enum Val<D: Dsl> {
-    #[default]
+    /// Empty expression
-    Nil,
+    #[default] Nil,
     /// Unsigned integer literal
     Num(usize),
-    /// Tokens that start with `:`
+    /// An identifier that starts with `.`
     Sym(D::Str),
-    /// Tokens that don't start with `:`
+    /// An identifier that doesn't start with `:`
     Key(D::Str),
-    /// Quoted string literals
+    /// A quoted string literal
     Str(D::Str),
-    /// Expressions.
+    /// A sub-expression.
     Exp(
         /// Expression depth checksum. Must be 0, otherwise you have an unclosed delimiter.
-        usize,
+        isize,
         /// Expression content.
         D::Exp
     ),
+    /// An error.
     Error(DslError),
 }
-
-impl<Str: Copy, Exp: Copy, D: Dsl<Str=Str,Exp=Exp>> Copy for Val<D> {}
-
 impl<D: Dsl> Val<D> {
-    pub fn convert <T: Dsl> (&self) -> Val<T> where
+    pub fn err (&self) -> Option<DslError> {match self{Val::Error(e)=>Some(*e),        _=>None}}
-        B::Str: for<'a> From<&'a D::Str>,
+    pub fn nil (&self) -> bool             {match self{Val::Nil=>true,                 _=>false}}
-        B::Exp: for<'a> From<&'a D::Exp>
+    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}}
-        match self { Val::Nil       => Val::Nil,
+    pub fn key (&self) -> Option<D::Str>   {match self{Val::Key(k)=>Some(k.clone()),   _=>None}}
-                     Val::Num(u)    => Val::Num(*u),
+    pub fn str (&self) -> Option<D::Str>   {match self{Val::Str(s)=>Some(s.clone()),   _=>None}}
-                     Val::Sym(s)    => Val::Sym(s.into()),
+    pub fn exp (&self) -> Option<D::Exp>   {match self{Val::Exp(_, x)=>Some(x.clone()),_=>None}}
-                     Val::Key(s)    => Val::Key(s.into()),
+}
-                     Val::Str(s)    => Val::Str(s.into()),
+/// The abstract syntax tree (AST) can be produced from the CST
-                     Val::Exp(d, x) => Val::Exp(*d, x.into()),
+/// by cloning source slices into owned ([Arc]) string slices.
-                     Val::Error(e)  => Val::Error(*e) } }
+#[derive(Debug, Clone, Default, PartialEq)]
-    pub fn is_nil (&self) -> bool { matches!(self, Self::Nil) }
+pub struct Ast(Arc<VecDeque<Arc<Token<Ast>>>>);
-    pub fn as_error (&self) -> Option<&DslError> { if let Self::Error(e) = self { Some(e) } else { None } }
+impl Dsl for Ast {
-    pub fn as_num (&self) -> Option<usize>   {match self{Self::Num(n)=>Some(*n),_=>None}}
+    type Str = Arc<str>;
-    pub fn as_sym (&self) -> Option<&str>    {match self{Self::Sym(s )=>Some(s.as_ref()),_=>None}}
+    type Exp = Arc<VecDeque<Arc<Token<Ast>>>>;
-    pub fn as_key (&self) -> Option<&str>    {match self{Self::Key(k )=>Some(k.as_ref()),_=>None}}
+    fn dsl (&self) -> Val<Self> { Val::Exp(0, self.0.clone()) }
-    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}}
+/// The concrete syntax tree (CST) implements zero-copy
-    pub fn exp_depth (&self) -> Option<usize> { todo!() }
+/// 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>);
+impl<'s> Dsl for Cst<'s> {
+    type Str = &'s str;
+    type Exp = CstConstIter<'s>;
+    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_head      (&self) -> Option<&Self> { todo!() } // TODO
-    pub fn exp_tail (&self) -> Option<&D::Exp> { todo!() }
+    pub fn exp_tail      (&self) -> Option<&D::Exp> { todo!() }
-    pub fn peek (&self) -> Option<Self> { todo!() }
+    pub fn peek          (&self) -> Option<Self> { todo!() }
-    pub fn next (&mut self) -> Option<Self> { todo!() }
+    pub fn next          (&mut self) -> Option<Self> { todo!() }
-    pub fn rest (self) -> Vec<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()
@@ -92,61 +155,6 @@ impl<D: Dsl> Val<D> {
     //}
 }
 
-/// 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 {}
-impl <T: PartialEq + Clone + Default + Debug> DslExp for T {}
-
-/// 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(Token<Ast>);
-impl Dsl for Ast {
-    type Str = Arc<str>;
-    type Exp = VecDeque<Arc<Token<Ast>>>;
-    fn dsl (&self) -> DslUsually<&Val<Self>> {
-        Ok(self.0.value())
-    }
-}
-
-/// 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, Clone, Default, PartialEq)]
-pub struct Cst<'s>(Token<Cst<'s>>);
-impl<'s> Dsl for Cst<'s> {
-    type Str = &'s str;
-    type Exp = CstConstIter<'s>;
-    fn dsl (&self) -> DslUsually<&Val<Self>> {
-        Ok(self.0.value())
-    }
-}
-
-/// `State` + [Dsl] -> `Self`.
-pub trait FromDsl<State>: Sized {
-    fn try_from_dsl (state: &State, dsl: &impl Dsl) -> Perhaps<Self>;
-    fn from_dsl (state: &State, dsl: &impl Dsl, err: impl Fn()->Box<dyn Error>) -> Usually<Self> {
-        match Self::try_from_dsl(state, dsl)? { Some(dsl) => Ok(dsl), _ => Err(err()) } } }
-
-/// `self` + `Options` -> [Dsl]
-pub trait IntoDsl { /*TODO*/ }
-
-/// `self` + [Dsl] -> `Item`
-pub trait DslInto<Item> {
-    fn try_dsl_into (&self, dsl: &impl Dsl) -> Perhaps<Item>;
-    fn dsl_into (&self, dsl: &impl Dsl, err: impl Fn()->Box<dyn Error>) -> Usually<Item> {
-        match Self::try_dsl_into(self, dsl)? { Some(dsl) => Ok(dsl), _ => Err(err()) } } }
-
-/// `self` + `Item` -> [Dsl]
-pub trait DslFrom { /*TODO*/ }
-/// Standard result type for DSL-specific operations.
-pub type DslResult<T> = Result<T, DslError>;
 /// DSL-specific error codes.
 #[derive(Error, Debug, Copy, Clone, PartialEq, PanicFmt)] pub enum DslError {
     #[error("parse failed: not implemented")]
@@ -175,9 +183,8 @@ impl<'s> Iterator for CstIter<'s> {
     type Item = Token<Cst<'s>>;
     fn next (&mut self) -> Option<Self::Item> {
         match self.0.advance() {
-            Ok(Some((item, rest))) => { self.0 = rest; item.into() },
+            Some((item, rest)) => { self.0 = rest; item.into() },
-            Ok(None) => None,
+            None => None,
-            Err(e) => panic!("{e:?}")
         }
     }
 }
@@ -193,7 +200,7 @@ impl<'s> From <&'s str> for CstConstIter<'s> {
 }
 impl<'s> Iterator for CstConstIter<'s> {
     type Item = Token<Cst<'s>>;
-    fn next (&mut self) -> Option<Token<Cst<'s>>> { self.advance().unwrap().map(|x|x.0) }
+    fn next (&mut self) -> Option<Token<Cst<'s>>> { self.advance().map(|x|x.0) }
 }
 impl<'s> ConstIntoIter for CstConstIter<'s> {
     type Kind = IsIteratorKind;
@@ -203,21 +210,98 @@ 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 peek (&self) -> DslPerhaps<Token<Cst<'s>>> { Token::peek(self.0) }
+    pub const fn advance (&mut self) -> Option<(Token<Cst<'s>>, Self)> {
-    //pub const fn next (mut self) -> Option<(Token<Cst<'s>>, Self)> {
+        match peek(self.0) {
-        //Self::advance(&mut self).unwrap() }
+            Token { value: Val::Nil, .. } => None,
-    pub const fn advance (&mut self) -> DslPerhaps<(Token<Cst<'s>>, Self)> {
+            token => {
-        match self.peek() {
-            Ok(Some(token)) => {
                 let end = self.chomp(token.span.end());
-                Ok(Some((token.copy(), end)))
+                Some((token.copy(), end))
             },
-            Ok(None) => Ok(None),
-            Err(e) => Err(e)
         }
     }
 }
 
+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'|')') }
+const fn is_key_start  (c: char) -> bool { matches!(c, '/'|'a'..='z') }
+const fn is_key_char   (c: char) -> bool { matches!(c, 'a'..='z'|'0'..='9'|'-'|'/') }
+const fn is_key_end    (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') }
+const fn is_sym_start  (c: char) -> bool { matches!(c, ':'|'@') }
+const fn is_sym_char   (c: char) -> bool { matches!(c, 'a'..='z'|'A'..='Z'|'0'..='9'|'-') }
+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;
+    while let Some(((_, c), next)) = iter.next() {
+        match to_digit(c) {
+            Ok(digit) => value = 10 * value + digit,
+            Err(e) => return Err(e),
+        }
+        iter = next;
+    }
+    Ok(value)
+}
+pub const fn to_digit (c: char) -> Result<usize, DslError> {
+    Ok(match c {
+        '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4,
+        '5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9,
+        _ => 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.
@@ -235,20 +319,13 @@ impl<'s, D: Dsl<Str=&'s str>> Span<D> {
         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) -> DslUsually<&mut Self> {
+    pub const fn grow (&mut self) -> &mut Self {
-        if self.length + self.start >= self.source.len() { return Err(End) }
+        let max_length = self.source.len().saturating_sub(self.start);
-        self.length = self.length.saturating_add(1);
+        self.length    = self.length + 1;
-        Ok(self) }
+        if self.length > max_length { self.length = max_length }
+        self }
 }
 
-/// 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>,
-}
 impl<D: Dsl> Token<D> {
     pub const fn value (&self) -> &Val<D> { &self.value }
     pub const fn span (&self) -> &Span<D> { &self.span }
@@ -256,76 +333,14 @@ impl<D: Dsl> Token<D> {
         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 {
+    pub const fn copy (&self) -> Self where D::Str: Copy, D::Exp: Copy, Val<D>: Copy {
         Self { span: Span { ..self.span }, value: self.value } }
 }
-const fn or_panic <T> (result: DslUsually<T>) -> T {
+impl<'s, D: Dsl<Str = &'s str, Exp = CstConstIter<'s>>> Token<D> {
-    match result { Ok(t) => t, Err(e) => const_panic::concat_panic!(e) }
+    pub const fn grown (mut self) -> Self { self.span.grow(); self }
-}
-impl<'s, D: Dsl<Str = &'s str>> Token<D> {
-    pub const fn peek (src: D::Str) -> DslPerhaps<Self> where D::Exp: From<&'s str> {
-        use Val::*;
-        let mut t = Self::new(src, 0, 0, Nil);
-        let mut iter = char_indices(src);
-        while let Some(((i, c), next)) = iter.next() {
-            t = match (t.value(), c) {
-                (Error(_), _) =>
-                    return Ok(Some(t)),
-                (Nil, ' '|'\n'|'\r'|'\t') =>
-                    *or_panic(t.grow()),
-                (Nil, '(') =>
-                    Self::new(src, i, 1, Exp(1, D::Exp::from(str_range(src, i, i + 1)))),
-                (Nil, '"') =>
-                    Self::new(src, i, 1, Str(str_range(src, i, i + 1))),
-                (Nil, ':'|'@') =>
-                    Self::new(src, i, 1, Sym(str_range(src, i, i + 1))),
-                (Nil, '/'|'a'..='z') =>
-                    Self::new(src, i, 1, Key(str_range(src, i, i + 1))),
-                (Nil, '0'..='9') =>
-                    Self::new(src, i, 1, match to_digit(c) { Ok(c) => Num(c), Err(e) => Error(e) }),
-                (Nil, _) =>
-                    { t.value = Val::Error(Unexpected(c)); t },
-                (Str(_), '"') =>
-                    return Ok(Some(t)),
-                (Str(_), _) =>
-                    { or_panic(t.grow()); t.value = Str(t.span.slice()); t },
-                (Num(m), ' '|'\n'|'\r'|'\t'|')') =>
-                    return Ok(Some(t)),
-                (Num(m), _) => match to_digit(c) {
-                    Ok(n)  => { t.grow()?; t.value = Num(10*m+n); t },
-                    Err(e) => { t.grow()?; t.value = Error(e); t } },
-                (Sym(_), ' '|'\n'|'\r'|'\t'|')') =>
-                    return Ok(Some(t)),
-                (Sym(_), 'a'..='z'|'A'..='Z'|'0'..='9'|'-') => {
-                    t.grow()?; t.value = Sym(t.span.slice()); t },
-                (Sym(_), _) =>
-                    { t.value = Error(Unexpected(c)); t },
-                (Key(_), ' '|'\n'|'\r'|'\t'|')') =>
-                    return Ok(Some(t)),
-                (Key(_), 'a'..='z'|'0'..='9'|'-'|'/') =>
-                    { t.grow()?; t.value = Key(t.span.slice()); t },
-                (Key(_), _ ) =>
-                    { t.value = Error(Unexpected(c)); t },
-                (Exp(0, _),  _) =>
-                    { t.grow()?; t.value = Exp(0,   D::Exp::from(t.span.slice_exp())); return Ok(Some(t)) },
-                (Exp(d, _), ')') =>
-                    { t.grow()?; t.value = Exp(d-1, D::Exp::from(t.span.slice_exp())); t },
-                (Exp(d, _), '(') =>
-                    { t.grow()?; t.value = Exp(d+1, D::Exp::from(t.span.slice_exp())); t },
-                (Exp(d, _),  _ ) =>
-                    { t.grow()?; t.value = Exp(*d,  D::Exp::from(t.span.slice_exp())); t },
-            };
-            iter = next;
-        }
-        Ok(match t.value() {
-            Nil => None,
-            _ => Some(t)
-        })
-    }
-    pub const fn grow (&mut self) -> DslUsually<&mut Self> { self.span.grow()?; Ok(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) as usize, D::Exp::from(self.span.slice_exp()));
+            self.value = Val::Exp(*depth as isize + d, CstConstIter(self.span.slice_exp()));
             self
         } else {
             unreachable!()
@@ -333,20 +348,22 @@ impl<'s, D: Dsl<Str = &'s str>> Token<D> {
     }
 }
 
-pub const fn to_digit (c: char) -> DslResult<usize> {
+/// `State` + [Dsl] -> `Self`.
-    Ok(match c {
+pub trait FromDsl<State>: Sized {
-        '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4,
+    fn try_from_dsl (state: &State, dsl: &impl Dsl) -> Perhaps<Self>;
-        '5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9,
+    fn from_dsl (state: &State, dsl: &impl Dsl, err: impl Fn()->Box<dyn Error>) -> Usually<Self> {
-        _ => return Result::Err(Unexpected(c)) }) }
+        match Self::try_from_dsl(state, dsl)? { Some(dsl) => Ok(dsl), _ => Err(err()) } }
-
+}
-macro_rules! iterate(($expr:expr => $arg: pat => $body:expr) => {
+/// `self` + `Options` -> [Dsl]
-    let mut iter = $expr; while let Some(($arg, next)) = iter.next() { $body; iter = next; } });
+pub trait IntoDsl { /*TODO*/ }
-pub const fn to_number (digits: &str) -> DslResult<usize> {
+/// `self` + [Dsl] -> `Item`
-    let mut value = 0;
+pub trait DslInto<Item> {
-    iterate!(char_indices(digits) => (_, c) => match to_digit(c) {
+    fn try_dsl_into (&self, dsl: &impl Dsl) -> Perhaps<Item>;
-        Ok(digit) => value = 10 * value + digit,
+    fn dsl_into (&self, dsl: &impl Dsl, err: impl Fn()->Box<dyn Error>) -> Usually<Item> {
-        Result::Err(e) => return Result::Err(e) });
+        match Self::try_dsl_into(self, dsl)? { Some(dsl) => Ok(dsl), _ => Err(err()) } }
-    Ok(value) }
+}
+/// `self` + `Item` -> [Dsl]
+pub trait DslFrom { /*TODO*/ }
 
 /// Implement type conversions.
 macro_rules! from(($($Struct:ty { $(

input/src/input_dsl.rs

@@ -4,24 +4,24 @@ use crate::*;
 /// Each contained layer defines a mapping from input event to command invocation
 /// over a given state. Furthermore, each layer may have an associated cond,
 /// so that only certain layers are active at a given time depending on state.
-#[derive(Debug)] pub struct InputMap<I, T: Dsl>(
+#[derive(Debug)] pub struct InputMap<I, D: Dsl>(
     /// Map of input event (key combination) to
     /// all command expressions bound to it by
     /// all loaded input layers.
-    pub BTreeMap<I, Vec<InputBinding<T>>>
+    pub BTreeMap<I, Vec<InputBinding<D>>>
 );
-impl<I, T: Dsl> Default for InputMap<I, T> {
+impl<I, D: Dsl> Default for InputMap<I, D> {
     fn default () -> Self {
         Self(Default::default())
     }
 }
-#[derive(Debug, Default)] pub struct InputBinding<T: Dsl> {
+#[derive(Debug, Default)] pub struct InputBinding<D: Dsl> {
-    condition:   Option<T>,
+    condition:   Option<D>,
-    command:     T,
+    command:     D,
     description: Option<Arc<str>>,
     source:      Option<Arc<PathBuf>>,
 }
-impl<I: Debug + Ord, T: Dsl> InputMap<I, T> {
+impl<'s, I: Debug + Ord, D: Dsl + From<Cst<'s>>> InputMap<I, D> {
     /// Create input layer collection from path to text file.
     pub fn from_path <P: Debug + AsRef<Path>> (path: P) -> Usually<Self> {
         if !exists(path.as_ref())? {
@@ -30,22 +30,19 @@ impl<I: Debug + Ord, T: Dsl> InputMap<I, T> {
         Self::from_source(read_and_leak(path)?)
     }
     /// Create input layer collection from string.
-    pub fn from_source <S: AsRef<str>> (source: S) -> Usually<Self> {
+    pub fn from_source (source: impl AsRef<str>) -> Usually<Self> {
-        Self::from_dsl(CstIter::from(source.as_ref()))
+        Self::from_dsl(D::from(Cst::from(source.as_ref())))
     }
     /// Create input layer collection from DSL.
-    pub fn from_dsl <D: Dsl> (dsl: D) -> Usually<Self> {
+    pub fn from_dsl (dsl: D) -> Usually<Self> {
-        use DslVal::*;
+        use Val::*;
-        let mut input_map: BTreeMap<I, Vec<InputBinding<T>>> = Default::default();
+        let mut input_map: BTreeMap<I, Vec<InputBinding<D>>> = Default::default();
-        let mut index = 0;
+        match dsl.exp() {
-        while let Some(Exp(_, mut exp)) = dsl.nth(index) {
+            Some(exp) => match exp.head() {
-            let val = exp.nth(0).map(|x|x.val());
-            match val {
                 Some(Str(path)) => {
-                    let path   = PathBuf::from(path.as_ref());
+                    let path = PathBuf::from(path.as_ref());
-                    let module = InputMap::<I, T>::from_path(&path)?;
+                    for (key, val) in InputMap::<I, D>::from_path(&path)?.0.into_iter() {
-                    for (key, val) in module.0.into_iter() {
+                        todo!("import {path:?} {key:?} {val:?}");
-                        todo!("import {exp:?} {key:?} {val:?} {path:?}");
                         if !input_map.contains_key(&key) {
                             input_map.insert(key, vec![]);
                         }
@@ -56,14 +53,14 @@ impl<I: Debug + Ord, T: Dsl> InputMap<I, T> {
                     //if !input_map.contains_key(&key) {
                         //input_map.insert(key, vec![]);
                     //}
-                    todo!("binding {exp:?} {sym:?}");
+                    todo!("binding {sym:?} {:?}", exp.tail());
                 },
-                Some(Key(key)) if key.as_ref() == "if" => {
+                Some(Key("if")) => {
-                    todo!("conditional binding {exp:?} {key:?}");
+                    todo!("conditional binding {:?}", exp.tail());
                 },
-                _ => return Result::Err(format!("invalid token in keymap: {val:?}").into()),
+                _ => return Err(format!("invalid form in keymap: {exp:?}").into())
-            }
+            },
-            index += 1;
+            _ => return Err(format!("not an expression: {dsl:?}").into())
         }
         Ok(Self(input_map))
     }
@@ -92,23 +89,23 @@ impl<I: Debug + Ord, T: Dsl> InputMap<I, T> {
     /*
     /// Create an input map with a single non-condal layer.
     /// (Use [Default::default] to get an empty map.)
-    pub fn new (layer: DslVal<T::Str, T::Exp>) -> Self {
+    pub fn new (layer: Val<T::Str, T::Exp>) -> Self {
         Self::default().layer(layer)
     }
     /// Add layer, return `Self`.
-    pub fn layer (mut self, layer: DslVal<T::Str, T::Exp>) -> Self {
+    pub fn layer (mut self, layer: Val<T::Str, T::Exp>) -> Self {
         self.add_layer(layer); self
     }
     /// Add condal layer, return `Self`.
-    pub fn layer_if (mut self, cond: DslVal<T::Str, T::Exp>, layer: DslVal<T::Str, T::Exp>) -> Self {
+    pub fn layer_if (mut self, cond: Val<T::Str, T::Exp>, layer: Val<T::Str, T::Exp>) -> Self {
         self.add_layer_if(Some(cond), layer); self
     }
     /// Add layer, return `&mut Self`.
-    pub fn add_layer (&mut self, layer: DslVal<T::Str, T::Exp>) -> &mut Self {
+    pub fn add_layer (&mut self, layer: Val<T::Str, T::Exp>) -> &mut Self {
         self.add_layer_if(None, layer.into()); self
     }
     /// Add condal layer, return `&mut Self`.
-    pub fn add_layer_if (&mut self, cond: Option<DslVal<T::Str, T::Exp>>, bind: DslVal<T::Str, T::Exp>) -> &mut Self {
+    pub fn add_layer_if (&mut self, cond: Option<Val<T::Str, T::Exp>>, bind: Val<T::Str, T::Exp>) -> &mut Self {
         self.0.push(InputLayer { cond, bind });
         self
     }
@@ -182,7 +179,7 @@ impl<I: Debug + Ord, T: Dsl> InputMap<I, T> {
 //}
     //fn from (source: &'s str) -> Self {
         //// this should be for single layer:
-        //use DslVal::*;
+        //use Val::*;
         //let mut layers = vec![];
         //let mut source = CstIter::from(source);
         //while let Some(Exp(_, mut iter)) = source.next().map(|x|x.value) {

output/src/ops.rs

@@ -392,7 +392,7 @@ transform_xy_unit!("padding/x" "padding/y" "padding/xy"|self: Padding, area|{
         //)*) => {
             //$(
                 //impl<S,$($($A),+)?> FromDsl<S> for $Struct$(<$($A),+>)? {
-                    //fn try_dsl_from (
+                    //fn try_from_dsl (
                         //state: &S, dsl: &impl Dsl
                     //) -> Perhaps<Self> {
                         //todo!()
@@ -408,7 +408,7 @@ transform_xy_unit!("padding/x" "padding/y" "padding/xy"|self: Padding, area|{
             $op:literal $(/)? [$head: ident, $tail: ident] $expr:expr
         ) => {
             impl<S,$($($A),+)?> FromDsl<S> for $Struct$(<$($A),+>)? {
-                fn try_dsl_from (
+                fn try_from_dsl (
                     _state: &S, _dsl: &impl Dsl
                 ) -> Perhaps<Self> {
                     todo!()
@@ -423,7 +423,7 @@ transform_xy_unit!("padding/x" "padding/y" "padding/xy"|self: Padding, area|{
             $op:literal $(/)? [$head: ident, $tail: ident] $expr:expr
         ) => {
             impl<S,$($($A),+)?> FromDsl<S> for $Struct$(<$($A),+>)? {
-                fn try_dsl_from (
+                fn try_from_dsl (
                     _state: &S, _dsl: &impl Dsl
                 ) -> Perhaps<Self> {
                     todo!()