From e9d4c7e0bcd203c9635dacb7b8df0841a0624c9f Mon Sep 17 00:00:00 2001 From: unspeaker Date: Mon, 26 May 2025 23:32:59 +0300 Subject: [PATCH] AstToken -> Ast <- AstValue --- dsl/src/dsl_ast.rs | 30 ++++++++++++++---------------- dsl/src/dsl_display.rs | 2 +- dsl/src/dsl_iter.rs | 10 ++-------- input/src/input_dsl.rs | 20 +++++++++----------- output/src/ops_dsl.rs | 8 ++++---- 5 files changed, 30 insertions(+), 40 deletions(-) diff --git a/dsl/src/dsl_ast.rs b/dsl/src/dsl_ast.rs index 0936cde..866e15f 100644 --- a/dsl/src/dsl_ast.rs +++ b/dsl/src/dsl_ast.rs @@ -2,15 +2,21 @@ use crate::*; use std::sync::Arc; use std::borrow::Cow; -/// Owns its values, and has no metadata. -#[derive(PartialEq, Clone, Default, Debug)] -pub struct AstToken(pub AstValue, pub AstMeta); - #[derive(Debug, Copy, Clone, Default, PartialEq)] -pub struct AstMeta; - -pub type AstValue = Value, Vec>; -impl<'source> From> for AstValue { +pub struct AstIter; +impl<'source> From> for AstIter { + fn from (source: SourceIter<'source>) -> Self { + Self // TODO + } +} +/// Owns its values, and has no metadata. +pub type Ast = 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::*; match value { @@ -24,11 +30,3 @@ impl<'source> From> for AstValue { } } } - -pub trait AstIter: DslIter {} - -//impl<'source> From> for AstExp { - //fn from (exp: CstExp<'source>) -> AstExp { - //AstExp(exp.words.map(|token|Token(AstValue::from(token.value()), AstMeta,)).collect()) - //} -//} diff --git a/dsl/src/dsl_display.rs b/dsl/src/dsl_display.rs index 8a10193..44def5d 100644 --- a/dsl/src/dsl_display.rs +++ b/dsl/src/dsl_display.rs @@ -1,6 +1,6 @@ use crate::*; use std::fmt::{Debug, Display, Formatter, Error as FormatError}; -impl Display for AstValue { +impl Display for Ast { fn fmt (&self, out: &mut Formatter) -> Result<(), FormatError> { use Value::*; write!(out, "{}", match self { diff --git a/dsl/src/dsl_iter.rs b/dsl/src/dsl_iter.rs index 6b12682..b532648 100644 --- a/dsl/src/dsl_iter.rs +++ b/dsl/src/dsl_iter.rs @@ -43,18 +43,12 @@ impl<'source> Into>> for SourceIter<'source> { } } -impl<'source> Into> for SourceIter<'source> { - fn into (self) -> Vec { +impl<'source> Into> for SourceIter<'source> { + fn into (self) -> Vec { self.map(Into::into).collect() } } -impl<'source> From> for AstToken { - fn from (value: CstToken<'source>) -> Self { - Self(value.0.into(), AstMeta) - } -} - /// Implement the const iterator pattern. #[macro_export] macro_rules! const_iter { ($(<$l:lifetime>)?|$self:ident: $Struct:ty| => $Item:ty => $expr:expr) => { diff --git a/input/src/input_dsl.rs b/input/src/input_dsl.rs index 7bd3605..6f6b24b 100644 --- a/input/src/input_dsl.rs +++ b/input/src/input_dsl.rs @@ -4,35 +4,33 @@ use std::fmt::Debug; #[derive(Default, Debug)] pub struct InputLayers(Vec); -#[derive(Default, Debug)] pub struct InputLayer(Option>, Cst<'static>); +#[derive(Default, Debug)] pub struct InputLayer(Option, Ast); impl InputLayers { - pub fn new (layer: Cst<'static>) -> Self { + pub fn new (layer: Ast) -> Self { Self(vec![]).layer(layer) } - pub fn layer (mut self, layer: Cst<'static>) -> Self { + pub fn layer (mut self, layer: Ast) -> Self { self.add_layer(layer); self } - pub fn layer_if (mut self, condition: Cst<'static>, layer: Cst<'static>) -> Self { + pub fn layer_if (mut self, condition: Ast, layer: Ast) -> Self { self.add_layer_if(Some(condition), layer); self } - pub fn add_layer (&mut self, layer: Cst<'static>) -> &mut Self { + pub fn add_layer (&mut self, layer: Ast) -> &mut Self { self.add_layer_if(None, layer.into()); self } - pub fn add_layer_if (&mut self, condition: Option>, binding: Cst<'static>) -> &mut Self { - self.0.push(InputLayer { condition, binding, __: Default::default() }); + pub fn add_layer_if (&mut self, condition: Option, binding: Ast) -> &mut Self { + self.0.push(InputLayer(condition, binding)); self } - pub fn handle , I, O: Command> ( - &self, state: &mut S, input: I - ) -> Perhaps { + pub fn handle > (&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<&'a dyn Ast, bool>, I, O: Command> Eval for InputHandle<'a, S> { +impl<'a, S, I, 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() { diff --git a/output/src/ops_dsl.rs b/output/src/ops_dsl.rs index 2dd72fb..f14194b 100644 --- a/output/src/ops_dsl.rs +++ b/output/src/ops_dsl.rs @@ -1,7 +1,7 @@ use crate::*; impl Dsl for When where S: Eval + Eval { - fn try_provide (state: S, source: impl Ast) -> Perhaps { + 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" { @@ -16,7 +16,7 @@ impl Dsl for When where S: Eval + Eval { } impl Dsl for Either where S: Eval + Eval + Eval { - fn try_provide (state: S, source: impl Ast) -> Perhaps { + 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" { @@ -32,7 +32,7 @@ impl Dsl for Either where S: Eval + Eval + } impl Dsl for Bsp where S: Eval, A> + Eval, B> { - fn try_provide (state: S, source: impl Ast) -> Perhaps { + fn try_provide (state: S, source: Ast) -> Perhaps { Ok(Some(if let Ast::Exp(source) = source { let mut iter = source.clone(); match iter.next() { @@ -69,7 +69,7 @@ impl Dsl for Bsp where S: Eval, A> + Eval Dsl for Align where S: Eval, A> { - fn try_provide (state: S, source: impl Ast) -> Perhaps { + fn try_provide (state: S, source: Ast) -> Perhaps { Ok(Some(if let Ast::Exp(source) = source { let mut iter = source.clone(); match iter.next() {