simplify

dsl/src/dsl.rs

@@ -0,0 +1,529 @@
+#![feature(adt_const_params)]
+#![feature(type_alias_impl_trait)]
+#![feature(impl_trait_in_fn_trait_return)]
+#![feature(const_precise_live_drops)]
+extern crate const_panic;
+use const_panic::{concat_panic, PanicFmt};
+pub(crate) use ::tengri_core::*;
+use std::ops::Deref;
+pub(crate) use std::error::Error;
+pub(crate) use std::fmt::Debug;
+pub(crate) use std::sync::Arc;
+pub(crate) use std::collections::VecDeque;
+pub(crate) use konst::iter::{ConstIntoIter, IsIteratorKind};
+pub(crate) use konst::string::{split_at, str_range, char_indices};
+pub(crate) use thiserror::Error;
+pub(crate) use self::DslError::*;
+#[cfg(test)] mod dsl_test;
+
+#[macro_export] macro_rules! dsl_read_advance (($exp:ident, $pat:pat => $val:expr)=>{{
+    let (head, tail) = $exp.advance(); $exp = tail; match head {
+        Some($pat) => $val, _ => Err(format!("(e4) unexpected {head:?}").into()) }}});
+
+/// Coerce to [Val] for predefined [Self::Str] and [Self::Exp].
+pub trait Dsl: Clone + Debug {
+    /// The string representation for a dizzle.
+    type Str: DslStr;
+    /// The string representation for a dizzle.
+    type Exp: DslExp;
+    /// Request the top-level DSL [Val]ue.
+    /// May perform cloning or parsing.
+    fn val       (&self) -> Val<Self::Str, Self::Exp>;
+    fn err       (&self) -> Option<DslError>           {self.val().err()}
+    fn nil       (&self) -> bool                       {self.val().nil()}
+    fn num       (&self) -> Option<usize>              {self.val().num()}
+    fn sym       (&self) -> Option<Self::Str>          {self.val().sym()}
+    fn key       (&self) -> Option<Self::Str>          {self.val().key()}
+    fn str       (&self) -> Option<Self::Str>          {self.val().str()}
+    fn exp       (&self) -> Option<Self::Exp>          {self.val().exp()}
+    fn exp_depth (&self) -> Option<isize>              {self.val().exp_depth()}
+    fn exp_head  (&self) -> Val<Self::Str, Self::Exp>  {self.val().exp_head()}
+    fn exp_tail  (&self) -> Self::Exp                  {self.val().exp_tail()}
+    fn exp_each  (&self, f: impl Fn(&Self) -> Usually<()>) -> Usually<()> {
+        todo!()
+    }
+    fn advance   (&self) -> (Val<Self::Str, Self::Exp>, Self::Exp) {
+        (self.exp_head(), self.exp_tail())
+    }
+}
+
+impl<'s> Dsl for &'s str {
+    type Str = &'s str;
+    type Exp = &'s str;
+    fn val (&self) -> Val<Self::Str, Self::Exp> { Val::Exp(0, self) }
+}
+
+impl<'s> Dsl for Cst<'s> {
+    type Str = &'s str;
+    type Exp = Cst<'s>;
+    fn val (&self) -> Val<Self::Str, Self::Exp> { Val::Exp(0, *self) }
+}
+
+impl Dsl for Ast {
+    type Str = Arc<str>;
+    type Exp = Ast;
+    fn val (&self) -> Val<Self::Str, Ast> { Val::Exp(0, self.clone()) }
+}
+
+impl<Str: DslStr, Exp: DslExp> Dsl for Token<Str, Exp> {
+    type Str = Str;
+    type Exp = Exp;
+    fn val (&self) -> Val<Str, Exp> { self.value.clone() }
+}
+
+impl<Str: DslStr, Exp: DslExp> Dsl for Val<Str, Exp> {
+    type Str = Str;
+    type Exp = Exp;
+    fn val (&self) -> Val<Str, Exp> { self.clone() }
+}
+
+/// The expression representation for a [Dsl] implementation.
+/// [Cst] uses [CstIter]. [Ast] uses [VecDeque].
+pub trait DslExp: PartialEq + Clone + Debug + Dsl {}
+impl<T: PartialEq + Clone + 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> + Deref<Target = str> {
+    fn as_str (&self) -> &str     { self.as_ref() }
+    fn as_arc (&self) -> Arc<str> { self.as_ref().into() }
+}
+impl<Str: PartialEq + Clone + Default + Debug + AsRef<str> + Deref<Target = str>> DslStr for Str {}
+/// 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<S1, E1> Val<S1, E1> {
+    pub fn convert_to <S2, E2> (&self, to_str: impl Fn(&S1)->S2, to_exp: impl Fn(&E1)->E2) -> Val<S2, E2> {
+        match self {
+            Val::Nil       => Val::Nil,
+            Val::Num(u)    => Val::Num(*u),
+            Val::Sym(s)    => Val::Sym(to_str(s)),
+            Val::Key(s)    => Val::Key(to_str(s)),
+            Val::Str(s)    => Val::Str(to_str(s)),
+            Val::Exp(d, x) => Val::Exp(*d, to_exp(x)),
+            Val::Error(e)  => Val::Error(*e)
+        }
+    }
+}
+impl<Str: DslStr, Exp: DslExp + Dsl<Str=Str>> 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,
+}
+/// Tokens are copiable where possible.
+impl<Str: Copy, Exp: Copy> Copy for Token<Str, Exp> {}
+/// Token methods.
+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 }
+    }
+}
+/// 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, PartialEq, Default)]
+pub enum Cst<'s> {
+    #[default] __,
+    Source(&'s str),
+    Token(CstToken<'s>),
+    Val(CstVal<'s>),
+    Iter(CstIter<'s>),
+    ConstIter(CstConstIter<'s>),
+}
+impl<'s> From<&'s str> for Cst<'s> {
+    fn from (src: &'s str) -> Self {
+        Cst::Source(src)
+    }
+}
+impl<'s> From<CstToken<'s>> for Cst<'s> {
+    fn from (token: CstToken<'s>) -> Self {
+        Cst::Token(token)
+    }
+}
+impl<'s> From<CstVal<'s>> for Cst<'s> {
+    fn from (val: CstVal<'s>) -> Self {
+        Cst::Val(val)
+    }
+}
+impl<'s> From<CstIter<'s>> for Cst<'s> {
+    fn from (iter: CstIter<'s>) -> Self {
+        Cst::Iter(iter)
+    }
+}
+impl<'s> From<CstConstIter<'s>> for Cst<'s> {
+    fn from (iter: CstConstIter<'s>) -> Self {
+        Cst::ConstIter(iter)
+    }
+}
+impl<'s> From<Cst<'s>> for Ast {
+    fn from (cst: Cst<'s>) -> Self {
+        match cst {
+            Cst::Source(source) | Cst::Iter(CstIter(CstConstIter(source))) |
+            Cst::ConstIter(CstConstIter(source)) =>
+                Ast::Source(source.into()),
+            Cst::Val(value) =>
+                Ast::Val(value.convert_to(|s|(*s).into(), |e|Box::new((*e).into()))),
+            Cst::Token(Token { source, start, length, value }) => {
+                let source = AsRef::<str>::as_ref(source).into();
+                let value  = value.convert_to(|s|(*s).into(), |e|Box::new((*e).into()));
+                Ast::Token(Token { source, start, length, value })
+            },
+            _ => unreachable!()
+        }
+    }
+}
+/// The abstract syntax tree (AST) can be produced from the CST
+/// by cloning source slices into owned ([Arc]) string slices.
+#[derive(Debug, Clone, PartialEq, Default)]
+pub enum Ast {
+    #[default] __,
+    Source(Arc<str>),
+    Token(Token<Arc<str>, Box<Ast>>),
+    Val(Val<Arc<str>, Box<Ast>>),
+    Exp(Arc<VecDeque<Arc<Token<Arc<str>, Ast>>>>),
+}
+impl<'s> From<&'s str> for Ast {
+    fn from (src: &'s str) -> Self {
+        Self::Source(src.into())
+    }
+}
+impl<'s, Str: DslStr, Exp: DslExp + Into<Ast> + 's> From<Token<Str, Exp>> for Ast {
+    fn from (Token { source, start, length, value }: Token<Str, Exp>) -> Self {
+        let source: Arc<str> = source.as_ref().into();
+        let value = value.convert_to(|s|s.as_ref().into(), |e|Box::new(e.clone().into()));
+        Self::Token(Token { source, start, length, value })
+    }
+}
+pub type CstVal<'s> = Val<&'s str, &'s str>;
+pub type CstToken<'s> = Token<&'s str, &'s str>;
+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, source);
+        self
+    }
+}
+//impl<'s> From<&'s str> for Ast {
+    //fn from (source: &'s str) -> Ast {
+        //let source: Arc<str> = source.into();
+        //Ast(CstIter(CstConstIter(source.as_ref()))
+            //.map(|token|Arc::new(Token {
+                //source: source.clone(),
+                //start:  token.start,
+                //length: token.length,
+                //value:  match token.value {
+                    //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.into())
+                //},
+            //}))
+            //.collect::<VecDeque<_>>()
+            //.into())
+    //}
+//}
+/// DSL-specific error codes.
+#[derive(Error, Debug, Copy, Clone, PartialEq, PanicFmt)] pub enum DslError {
+    #[error("parse failed: not implemented")]
+    Unimplemented,
+    #[error("parse failed: empty")]
+    Empty,
+    #[error("parse failed: incomplete")]
+    Incomplete,
+    #[error("parse failed: unexpected character '{0}'")]
+    Unexpected(char),
+    #[error("parse failed: error #{0}")]
+    Code(u8),
+    #[error("end reached")]
+    End
+}
+/// Provides native [Iterator] API over [CstConstIter], emitting [Cst] items.
+///
+/// [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>(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 = CstToken<'s>;
+    fn next (&mut self) -> Option<Self::Item> {
+        match self.0.advance() {
+            Some((item, rest)) => { self.0 = rest; Some(item.into()) },
+            None => None,
+        }
+    }
+}
+/// Holds a reference to the source text.
+/// [CstConstIter::next] emits subsequent pairs of:
+/// * a [Cst] and
+/// * the source text remaining
+///   * [ ] TODO: maybe [CstConstIter::next] should wrap the remaining source in `Self` ?
+#[derive(Copy, Clone, Debug, Default, PartialEq)]
+pub struct CstConstIter<'s>(pub &'s str);
+impl<'s> From <&'s str> for CstConstIter<'s> {
+    fn from (src: &'s str) -> Self { Self(src) }
+}
+impl<'s> Iterator for CstConstIter<'s> {
+    type Item = CstToken<'s>;
+    fn next (&mut self) -> Option<CstToken<'s>> { self.advance().map(|x|x.0) }
+}
+impl<'s> ConstIntoIter for CstConstIter<'s> {
+    type Kind = IsIteratorKind;
+    type Item = Cst<'s>;
+    type IntoIter = Self;
+}
+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<(CstToken<'s>, Self)> {
+        match peek(Val::Nil, self.0) {
+            Token { value: Val::Nil, .. } => None,
+            token => {
+                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;
+                value = if is_exp_start(c)  { Exp(1, str_range(source, i, i+1)) }
+                    else if is_str_start(c) { Str(str_range(source, i, i+1)) }
+                    else if is_sym_start(c) { Sym(str_range(source, i, i+1)) }
+                    else if is_key_start(c) { Key(str_range(source, i, i+1)) }
+                    else if is_digit(c) { 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, str_range(source, start, start + length));
+                    break
+                }
+                length += 1;
+                value = Exp(
+                    if c == ')' { depth-1 } else if c == '(' { depth+1 } else { depth },
+                    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'|')') }
+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 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))
+    })
+}
+
+/// Implement type conversions.
+macro_rules! from(($($Struct:ty { $(
+    $(<$($l:lifetime),* $($T:ident$(:$U:ident)?),*>)? ($source:ident: $From:ty) $expr:expr
+);+ $(;)? })*) => { $(
+    $(impl $(<$($l),* $($T$(:$U)?),*>)? From<$From> for $Struct {
+        fn from ($source: $From) -> Self { $expr }
+    })+
+)* });
+
+//from! {
+    ////Vec<Token<'s>>   { <'s> (val: CstIter<'s>) val.collect();  }
+    //CstConstIter<'s> {
+        //<'s> (src: &'s str) Self(src);
+        //<'s> (iter: CstIter<'s>) iter.0; }
+    //CstIter<'s> {
+        //<'s> (src: &'s str) Self(CstConstIter(src));
+        //<'s> (iter: CstConstIter<'s>) Self(iter); }
+    //Cst<'s>  { <'s> (src: &'s str) Self(CstIter(CstConstIter(src))); }
+    //Vec<Ast> { <'s> (val: CstIter<'s>) val.map(Into::into).collect(); }
+    //Token<Cst<'s>> { <'s> (token: Token<Cst<'s>>) Self { value: token.value.into(), span: token.span.into() } }
+    //Ast {
+        //<'s> (src: &'s str) Ast::from(CstIter(CstConstIter(src)));
+        //<'s> (cst: Cst<'s>) Ast(VecDeque::from([dsl_val(cst.val())]).into());
+        //<'s> (iter: CstIter<'s>) Ast(iter.map(|x|x.value.into()).collect::<VecDeque<_>>().into());
+        //<D: Dsl> (token: Token<D>) Ast(VecDeque::from([dsl_val(token.val())]).into()); }
+//}
+
+/// `T` + [Dsl] -> `Self`.
+pub trait FromDsl<T>: Sized {
+    fn from_dsl (state: &T, dsl: &impl Dsl) -> Perhaps<Self>;
+    fn from_dsl_or (state: &T, dsl: &impl Dsl, err: Box<dyn Error>) -> Usually<Self> {
+        Self::from_dsl(state, dsl)?.ok_or(err)
+    }
+    fn from_dsl_or_else (state: &T, dsl: &impl Dsl, err: impl Fn()->Box<dyn Error>) -> Usually<Self> {
+        Self::from_dsl(state, dsl)?.ok_or_else(err)
+    }
+}
+
+impl<T: FromDsl<U>, U> DslInto<T> for U {
+    fn dsl_into (&self, dsl: &impl Dsl) -> Perhaps<T> {
+        T::from_dsl(self, dsl)
+    }
+}
+
+/// `self` + [Dsl] -> `T`
+pub trait DslInto<T> {
+    fn dsl_into (&self, dsl: &impl Dsl) -> Perhaps<T>;
+    fn dsl_into_or (&self, dsl: &impl Dsl, err: Box<dyn Error>) -> Usually<T> {
+        self.dsl_into(dsl)?.ok_or(err)
+    }
+    fn dsl_into_or_else (&self, dsl: &impl Dsl, err: impl Fn()->Box<dyn Error>) -> Usually<T> {
+        self.dsl_into(dsl)?.ok_or_else(err)
+    }
+}
+
+/// `self` + `T` + -> [Dsl]
+pub trait IntoDsl<T> {
+    fn into_dsl (&self, state: &T) -> Perhaps<impl Dsl>;
+    fn into_dsl_or (&self, state: &T, err: Box<dyn Error>) -> Usually<impl Dsl> {
+        self.into_dsl(state)?.ok_or(err)
+    }
+    fn into_dsl_or_else (&self, state: &T, err: impl Fn()->Box<dyn Error>) -> Usually<impl Dsl> {
+        self.into_dsl(state)?.ok_or_else(err)
+    }
+}
+
+/// `self` + `T` -> [Dsl]
+pub trait DslFrom<T> {
+    fn dsl_from (&self, dsl: &impl Dsl) -> Perhaps<impl Dsl>;
+    fn dsl_from_or (&self, dsl: &impl Dsl, err: Box<dyn Error>) -> Usually<impl Dsl> {
+        self.dsl_from(dsl)?.ok_or(err)
+    }
+    fn dsl_from_or_else (&self, dsl: &impl Dsl, err: impl Fn()->Box<dyn Error>) -> Usually<impl Dsl> {
+        self.dsl_from(dsl)?.ok_or_else(err)
+    }
+}