From cb47c4d0ff6d68f55f6ff716933914b93bbcb0a4 Mon Sep 17 00:00:00 2001 From: unspeaker Date: Tue, 27 May 2025 00:53:06 +0300 Subject: [PATCH] dsl goes fat --- dsl/src/dsl_ast.rs | 24 +++- dsl/src/dsl_cst.rs | 177 ++++++++++++++++++++++++++++- dsl/src/dsl_domain.rs | 4 +- dsl/src/dsl_iter.rs | 24 +++- dsl/src/dsl_test.rs | 124 +++++++++++++++++++++ dsl/src/dsl_token.rs | 245 ----------------------------------------- dsl/src/dsl_value.rs | 84 ++++++++++++++ dsl/src/lib.rs | 137 +---------------------- input/src/input_dsl.rs | 25 ++--- input/src/lib.rs | 1 + output/src/ops_dsl.rs | 160 ++++++++++++--------------- 11 files changed, 513 insertions(+), 492 deletions(-) create mode 100644 dsl/src/dsl_test.rs create mode 100644 dsl/src/dsl_value.rs diff --git a/dsl/src/dsl_ast.rs b/dsl/src/dsl_ast.rs index fca3fd6..24a0f6f 100644 --- a/dsl/src/dsl_ast.rs +++ b/dsl/src/dsl_ast.rs @@ -1,13 +1,16 @@ use crate::*; use std::sync::Arc; use std::borrow::Cow; + #[derive(Debug, Clone, Default, PartialEq)] pub struct Ast(pub Value, AstIter>); + impl<'source> From> for Ast { fn from (token: CstToken<'source>) -> Self { token.value().into() } } + impl<'source> From> for Ast { fn from (value: CstValue<'source>) -> Self { use Value::*; @@ -23,10 +26,21 @@ impl<'source> From> for Ast { } } -#[derive(Debug, Copy, Clone, Default, PartialEq)] -pub struct AstIter; // TODO -impl<'source> From> for AstIter { - fn from (source: SourceIter<'source>) -> Self { - Self // TODO +impl DslValue for Ast { + type Str = Arc; + type Exp = AstIter; + fn value (&self) -> &Value, AstIter> { + self.0.value() + } +} + +impl DslToken for Ast { + type Value = Self; + type Meta = (); + fn value (&self) -> &Self::Value { + self + } + fn meta (&self) -> &Self::Meta { + &() } } diff --git a/dsl/src/dsl_cst.rs b/dsl/src/dsl_cst.rs index 1af6f8f..7757a70 100644 --- a/dsl/src/dsl_cst.rs +++ b/dsl/src/dsl_cst.rs @@ -1,12 +1,183 @@ use crate::*; + /// CST stores strings as source references and expressions as new [SourceIter] instances. pub type CstValue<'source> = Value<&'source str, SourceIter<'source>>; -/// Token sharing memory with source reference. -#[derive(Debug, Copy, Clone, Default, PartialEq)] -pub struct CstToken<'source>(pub CstValue<'source>, pub CstMeta<'source>); + /// Reference to the source slice. #[derive(Debug, Copy, Clone, Default, PartialEq)] pub struct CstMeta<'source> { pub source: &'source str, pub start: usize, pub length: usize, } + +/// Token sharing memory with source reference. +#[derive(Debug, Copy, Clone, Default, PartialEq)] +pub struct CstToken<'source>(pub CstValue<'source>, pub CstMeta<'source>); + +impl<'source> CstToken<'source> { + pub const fn new ( + source: &'source str, start: usize, length: usize, value: CstValue<'source> + ) -> Self { + Self(value, CstMeta { source, start, length }) + } + pub const fn end (&self) -> usize { + self.1.start.saturating_add(self.1.length) + } + pub const fn slice (&'source self) -> &'source str { + self.slice_source(self.1.source) + } + pub const fn slice_source <'range> (&'source self, source: &'range str) -> &'range str { + str_range(source, self.1.start, self.end()) + } + pub const fn slice_source_exp <'range> (&'source self, source: &'range str) -> &'range str { + str_range(source, self.1.start.saturating_add(1), self.end()) + } + pub const fn with_value (self, value: CstValue<'source>) -> Self { + Self(value, self.1) + } + pub const fn value (&self) -> CstValue<'source> { + self.0 + } + pub const fn error (self, error: DslError) -> Self { + Self(Value::Err(error), self.1) + } + pub const fn grow (self) -> Self { + Self(self.0, CstMeta { length: self.1.length.saturating_add(1), ..self.1 }) + } + pub const fn grow_num (self, m: usize, c: char) -> Self { + use Value::*; + match to_digit(c) { + Result::Ok(n) => Self(Num(10*m+n), self.grow().1), + Result::Err(e) => Self(Err(e), self.grow().1), + } + } + pub const fn grow_key (self) -> Self { + use Value::*; + let token = self.grow(); + token.with_value(Key(token.slice_source(self.1.source))) + } + pub const fn grow_sym (self) -> Self { + use Value::*; + let token = self.grow(); + token.with_value(Sym(token.slice_source(self.1.source))) + } + pub const fn grow_str (self) -> Self { + use Value::*; + let token = self.grow(); + token.with_value(Str(token.slice_source(self.1.source))) + } + pub const fn grow_exp (self) -> Self { + use Value::*; + let token = self.grow(); + if let Exp(depth, _) = token.value() { + token.with_value(Exp(depth, SourceIter::new(token.slice_source_exp(self.1.source)))) + } else { + unreachable!() + } + } + pub const fn grow_in (self) -> Self { + let token = self.grow_exp(); + if let Value::Exp(depth, source) = token.value() { + token.with_value(Value::Exp(depth.saturating_add(1), source)) + } else { + unreachable!() + } + } + pub const fn grow_out (self) -> Self { + let token = self.grow_exp(); + if let Value::Exp(depth, source) = token.value() { + if depth > 0 { + token.with_value(Value::Exp(depth - 1, source)) + } else { + return self.error(Unexpected(')')) + } + } else { + unreachable!() + } + } +} + +pub const fn to_number (digits: &str) -> DslResult { + let mut value = 0; + iterate!(char_indices(digits) => (_, c) => match to_digit(c) { + Ok(digit) => value = 10 * value + digit, + Result::Err(e) => return Result::Err(e) + }); + Ok(value) +} + +pub const fn to_digit (c: char) -> DslResult { + Ok(match c { + '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4, + '5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9, + _ => return Result::Err(Unexpected(c)) + }) +} + +/// Static iteration helper. +#[macro_export] macro_rules! iterate { + ($expr:expr => $arg: pat => $body:expr) => { + let mut iter = $expr; + while let Some(($arg, next)) = iter.next() { + $body; + iter = next; + } + } +} + +pub const fn peek_src <'a> (source: &'a str) -> Option> { + use Value::*; + let mut token: CstToken<'a> = CstToken::new(source, 0, 0, Nil); + iterate!(char_indices(source) => (start, c) => token = match token.value() { + Err(_) => return Some(token), + Nil => match c { + ' '|'\n'|'\r'|'\t' => + token.grow(), + '(' => + CstToken::new(source, start, 1, Exp(1, SourceIter::new(str_range(source, start, start + 1)))), + '"' => + CstToken::new(source, start, 1, Str(str_range(source, start, start + 1))), + ':'|'@' => + CstToken::new(source, start, 1, Sym(str_range(source, start, start + 1))), + '/'|'a'..='z' => + CstToken::new(source, start, 1, Key(str_range(source, start, start + 1))), + '0'..='9' => + CstToken::new(source, start, 1, match to_digit(c) { + Ok(c) => Value::Num(c), + Result::Err(e) => Value::Err(e) + }), + _ => token.error(Unexpected(c)) + }, + Str(_) => match c { + '"' => return Some(token), + _ => token.grow_str(), + }, + Num(n) => match c { + '0'..='9' => token.grow_num(n, c), + ' '|'\n'|'\r'|'\t'|')' => return Some(token), + _ => token.error(Unexpected(c)) + }, + Sym(_) => match c { + 'a'..='z'|'A'..='Z'|'0'..='9'|'-' => token.grow_sym(), + ' '|'\n'|'\r'|'\t'|')' => return Some(token), + _ => token.error(Unexpected(c)) + }, + Key(_) => match c { + 'a'..='z'|'0'..='9'|'-'|'/' => token.grow_key(), + ' '|'\n'|'\r'|'\t'|')' => return Some(token), + _ => token.error(Unexpected(c)) + }, + Exp(depth, _) => match depth { + 0 => return Some(token.grow_exp()), + _ => match c { + ')' => token.grow_out(), + '(' => token.grow_in(), + _ => token.grow_exp(), + } + }, + }); + match token.value() { + Nil => None, + _ => Some(token), + } +} diff --git a/dsl/src/dsl_domain.rs b/dsl/src/dsl_domain.rs index 8289ff8..d8d502e 100644 --- a/dsl/src/dsl_domain.rs +++ b/dsl/src/dsl_domain.rs @@ -27,9 +27,9 @@ pub trait Eval { /// May construct [Self] from token stream. pub trait Dsl: Sized { - fn try_provide (state: &State, source: impl DslValue) -> Perhaps; + fn try_provide (state: &State, source: Ast) -> Perhaps; fn provide >, F: Fn()->E> ( - state: &State, source: impl DslValue, error: F + state: &State, source: Ast, error: F ) -> Usually { let next = format!("{source:?}"); if let Some(value) = Self::try_provide(state, source)? { diff --git a/dsl/src/dsl_iter.rs b/dsl/src/dsl_iter.rs index b532648..07cfdd7 100644 --- a/dsl/src/dsl_iter.rs +++ b/dsl/src/dsl_iter.rs @@ -4,7 +4,29 @@ pub trait DslIter { type Token: DslToken; fn peek (&self) -> Option<::Value>; fn next (&mut self) -> Option<::Value>; - fn rest (&self) -> Option<&[::Value]>; + fn rest (self) -> Vec; +} + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct AstIter(std::collections::VecDeque); + +impl DslIter for AstIter { + type Token = Ast; + fn peek (&self) -> Option { + self.0.get(0).cloned() + } + fn next (&mut self) -> Option { + self.0.pop_front() + } + fn rest (self) -> Vec { + self.0.into() + } +} + +impl<'source> From> for AstIter { + fn from (source: SourceIter<'source>) -> Self { + Self(source.map(Into::into).collect()) + } } /// Provides a native [Iterator] API over [SourceConstIter], diff --git a/dsl/src/dsl_test.rs b/dsl/src/dsl_test.rs new file mode 100644 index 0000000..4f7c4b2 --- /dev/null +++ b/dsl/src/dsl_test.rs @@ -0,0 +1,124 @@ +#[cfg(test)] mod test_token_iter { + use crate::*; + //use proptest::prelude::*; + #[test] fn test_iters () { + let mut iter = crate::SourceIter::new(&":foo :bar"); + let _ = iter.next(); + let mut iter = crate::TokenIter::new(&":foo :bar"); + let _ = iter.next(); + } + #[test] const fn test_const_iters () { + let mut iter = crate::SourceIter::new(&":foo :bar"); + let _ = iter.next(); + } + #[test] fn test_num () { + let digit = to_digit('0'); + let digit = to_digit('x'); + let number = to_number(&"123"); + let number = to_number(&"12asdf3"); + } + //proptest! { + //#[test] fn proptest_source_iter ( + //source in "\\PC*" + //) { + //let mut iter = crate::SourceIter::new(&source); + ////let _ = iter.next(); + //} + //#[test] fn proptest_token_iter ( + //source in "\\PC*" + //) { + //let mut iter = crate::TokenIter::new(&source); + ////let _ = iter.next(); + //} + //} +} + +#[cfg(test)] mod test_token_prop { + use proptest::prelude::*; + proptest! { + #[test] fn test_token_prop ( + source in "\\PC*", + start in usize::MIN..usize::MAX, + length in usize::MIN..usize::MAX, + ) { + let token = crate::Token { + source: &source, + start, + length, + value: crate::Value::Nil + }; + let _ = token.slice(); + } + } +} + +#[cfg(test)] #[test] fn test_token () -> Result<(), Box> { + let source = ":f00"; + let mut token = Token { source, start: 0, length: 1, value: Sym(":") }; + token = token.grow_sym(); + assert_eq!(token, Token { source, start: 0, length: 2, value: Sym(":f") }); + token = token.grow_sym(); + assert_eq!(token, Token { source, start: 0, length: 3, value: Sym(":f0") }); + token = token.grow_sym(); + assert_eq!(token, Token { source, start: 0, length: 4, value: Sym(":f00") }); + + let src = ""; + assert_eq!(None, SourceIter(src).next()); + + let src = " \n \r \t "; + assert_eq!(None, SourceIter(src).next()); + + let src = "7"; + assert_eq!(Num(7), SourceIter(src).next().unwrap().0.value); + + let src = " 100 "; + assert_eq!(Num(100), SourceIter(src).next().unwrap().0.value); + + let src = " 9a "; + assert_eq!(Err(Unexpected('a')), SourceIter(src).next().unwrap().0.value); + + let src = " :123foo "; + assert_eq!(Sym(":123foo"), SourceIter(src).next().unwrap().0.value); + + let src = " \r\r\r\n\n\n@bar456\t\t\t\t\t\t"; + assert_eq!(Sym("@bar456"), SourceIter(src).next().unwrap().0.value); + + let src = "foo123"; + assert_eq!(Key("foo123"), SourceIter(src).next().unwrap().0.value); + + let src = "foo/bar"; + assert_eq!(Key("foo/bar"), SourceIter(src).next().unwrap().0.value); + + let src = "\"foo/bar\""; + assert_eq!(Str("foo/bar"), SourceIter(src).next().unwrap().0.value); + + let src = " \"foo/bar\" "; + assert_eq!(Str("foo/bar"), SourceIter(src).next().unwrap().0.value); + + Ok(()) +} + +//#[cfg(test)] #[test] fn test_examples () -> Result<(), DslError> { + //// Let's pretend to render some view. + //let source = include_str!("../../tek/src/view_arranger.edn"); + //// The token iterator allows you to get the tokens represented by the source text. + //let mut view = TokenIter(source); + //// The token iterator wraps a const token+source iterator. + //assert_eq!(view.0.0, source); + //let mut expr = view.peek(); + //assert_eq!(view.0.0, source); + //assert_eq!(expr, Some(Token { + //source, start: 0, length: source.len() - 1, value: Exp(0, SourceIter(&source[1..])) + //})); + ////panic!("{view:?}"); + ////panic!("{:#?}", expr); + ////for example in [ + ////include_str!("../../tui/examples/edn01.edn"), + ////include_str!("../../tui/examples/edn02.edn"), + ////] { + //////let items = Dsl::read_all(example)?; + //////panic!("{layout:?}"); + //////let content = >::from(&layout); + ////} + //Ok(()) +//} diff --git a/dsl/src/dsl_token.rs b/dsl/src/dsl_token.rs index 71d1997..4411e7e 100644 --- a/dsl/src/dsl_token.rs +++ b/dsl/src/dsl_token.rs @@ -1,67 +1,5 @@ use crate::*; -#[derive(PartialEq, Clone, Default, Debug)] -pub enum Value< - S: PartialEq + Clone + Default + Debug, - X: PartialEq + Clone + Default + Debug, -> { - #[default] Nil, Err(DslError), Num(usize), Sym(S), Key(S), Str(S), Exp(usize, X), -} - -impl< - S: Copy + PartialEq + Clone + Default + Debug, - X: Copy + PartialEq + Clone + Default + Debug, -> Copy for Value {} - -pub trait DslValue: PartialEq + Clone + Default + Debug { - type Err: PartialEq + Clone + Debug; - type Num: PartialEq + Copy + Clone + Default + Debug; - type Str: PartialEq + Clone + Default + Debug; - type Exp: PartialEq + Clone + Default + Debug; - fn nil (&self) -> bool; - fn err (&self) -> Option<&Self::Err>; - fn num (&self) -> Option; - fn sym (&self) -> Option<&Self::Str>; - fn key (&self) -> Option<&Self::Str>; - fn str (&self) -> Option<&Self::Str>; - fn exp (&self) -> Option<&Self::Exp>; - fn exp_depth (&self) -> Option { None } // TODO - fn exp_head (&self) -> Option<&Self> { None } // TODO - fn exp_tail (&self) -> Option<&[Self]> { None } // TODO -} - -impl< - Str: PartialEq + Clone + Default + Debug, - Exp: PartialEq + Clone + Default + Debug, -> DslValue for Value { - type Err = DslError; - type Num = usize; - type Str = Str; - type Exp = Exp; - fn nil (&self) -> bool { - matches!(self, Self::Nil) - } - fn err (&self) -> Option<&DslError> { - if let Self::Err(e) = self { Some(e) } else { None } - } - fn num (&self) -> Option { - if let Self::Num(n) = self { Some(*n) } else { None } - } - fn sym (&self) -> Option<&Str> { - if let Self::Sym(s) = self { Some(s) } else { None } - } - fn key (&self) -> Option<&Str> { - if let Self::Key(k) = self { Some(k) } else { None } - } - fn str (&self) -> Option<&Str> { - if let Self::Str(s) = self { Some(s) } else { None } - } - fn exp (&self) -> Option<&Exp> { - if let Self::Exp(_, x) = self { Some(x) } else { None } - } -} - - #[derive(PartialEq, Clone, Default, Debug)] pub struct Token< V: PartialEq + Clone + Default + Debug, @@ -85,186 +23,3 @@ impl DslToken for Token CstToken<'source> { - pub const fn new ( - source: &'source str, start: usize, length: usize, value: CstValue<'source> - ) -> Self { - Self(value, CstMeta { source, start, length }) - } - pub const fn end (&self) -> usize { - self.1.start.saturating_add(self.1.length) - } - pub const fn slice (&'source self) -> &'source str { - self.slice_source(self.1.source) - } - pub const fn slice_source <'range> (&'source self, source: &'range str) -> &'range str { - str_range(source, self.1.start, self.end()) - } - pub const fn slice_source_exp <'range> (&'source self, source: &'range str) -> &'range str { - str_range(source, self.1.start.saturating_add(1), self.end()) - } - pub const fn with_value (self, value: CstValue<'source>) -> Self { - Self(value, self.1) - } - pub const fn value (&self) -> CstValue<'source> { - self.0 - } - pub const fn error (self, error: DslError) -> Self { - Self(Value::Err(error), self.1) - } - pub const fn grow (self) -> Self { - Self(self.0, CstMeta { length: self.1.length.saturating_add(1), ..self.1 }) - } - pub const fn grow_num (self, m: usize, c: char) -> Self { - use Value::*; - match to_digit(c) { - Result::Ok(n) => Self(Num(10*m+n), self.grow().1), - Result::Err(e) => Self(Err(e), self.grow().1), - } - } - pub const fn grow_key (self) -> Self { - use Value::*; - let token = self.grow(); - token.with_value(Key(token.slice_source(self.1.source))) - } - pub const fn grow_sym (self) -> Self { - use Value::*; - let token = self.grow(); - token.with_value(Sym(token.slice_source(self.1.source))) - } - pub const fn grow_str (self) -> Self { - use Value::*; - let token = self.grow(); - token.with_value(Str(token.slice_source(self.1.source))) - } - pub const fn grow_exp (self) -> Self { - use Value::*; - let token = self.grow(); - if let Exp(depth, _) = token.value() { - token.with_value(Exp(depth, SourceIter::new(token.slice_source_exp(self.1.source)))) - } else { - unreachable!() - } - } - pub const fn grow_in (self) -> Self { - let token = self.grow_exp(); - if let Value::Exp(depth, source) = token.value() { - token.with_value(Value::Exp(depth.saturating_add(1), source)) - } else { - unreachable!() - } - } - pub const fn grow_out (self) -> Self { - let token = self.grow_exp(); - if let Value::Exp(depth, source) = token.value() { - if depth > 0 { - token.with_value(Value::Exp(depth - 1, source)) - } else { - return self.error(Unexpected(')')) - } - } else { - unreachable!() - } - } -} - -pub const fn to_number (digits: &str) -> DslResult { - let mut value = 0; - iterate!(char_indices(digits) => (_, c) => match to_digit(c) { - Ok(digit) => value = 10 * value + digit, - Result::Err(e) => return Result::Err(e) - }); - Ok(value) -} - -pub const fn to_digit (c: char) -> DslResult { - Ok(match c { - '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4, - '5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9, - _ => return Result::Err(Unexpected(c)) - }) -} - -/// Static iteration helper. -#[macro_export] macro_rules! iterate { - ($expr:expr => $arg: pat => $body:expr) => { - let mut iter = $expr; - while let Some(($arg, next)) = iter.next() { - $body; - iter = next; - } - } -} - -pub const fn peek_src <'a> (source: &'a str) -> Option> { - use Value::*; - let mut token: CstToken<'a> = CstToken::new(source, 0, 0, Nil); - iterate!(char_indices(source) => (start, c) => token = match token.value() { - Err(_) => return Some(token), - Nil => match c { - ' '|'\n'|'\r'|'\t' => - token.grow(), - '(' => - CstToken::new(source, start, 1, Exp(1, SourceIter::new(str_range(source, start, start + 1)))), - '"' => - CstToken::new(source, start, 1, Str(str_range(source, start, start + 1))), - ':'|'@' => - CstToken::new(source, start, 1, Sym(str_range(source, start, start + 1))), - '/'|'a'..='z' => - CstToken::new(source, start, 1, Key(str_range(source, start, start + 1))), - '0'..='9' => - CstToken::new(source, start, 1, match to_digit(c) { - Ok(c) => Value::Num(c), - Result::Err(e) => Value::Err(e) - }), - _ => token.error(Unexpected(c)) - }, - Str(_) => match c { - '"' => return Some(token), - _ => token.grow_str(), - }, - Num(n) => match c { - '0'..='9' => token.grow_num(n, c), - ' '|'\n'|'\r'|'\t'|')' => return Some(token), - _ => token.error(Unexpected(c)) - }, - Sym(_) => match c { - 'a'..='z'|'A'..='Z'|'0'..='9'|'-' => token.grow_sym(), - ' '|'\n'|'\r'|'\t'|')' => return Some(token), - _ => token.error(Unexpected(c)) - }, - Key(_) => match c { - 'a'..='z'|'0'..='9'|'-'|'/' => token.grow_key(), - ' '|'\n'|'\r'|'\t'|')' => return Some(token), - _ => token.error(Unexpected(c)) - }, - Exp(depth, _) => match depth { - 0 => return Some(token.grow_exp()), - _ => match c { - ')' => token.grow_out(), - '(' => token.grow_in(), - _ => token.grow_exp(), - } - }, - }); - match token.value() { - Nil => None, - _ => Some(token), - } -} - -//impl, X1, X2: From> From> for Value { - //fn from (other: Value) -> Self { - //use Value::*; - //match other { - //Nil => Nil, - //Err(e) => Err(e), - //Num(u) => Num(u), - //Sym(s) => Sym(s.into()), - //Key(s) => Key(s.into()), - //Str(s) => Str(s.into()), - //Exp(x) => Exp(x.into()), - //} - //} -//} diff --git a/dsl/src/dsl_value.rs b/dsl/src/dsl_value.rs new file mode 100644 index 0000000..45b586f --- /dev/null +++ b/dsl/src/dsl_value.rs @@ -0,0 +1,84 @@ +use crate::*; +use std::fmt::Display; +pub trait DslValue: PartialEq + Clone + Default + Debug { + type Str: AsRef + PartialEq + Clone + Default + Debug; + type Exp: PartialEq + Clone + Default + Debug; + fn value (&self) -> &Value; + fn nil (&self) -> bool { + matches!(self.value(), Value::Nil) + } + fn err (&self) -> Option<&DslError> { + if let Value::Err(e) = self.value() { Some(e) } else { None } + } + fn num (&self) -> Option { + if let Value::Num(n) = self.value() { Some(*n) } else { None } + } + fn sym (&self) -> Option<&str> { + if let Value::Sym(s) = self.value() { Some(s.as_ref()) } else { None } + } + fn key (&self) -> Option<&str> { + if let Value::Key(k) = self.value() { Some(k.as_ref()) } else { None } + } + fn str (&self) -> Option<&str> { + if let Value::Str(s) = self.value() { Some(s.as_ref()) } else { None } + } + fn exp (&self) -> Option<&Self::Exp> { + if let Value::Exp(_, x) = self.value() { Some(x) } else { None } + } + fn exp_depth (&self) -> Option { None } // TODO + fn exp_head (&self) -> Option<&Self> { None } // TODO + fn exp_tail (&self) -> Option<&[Self]> { None } // TODO +} +impl< + Str: AsRef + PartialEq + Clone + Default + Debug, + Exp: PartialEq + Clone + Default + Debug, +> DslValue for Value { + type Str = Str; + type Exp = Exp; + fn value (&self) -> &Value { + self + } +} + +pub enum Value { Nil, Err(DslError), Num(usize), Sym(S), Key(S), Str(S), Exp(usize, X), } +impl Default for Value { fn default () -> Self { Self:: Nil } } +impl PartialEq for Value { + fn eq (&self, other: &Self) -> bool { + use Value::*; + match (self, other) { + (Nil, Nil) => true, + (Err(e1), Err(e2)) if e1 == e2 => true, + (Num(n1), Num(n2)) if n1 == n2 => true, + (Sym(s1), Sym(s2)) if s1 == s2 => true, + (Key(s1), Key(s2)) if s1 == s2 => true, + (Str(s1), Str(s2)) if s1 == s2 => true, + (Exp(d1, e1), Exp(d2, e2)) if d1 == d2 && e1 == e2 => true, + _ => false + } + } +} +impl Clone for Value { + fn clone (&self) -> Self { + use Value::*; + match self { + Nil => Nil, + Err(e) => Err(e.clone()), + Num(n) => Num(*n), + Sym(s) => Sym(s.clone()), + Key(s) => Key(s.clone()), + Str(s) => Str(s.clone()), + Exp(d, e) => Exp(*d, e.clone()), + } + } +} +impl Copy for Value {} +impl Debug for Value { + fn fmt (&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { + todo!() + } +} +impl Display for Value { + fn fmt (&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { + todo!() + } +} diff --git a/dsl/src/lib.rs b/dsl/src/lib.rs index 8fc06e4..7e990c8 100644 --- a/dsl/src/lib.rs +++ b/dsl/src/lib.rs @@ -1,7 +1,3 @@ -#![feature(adt_const_params)] -#![feature(type_alias_impl_trait)] -#![feature(impl_trait_in_fn_trait_return)] - //! [Token]s are parsed substrings with an associated [Value]. //! //! * [ ] FIXME: Value may be [Err] which may shadow [Result::Err] @@ -35,15 +31,15 @@ //! assert_eq!(view.0.0, src); //! assert_eq!(view.peek(), view.0.peek()) //! ``` - +#![feature(adt_const_params)] +#![feature(type_alias_impl_trait)] +#![feature(impl_trait_in_fn_trait_return)] pub(crate) use ::tengri_core::*; - pub(crate) use std::fmt::Debug; 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::*; - mod dsl_ast; pub use self::dsl_ast::*; mod dsl_cst; pub use self::dsl_cst::*; mod dsl_display; pub use self::dsl_display::*; @@ -51,128 +47,5 @@ mod dsl_domain; pub use self::dsl_domain::*; mod dsl_error; pub use self::dsl_error::*; mod dsl_iter; pub use self::dsl_iter::*; mod dsl_token; pub use self::dsl_token::*; - -#[cfg(test)] mod test_token_iter { - use crate::*; - //use proptest::prelude::*; - #[test] fn test_iters () { - let mut iter = crate::SourceIter::new(&":foo :bar"); - let _ = iter.next(); - let mut iter = crate::TokenIter::new(&":foo :bar"); - let _ = iter.next(); - } - #[test] const fn test_const_iters () { - let mut iter = crate::SourceIter::new(&":foo :bar"); - let _ = iter.next(); - } - #[test] fn test_num () { - let digit = to_digit('0'); - let digit = to_digit('x'); - let number = to_number(&"123"); - let number = to_number(&"12asdf3"); - } - //proptest! { - //#[test] fn proptest_source_iter ( - //source in "\\PC*" - //) { - //let mut iter = crate::SourceIter::new(&source); - ////let _ = iter.next(); - //} - //#[test] fn proptest_token_iter ( - //source in "\\PC*" - //) { - //let mut iter = crate::TokenIter::new(&source); - ////let _ = iter.next(); - //} - //} -} - -#[cfg(test)] mod test_token_prop { - use proptest::prelude::*; - proptest! { - #[test] fn test_token_prop ( - source in "\\PC*", - start in usize::MIN..usize::MAX, - length in usize::MIN..usize::MAX, - ) { - let token = crate::Token { - source: &source, - start, - length, - value: crate::Value::Nil - }; - let _ = token.slice(); - } - } -} - -#[cfg(test)] #[test] fn test_token () -> Result<(), Box> { - let source = ":f00"; - let mut token = Token { source, start: 0, length: 1, value: Sym(":") }; - token = token.grow_sym(); - assert_eq!(token, Token { source, start: 0, length: 2, value: Sym(":f") }); - token = token.grow_sym(); - assert_eq!(token, Token { source, start: 0, length: 3, value: Sym(":f0") }); - token = token.grow_sym(); - assert_eq!(token, Token { source, start: 0, length: 4, value: Sym(":f00") }); - - let src = ""; - assert_eq!(None, SourceIter(src).next()); - - let src = " \n \r \t "; - assert_eq!(None, SourceIter(src).next()); - - let src = "7"; - assert_eq!(Num(7), SourceIter(src).next().unwrap().0.value); - - let src = " 100 "; - assert_eq!(Num(100), SourceIter(src).next().unwrap().0.value); - - let src = " 9a "; - assert_eq!(Err(Unexpected('a')), SourceIter(src).next().unwrap().0.value); - - let src = " :123foo "; - assert_eq!(Sym(":123foo"), SourceIter(src).next().unwrap().0.value); - - let src = " \r\r\r\n\n\n@bar456\t\t\t\t\t\t"; - assert_eq!(Sym("@bar456"), SourceIter(src).next().unwrap().0.value); - - let src = "foo123"; - assert_eq!(Key("foo123"), SourceIter(src).next().unwrap().0.value); - - let src = "foo/bar"; - assert_eq!(Key("foo/bar"), SourceIter(src).next().unwrap().0.value); - - let src = "\"foo/bar\""; - assert_eq!(Str("foo/bar"), SourceIter(src).next().unwrap().0.value); - - let src = " \"foo/bar\" "; - assert_eq!(Str("foo/bar"), SourceIter(src).next().unwrap().0.value); - - Ok(()) -} - -//#[cfg(test)] #[test] fn test_examples () -> Result<(), DslError> { - //// Let's pretend to render some view. - //let source = include_str!("../../tek/src/view_arranger.edn"); - //// The token iterator allows you to get the tokens represented by the source text. - //let mut view = TokenIter(source); - //// The token iterator wraps a const token+source iterator. - //assert_eq!(view.0.0, source); - //let mut expr = view.peek(); - //assert_eq!(view.0.0, source); - //assert_eq!(expr, Some(Token { - //source, start: 0, length: source.len() - 1, value: Exp(0, SourceIter(&source[1..])) - //})); - ////panic!("{view:?}"); - ////panic!("{:#?}", expr); - ////for example in [ - ////include_str!("../../tui/examples/edn01.edn"), - ////include_str!("../../tui/examples/edn02.edn"), - ////] { - //////let items = Dsl::read_all(example)?; - //////panic!("{layout:?}"); - //////let content = >::from(&layout); - ////} - //Ok(()) -//} +mod dsl_value; pub use self::dsl_value::*; +#[cfg(test)] mod dsl_test; diff --git a/input/src/input_dsl.rs b/input/src/input_dsl.rs index bff457d..a91453f 100644 --- a/input/src/input_dsl.rs +++ b/input/src/input_dsl.rs @@ -23,34 +23,27 @@ impl InputLayers { self.0.push(InputLayer(condition, binding)); self } - pub fn handle , I, O: Command> (&self, state: &mut S, input: I) -> Perhaps { + pub fn handle + Eval, I: Eval, O: Command> (&self, state: &mut S, input: I) -> Perhaps { InputHandle(state, self.0.as_slice()).try_eval(input) } } pub struct InputHandle<'a, S>(&'a mut S, &'a [InputLayer]); -impl<'a, S: Eval, I, O: Command> Eval for InputHandle<'a, S> { +impl<'a, S: Eval + Eval, I: Eval, O: Command> Eval for InputHandle<'a, S> { fn try_eval (&self, input: I) -> Perhaps { let Self(state, layers) = self; for InputLayer(condition, binding) in layers.iter() { let mut matches = true; if let Some(condition) = condition { - matches = state.eval(*condition, ||"input: no condition")?; + matches = state.eval(condition.clone(), ||"input: no condition")?; } - if matches { - if let AstValue::Exp(e) = binding.peek() { - if let Some(ast) = e.peek() { - if input.eval(ast.clone(), ||"InputLayers: input.eval(binding) failed")? - && let Some(command) = state.try_eval(ast)? { - return Ok(Some(command)) - } - } else { - unreachable!("InputLayer") - } - } else { - panic!("InputLayer: expected expression, got: {input:?}") - } + if matches + && let Some(exp) = binding.exp() + && let Some(ast) = exp.peek() + && input.eval(ast.clone(), ||"InputLayers: input.eval(binding) failed")? + && let Some(command) = state.try_eval(ast)? { + return Ok(Some(command)) } } Ok(None) diff --git a/input/src/lib.rs b/input/src/lib.rs index 21035fe..4f27011 100644 --- a/input/src/lib.rs +++ b/input/src/lib.rs @@ -1,4 +1,5 @@ #![feature(associated_type_defaults)] +#![feature(if_let_guard)] pub(crate) use tengri_core::*; diff --git a/output/src/ops_dsl.rs b/output/src/ops_dsl.rs index f14194b..196f693 100644 --- a/output/src/ops_dsl.rs +++ b/output/src/ops_dsl.rs @@ -1,134 +1,118 @@ use crate::*; +use Value::*; impl Dsl for When where S: Eval + Eval { - fn try_provide (state: S, source: Ast) -> Perhaps { - if let Ast::Exp(exp) = source { - let mut iter = source.clone(); - if let Some(Ast::Key(id)) = iter.next() && *id == *"when" { - return Ok(Some(Self( - state.eval(iter.next().unwrap(), ||"when: expected condition")?, - state.eval(iter.next().unwrap(), ||"when: expected content")?, - ))) - } + fn try_provide (state: &S, source: Ast) -> Perhaps { + if let Exp(_, exp) = source.0 && let Some(Ast(Key(id))) = exp.peek() && *id == *"when" { + let _ = exp.next(); + return Ok(Some(Self( + state.eval(exp.next().unwrap(), ||"when: expected condition")?, + state.eval(exp.next().unwrap(), ||"when: expected content")?, + ))) } Ok(None) } } impl Dsl for Either where S: Eval + Eval + Eval { - fn try_provide (state: S, source: Ast) -> Perhaps { - if let Ast::Exp(source) = source { - let mut iter = source.clone(); - if let Some(Ast::Key(id)) = iter.next() && *id == *"either" { - return Ok(Some(Self( - state.eval(iter.next().unwrap(), ||"either: expected condition")?, - state.eval(iter.next().unwrap(), ||"either: expected content 1")?, - state.eval(iter.next().unwrap(), ||"either: expected content 2")?, - ))) - } + fn try_provide (state: &S, source: Ast) -> Perhaps { + if let Exp(_, exp) = source.0 && let Some(Ast(Key(id))) = exp.peek() && *id == *"either" { + let _ = exp.next(); + return Ok(Some(Self( + state.eval(exp.next().unwrap(), ||"either: expected condition")?, + state.eval(exp.next().unwrap(), ||"either: expected content 1")?, + state.eval(exp.next().unwrap(), ||"either: expected content 2")?, + ))) + } + Ok(None) + } +} + +impl Dsl for Align where S: Eval, A> { + fn try_provide (state: &S, source: Ast) -> Perhaps { + if let Exp(_, source) = source.0 { + let mut rest = source.clone(); + return Ok(Some(match rest.next().and_then(|x|x.key()) { + Some("align/c") => Self::c(state.eval(rest.next(), ||"align/c: expected content")?), + Some("align/x") => Self::x(state.eval(rest.next(), ||"align/x: expected content")?), + Some("align/y") => Self::y(state.eval(rest.next(), ||"align/y: expected content")?), + Some("align/n") => Self::n(state.eval(rest.next(), ||"align/n: expected content")?), + Some("align/s") => Self::s(state.eval(rest.next(), ||"align/s: expected content")?), + Some("align/e") => Self::e(state.eval(rest.next(), ||"align/e: expected content")?), + Some("align/w") => Self::w(state.eval(rest.next(), ||"align/w: expected content")?), + Some("align/nw") => Self::nw(state.eval(rest.next(), ||"align/nw: expected content")?), + Some("align/ne") => Self::ne(state.eval(rest.next(), ||"align/ne: expected content")?), + Some("align/sw") => Self::sw(state.eval(rest.next(), ||"align/sw: expected content")?), + Some("align/se") => Self::se(state.eval(rest.next(), ||"align/se: expected content")?), + _ => return Ok(None), + })) } Ok(None) } } impl Dsl for Bsp where S: Eval, A> + Eval, B> { - fn try_provide (state: S, source: Ast) -> Perhaps { - Ok(Some(if let Ast::Exp(source) = source { - let mut iter = source.clone(); - match iter.next() { - Some(Value::Key("bsp/n")) => Self::n( - state.eval(iter.next(), ||"bsp/n: expected content 1")?, - state.eval(iter.next(), ||"bsp/n: expected content 2")?, + fn try_provide (state: &S, source: Ast) -> Perhaps { + if let Exp(_, exp) = source.0 { + let mut rest = exp.clone(); + return Ok(Some(match rest.next().and_then(|x|x.key()) { + Some("bsp/n") => Self::n( + state.eval(rest.next(), ||"bsp/n: expected content 1")?, + state.eval(rest.next(), ||"bsp/n: expected content 2")?, ), - Some(Value::Key("bsp/s")) => Self::s( - state.eval(iter.next(), ||"bsp/s: expected content 1")?, - state.eval(iter.next(), ||"bsp/s: expected content 2")?, + Some("bsp/s") => Self::s( + state.eval(rest.next(), ||"bsp/s: expected content 1")?, + state.eval(rest.next(), ||"bsp/s: expected content 2")?, ), - Some(Value::Key("bsp/e")) => Self::e( - state.eval(iter.next(), ||"bsp/e: expected content 1")?, - state.eval(iter.next(), ||"bsp/e: expected content 2")?, + Some("bsp/e") => Self::e( + state.eval(rest.next(), ||"bsp/e: expected content 1")?, + state.eval(rest.next(), ||"bsp/e: expected content 2")?, ), - Some(Value::Key("bsp/w")) => Self::w( - state.eval(iter.next(), ||"bsp/w: expected content 1")?, - state.eval(iter.next(), ||"bsp/w: expected content 2")?, + Some("bsp/w") => Self::w( + state.eval(rest.next(), ||"bsp/w: expected content 1")?, + state.eval(rest.next(), ||"bsp/w: expected content 2")?, ), - Some(Value::Key("bsp/a")) => Self::a( - state.eval(iter.next(), ||"bsp/a: expected content 1")?, - state.eval(iter.next(), ||"bsp/a: expected content 2")?, + Some("bsp/a") => Self::a( + state.eval(rest.next(), ||"bsp/a: expected content 1")?, + state.eval(rest.next(), ||"bsp/a: expected content 2")?, ), - Some(Value::Key("bsp/b")) => Self::b( - state.eval(iter.next(), ||"bsp/b: expected content 1")?, - state.eval(iter.next(), ||"bsp/b: expected content 2")?, + Some("bsp/b") => Self::b( + state.eval(rest.next(), ||"bsp/b: expected content 1")?, + state.eval(rest.next(), ||"bsp/b: expected content 2")?, ), _ => return Ok(None), - } - } else { - return Ok(None) - })) - } -} - -impl Dsl for Align where S: Eval, A> { - fn try_provide (state: S, source: Ast) -> Perhaps { - Ok(Some(if let Ast::Exp(source) = source { - let mut iter = source.clone(); - match iter.next() { - Some(Value::Key("align/c")) => - Self::c(state.eval(iter.next(), ||"align/c: expected content")?), - Some(Value::Key("align/x")) => - Self::x(state.eval(iter.next(), ||"align/x: expected content")?), - Some(Value::Key("align/y")) => - Self::y(state.eval(iter.next(), ||"align/y: expected content")?), - Some(Value::Key("align/n")) => - Self::n(state.eval(iter.next(), ||"align/n: expected content")?), - Some(Value::Key("align/s")) => - Self::s(state.eval(iter.next(), ||"align/s: expected content")?), - Some(Value::Key("align/e")) => - Self::e(state.eval(iter.next(), ||"align/e: expected content")?), - Some(Value::Key("align/w")) => - Self::w(state.eval(iter.next(), ||"align/w: expected content")?), - Some(Value::Key("align/nw")) => - Self::nw(state.eval(iter.next(), ||"align/nw: expected content")?), - Some(Value::Key("align/ne")) => - Self::ne(state.eval(iter.next(), ||"align/ne: expected content")?), - Some(Value::Key("align/sw")) => - Self::sw(state.eval(iter.next(), ||"align/sw: expected content")?), - Some(Value::Key("align/se")) => - Self::se(state.eval(iter.next(), ||"align/se: expected content")?), - _ => return Ok(None), - } - } else { - return Ok(None) - })) + })) + } + Ok(None) } } //#[cfg(feature = "dsl")] take!($Enum, A|state, words|Ok( - //if let Some(Token { value: Value::Key(k), .. }) = words.peek() { + //if let Some(Token { value: Key(k), .. }) = words.peek() { //let mut base = words.clone(); //let content = state.give_or_fail(words, ||format!("{k}: no content"))?; //return Ok(Some(match words.next() { - //Some(Token{value: Value::Key($x),..}) => Self::x(content), - //Some(Token{value: Value::Key($y),..}) => Self::y(content), - //Some(Token{value: Value::Key($xy),..}) => Self::xy(content), + //Some(Token{value: Key($x),..}) => Self::x(content), + //Some(Token{value: Key($y),..}) => Self::y(content), + //Some(Token{value: Key($xy),..}) => Self::xy(content), //_ => unreachable!() //})) //} else { //None //})); //#[cfg(feature = "dsl")] take!($Enum, U, A|state, words|Ok( - //if let Some(Token { value: Value::Key($x|$y|$xy), .. }) = words.peek() { + //if let Some(Token { value: Key($x|$y|$xy), .. }) = words.peek() { //let mut base = words.clone(); //Some(match words.next() { - //Some(Token { value: Value::Key($x), .. }) => Self::x( + //Some(Token { value: Key($x), .. }) => Self::x( //state.give_or_fail(words, ||"x: no unit")?, //state.give_or_fail(words, ||"x: no content")?, //), - //Some(Token { value: Value::Key($y), .. }) => Self::y( + //Some(Token { value: Key($y), .. }) => Self::y( //state.give_or_fail(words, ||"y: no unit")?, //state.give_or_fail(words, ||"y: no content")?, //), - //Some(Token { value: Value::Key($x), .. }) => Self::xy( + //Some(Token { value: Key($x), .. }) => Self::xy( //state.give_or_fail(words, ||"xy: no unit x")?, //state.give_or_fail(words, ||"xy: no unit y")?, //state.give_or_fail(words, ||"xy: no content")?