wip: dsl, input, output, proc: more precise lifetimes

dsl/src/dsl_context.rs

@@ -1,11 +1,17 @@
 use crate::*;
 
-pub trait TryFromDsl<'a, T>: Sized {
-    fn try_from_expr (_state: &'a T, _iter: TokenIter<'a>) -> Option<Self> {
+pub trait TryFromDsl<'state, T>: Sized {
+    fn try_from_expr <'source: 'state> (
+        _state: &'state T, _iter: TokenIter<'source>
+    ) -> Option<Self> {
         None
     }
-    fn try_from_atom (state: &'a T, value: Value<'a>) -> Option<Self> {
-        if let Exp(0, iter) = value { return Self::try_from_expr(state, iter) }
+    fn try_from_atom <'source: 'state> (
+        state: &'state T, value: Value<'source>
+    ) -> Option<Self> {
+        if let Exp(0, iter) = value {
+            return Self::try_from_expr(state, iter.clone())
+        }
         None
     }
 }
@@ -15,29 +21,20 @@ pub trait TryIntoDsl<T>: Sized {
 }
 
 /// Map EDN tokens to parameters of a given type for a given context
-pub trait Context<U>: Sized {
-    fn get (&self, _atom: &Value) -> Option<U> {
+pub trait Context<'state, U>: Sized {
+    fn get <'source> (&'state self, _iter: &mut TokenIter<'source>) -> Option<U> {
         None
     }
-    fn get_or_fail (&self, dsl: &Value) -> U {
-        self.get(dsl).expect("no value")
+}
+
+impl<'state, T: Context<'state, U>, U> Context<'state, U> for &T {
+    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<U> {
+        (*self).get(iter)
     }
 }
 
-impl<T: Context<U>, U> Context<U> for &T {
-    fn get (&self, dsl: &Value) -> Option<U> {
-        (*self).get(dsl)
-    }
-    fn get_or_fail (&self, dsl: &Value) -> U {
-        (*self).get_or_fail(dsl)
-    }
-}
-
-impl<T: Context<U>, U> Context<U> for Option<T> {
-    fn get (&self, dsl: &Value) -> Option<U> {
-        self.as_ref().map(|s|s.get(dsl)).flatten()
-    }
-    fn get_or_fail (&self, dsl: &Value) -> U {
-        self.as_ref().map(|s|s.get_or_fail(dsl)).expect("no provider")
+impl<'state, T: Context<'state, U>, U> Context<'state, U> for Option<T> {
+    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<U> {
+        self.as_ref().map(|s|s.get(iter)).flatten()
     }
 }

dsl/src/dsl_token.rs

@@ -22,38 +22,38 @@
 //!```
 use crate::*;
 
-#[derive(Debug, Copy, Clone, Default, PartialEq)] pub struct Token<'a> {
-    pub source: &'a str,
+#[derive(Debug, Copy, Clone, Default, PartialEq)] pub struct Token<'source> {
+    pub source: &'source str,
     pub start:  usize, 
     pub length: usize,
-    pub value:  Value<'a>,
+    pub value:  Value<'source>,
 }
 
-#[derive(Debug, Copy, Clone, Default, PartialEq)] pub enum Value<'a> {
+#[derive(Debug, Copy, Clone, Default, PartialEq)] pub enum Value<'source> {
     #[default] Nil,
     Err(ParseError),
     Num(usize),
-    Sym(&'a str),
-    Key(&'a str),
-    Str(&'a str),
-    Exp(usize, TokenIter<'a>),
+    Sym(&'source str),
+    Key(&'source str),
+    Str(&'source str),
+    Exp(usize, TokenIter<'source>),
 }
 
-impl<'a> Token<'a> {
-    pub const fn new (source: &'a str, start: usize, length: usize, value: Value<'a>) -> Self {
+impl<'source> Token<'source> {
+    pub const fn new (source: &'source str, start: usize, length: usize, value: Value<'source>) -> Self {
         Self { source, start, length, value }
     }
     pub const fn end (&self) -> usize {
         self.start.saturating_add(self.length)
     }
-    pub const fn slice (&'a self) -> &'a str {
+    pub const fn slice (&'source self) -> &'source str {
         self.slice_source(self.source)
         //str_range(self.source, self.start, self.end())
     }
-    pub const fn slice_source <'b> (&'a self, source: &'b str) -> &'b str {
+    pub const fn slice_source <'range> (&'source self, source: &'range str) -> &'range str {
         str_range(source, self.start, self.end())
     }
-    pub const fn slice_source_exp <'b> (&'a self, source: &'b str) -> &'b str {
+    pub const fn slice_source_exp <'range> (&'source self, source: &'range str) -> &'range str {
         str_range(source, self.start.saturating_add(1), self.end())
     }
     pub const fn value (&self) -> Value {