more dsl runaround

dsl/src/dsl.rs

@@ -13,6 +13,11 @@ pub(crate) use ::tengri_core::*;
 pub(crate) use self::DslError::*;
 mod dsl_conv; pub use self::dsl_conv::*;
 #[cfg(test)] mod dsl_test;
+/// DSL-specific result type.
+pub type DslResult<T> = Result<T, DslError>;
+/// DSL-specific optional result type.
+pub type DslPerhaps<T> = Result<Option<T>, DslError>;
+// Designates a string as parsable DSL.
 flex_trait!(Dsl: Debug + Send + Sync + Sized {
     fn src (&self) -> DslPerhaps<&str> { unreachable!("Dsl::src default impl") }
 });
@@ -24,19 +29,6 @@ impl<D: Dsl> Dsl for Option<D> {
 impl<D: Dsl> Dsl for Result<D, DslError> {
     fn src (&self) -> DslPerhaps<&str> {match self {Ok(dsl) => Ok(dsl.src()?), Err(e) => Err(*e)}}
 }
-impl<D: Dsl> DslExp for D {} pub trait DslExp: Dsl {
-    fn exp  (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(exp_peek_inner_only))}
-    fn head (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(peek))}
-    fn tail (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(peek_tail(self.head())))}
-    fn each (&self, mut cb: impl FnMut(&str)->Usually<()>) -> Usually<()> {
-        Ok(if let Some(head) = self.head()? {
-            cb(head)?;
-            if let Some(tail) = self.tail()? {
-                tail.each(cb)?;
-            }
-        })
-    }
-}
 impl<D: Dsl> DslText for D {} pub trait DslText: Dsl {
     fn text (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(text_peek_only))}
 }
@@ -49,30 +41,72 @@ impl<D: Dsl> DslKey for D {} pub trait DslKey: Dsl {
 impl<D: Dsl> DslNum for D {} pub trait DslNum: Dsl {
     fn num  (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(num_peek_only))}
 }
-/// DSL-specific result type.
-pub type DslResult<T> = Result<T, DslError>;
-/// DSL-specific optional result type.
-pub type DslPerhaps<T> = Result<Option<T>, DslError>;
+impl<D: Dsl> DslExp for D {} pub trait DslExp: Dsl {
+    fn exp  (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(exp_peek_inner_only))}
+    fn head (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(peek))}
+    fn tail (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(peek_tail))}
+    fn each (&self, mut cb: impl FnMut(&str)->Usually<()>) -> Usually<()> {
+        Ok(if let Some(head) = self.head()? {
+            println!("| HEAD ->\n{head}");
+            cb(head)?;
+            if let Some(tail) = self.tail()? {
+                println!("| TAIL ->\n{tail}");
+                tail.each(cb)?;
+            }
+        })
+    }
+}
+pub const fn peek (src: &str) -> DslPerhaps<&str> {
+    Ok(Some(if let Ok(Some(exp))  = exp_peek(src)  { exp  } else
+            if let Ok(Some(sym))  = sym_peek(src)  { sym  } else
+            if let Ok(Some(key))  = key_peek(src)  { key  } else
+            if let Ok(Some(num))  = num_peek(src)  { num  } else
+            if let Ok(Some(text)) = text_peek(src) { text } else
+            if let Err(e) = no_trailing_non_space(src, 0, Some("peek")) { return Err(e) }
+            else { return Ok(None) }))
+}
+pub const fn seek (src: &str) -> DslPerhaps<(usize, usize)> {
+    Ok(Some(if let Ok(Some(exp))  = exp_seek(src)  { exp  } else
+            if let Ok(Some(sym))  = sym_seek(src)  { sym  } else
+            if let Ok(Some(key))  = key_seek(src)  { key  } else
+            if let Ok(Some(num))  = num_seek(src)  { num  } else
+            if let Ok(Some(text)) = text_seek(src) { text } else
+            if let Err(e) = no_trailing_non_space(src, 0, Some("seek")) { return Err(e) }
+            else { return Ok(None) }))
+}
+pub const fn peek_tail (src: &str) -> DslPerhaps<&str> {
+    match seek(src) {
+        Err(e) => Err(e),
+        Ok(None) => Ok(None),
+        Ok(Some((start, length))) => {
+            let tail = str_range(src, start + length, src.len());
+            for_each!((i, c) in char_indices(tail) => if !is_space(c) { return Ok(Some(tail)) });
+            Ok(None)
+        },
+    }
+}
 /// 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: unexpected character '{0}'")] Unexpected(char, Option<usize>, Option<&'static str>),
     #[error("parse failed: error #{0}")] Code(u8),
     #[error("end reached")] End
 }
 fn ok_flat <T> (x: Option<DslPerhaps<T>>) -> DslPerhaps<T> { Ok(x.transpose()?.flatten()) }
-fn peek_tail <'a> (head: DslPerhaps<&'a str>) -> impl Fn(&'a str)->DslPerhaps<&'a str> {
-    move|src|match head {
-        Ok(Some(next)) => {
-            let src = &src[src.len().min(1 + next.len())..];
-            for c in src.chars() { if !is_whitespace(c) { return Ok(Some(src)) } }
-            Ok(None)
-        },
-        e => e
-    }
+pub const fn is_space (c: char) -> bool {
+    matches!(c, ' '|'\n'|'\r'|'\t')
+}
+pub const fn no_trailing_non_space (source: &str, offset: usize, context: Option<&'static str>) -> DslResult<()> {
+    Ok(for_each!((i, c) in char_indices(str_range(source, offset, source.len())) => if !is_space(c) {
+        return Err(Unexpected(c, Some(offset + i), if let Some(context) = context {
+            Some(context)
+        } else {
+            Some("trailing non-space")
+        }))
+    }))
 }
 macro_rules! def_peek_seek(($peek:ident, $peek_only:ident, $seek:ident, $seek_start:ident, $seek_length:ident)=>{
     /// Find a slice corrensponding to a syntax token.
@@ -91,7 +125,7 @@ macro_rules! def_peek_seek(($peek:ident, $peek_only:ident, $seek:ident, $seek_st
             Err(e) => Err(e),
             Ok(None) => Ok(None),
             Ok(Some((start, length))) => {
-                if let Err(e) = no_trailing_non_whitespace(source, start + length) { return Err(e) }
+                if let Err(e) = no_trailing_non_space(source, start + length, Some("peek_only")) { return Err(e) }
                 Ok(Some(str_range(source, start, start + length)))
             }
         }
@@ -125,7 +159,7 @@ pub const fn exp_peek_inner_only (source: &str) -> DslPerhaps<&str> {
         Err(e) => Err(e),
         Ok(None) => Ok(None),
         Ok(Some((start, length))) => {
-            if let Err(e) = no_trailing_non_whitespace(source, start + length) { return Err(e) }
+            if let Err(e) = no_trailing_non_space(source, start + length, Some("exp_peek_inner_only")) { return Err(e) }
             let peeked = str_range(source, start, start + length);
             let len = peeked.len();
             let start = if len > 0 { 1 } else { 0 };
@@ -138,8 +172,8 @@ pub const fn is_exp_end (c: char) -> bool { c == ')' }
 pub const fn exp_seek_start (source: &str) -> DslPerhaps<usize> {
     for_each!((i, c) in char_indices(source) => if is_exp_start(c) {
         return Ok(Some(i))
-    } else if !is_whitespace(c) {
-        return Err(Unexpected(c))
+    } else if !is_space(c) {
+        return Err(Unexpected(c, Some(i), Some("expected expression start")))
     });
     Ok(None)
 }
@@ -149,7 +183,7 @@ pub const fn exp_seek_length (source: &str) -> DslPerhaps<usize> {
         depth += 1;
     } else if is_exp_end(c) {
         if depth == 0 {
-            return Err(Unexpected(c))
+            return Err(Unexpected(c, Some(i), Some("expected expression end")))
         } else if depth == 1 {
             return Ok(Some(i + 1))
         } else {
@@ -160,13 +194,13 @@ pub const fn exp_seek_length (source: &str) -> DslPerhaps<usize> {
 }
 def_peek_seek!(sym_peek, sym_peek_only, sym_seek, sym_seek_start, sym_seek_length);
 pub const fn is_sym_start (c: char) -> bool { matches!(c, ':'|'@') }
-pub const fn is_sym_char (c: char) -> bool { matches!(c, 'a'..='z'|'A'..='Z'|'0'..='9'|'-') }
-pub const fn is_sym_end (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') }
+pub const fn is_sym_char (c: char) -> bool { matches!(c, ':'|'a'..='z'|'A'..='Z'|'0'..='9'|'-'|'/') }
+pub const fn is_sym_end (c: char) -> bool { is_space(c) || matches!(c, ')') }
 pub const fn sym_seek_start (source: &str) -> DslPerhaps<usize> {
     for_each!((i, c) in char_indices(source) => if is_sym_start(c) {
         return Ok(Some(i))
-    } else if !is_whitespace(c) {
-        return Err(Unexpected(c))
+    } else if !is_space(c) {
+        return Err(Unexpected(c, Some(i), Some("sym_seek_start")))
     });
     Ok(None)
 }
@@ -174,19 +208,19 @@ pub const fn sym_seek_length (source: &str) -> DslPerhaps<usize> {
     for_each!((i, c) in char_indices(source) => if is_sym_end(c) {
         return Ok(Some(i))
     } else if !is_sym_char(c) {
-        return Err(Unexpected(c))
+        return Err(Unexpected(c, Some(i), Some("sym_seek_length")))
     });
     Ok(Some(source.len()))
 }
 def_peek_seek!(key_peek, key_peek_only, key_seek, key_seek_start, key_seek_length);
 pub const fn is_key_start (c: char) -> bool { matches!(c, '/'|('a'..='z')) }
 pub const fn is_key_char (c: char) -> bool { matches!(c, 'a'..='z'|'0'..='9'|'-'|'/') }
-pub const fn is_key_end (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') }
+pub const fn is_key_end (c: char) -> bool { is_space(c) || matches!(c, ')') }
 pub const fn key_seek_start (source: &str) -> DslPerhaps<usize> {
     for_each!((i, c) in char_indices(source) => if is_key_start(c) {
         return Ok(Some(i))
-    } else if !is_whitespace(c) {
-        return Err(Unexpected(c))
+    } else if !is_space(c) {
+        return Err(Unexpected(c, Some(i), None))
     });
     Ok(None)
 }
@@ -194,7 +228,7 @@ pub const fn key_seek_length (source: &str) -> DslPerhaps<usize> {
     for_each!((i, c) in char_indices(source) => if is_key_end(c) {
         return Ok(Some(i))
     } else if !is_key_char(c) {
-        return Err(Unexpected(c))
+        return Err(Unexpected(c, Some(i), None))
     });
     Ok(Some(source.len()))
 }
@@ -204,8 +238,8 @@ pub const fn is_text_end (c: char) -> bool { matches!(c, '"') }
 pub const fn text_seek_start (source: &str) -> DslPerhaps<usize> {
     for_each!((i, c) in char_indices(source) => if is_text_start(c) {
         return Ok(Some(i))
-    } else if !is_whitespace(c) {
-        return Err(Unexpected(c))
+    } else if !is_space(c) {
+        return Err(Unexpected(c, Some(i), None))
     });
     Ok(None)
 }
@@ -217,8 +251,8 @@ def_peek_seek!(num_peek, num_peek_only, num_seek, num_seek_start, num_seek_lengt
 pub const fn num_seek_start (source: &str) -> DslPerhaps<usize> {
     for_each!((i, c) in char_indices(source) => if is_digit(c) {
         return Ok(Some(i));
-    } else if !is_whitespace(c) {
-        return Err(Unexpected(c))
+    } else if !is_space(c) {
+        return Err(Unexpected(c, Some(i), None))
     });
     Ok(None)
 }
@@ -226,7 +260,7 @@ pub const fn num_seek_length (source: &str) -> DslPerhaps<usize> {
     for_each!((i, c) in char_indices(source) => if is_num_end(c) {
         return Ok(Some(i))
     } else if !is_digit(c) {
-        return Err(Unexpected(c))
+        return Err(Unexpected(c, Some(i), None))
     });
     Ok(None)
 }
@@ -248,46 +282,6 @@ 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))
+        _ => return Err(Unexpected(c, None, Some("parse digit")))
     })
 }
-pub const fn peek (src: &str) -> DslPerhaps<&str> {
-    Ok(Some(match () {
-        _ if let Ok(Some(exp))  = exp_peek(src) => exp,
-        _ if let Ok(Some(sym))  = sym_peek(src) => sym,
-        _ if let Ok(Some(key))  = key_peek(src) => key,
-        _ if let Ok(Some(num))  = num_peek(src) => num,
-        _ if let Ok(Some(text)) = text_peek(src) => text,
-        _ => {
-            for_each!((_, c) in char_indices(src) => if !is_whitespace(c) {
-                return Err(Unexpected(c))
-            });
-            return Ok(None)
-        }
-    }))
-}
-pub const fn seek (src: &str) -> DslPerhaps<(usize, usize)> {
-    Ok(Some(match () {
-        _ if let Ok(Some(exp))  = exp_seek(src) => exp,
-        _ if let Ok(Some(sym))  = sym_seek(src) => sym,
-        _ if let Ok(Some(key))  = key_seek(src) => key,
-        _ if let Ok(Some(num))  = num_seek(src) => num,
-        _ if let Ok(Some(text)) = text_seek(src) => text,
-        _ => {
-            for_each!((_, c) in char_indices(src) => if !is_whitespace(c) {
-                return Err(Unexpected(c))
-            });
-            return Ok(None)
-        }
-    }))
-}
-pub const fn is_whitespace (c: char) -> bool {
-    matches!(c, ' '|'\n'|'\r'|'\t')
-}
-pub const fn no_trailing_non_whitespace (source: &str, offset: usize) -> DslResult<()> {
-    let tail = str_range(source, offset, source.len());
-    for_each!((_, c) in char_indices(tail) => if !is_whitespace(c) {
-        return Err(Unexpected(c))
-    });
-    Ok(())
-}

dsl/src/dsl_test.rs

@@ -21,6 +21,8 @@ macro_rules!is_err(($exp:expr)=>{assert!($exp.is_err())};
     check("(a b c) d e f", Err(e1), Err(e3), Ok(Some("(a b c)")), Ok(Some("d e f")));
     check("a (b c d) e f", Err(e1), Err(e0), Ok(Some("a")), Ok(Some("(b c d) e f")));
 
+    is_some!(sym_peek("\n  :view/transport"), ":view/transport");
+
     assert!(is_whitespace(' '));
     assert!(!is_key_start(' '));
     assert!(is_key_start('f'));