mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-12-07 04:06:45 +01:00
generalize EdnItem.
maybe should rename it to Atom? ~90 instances of it
This commit is contained in:
parent
1b9da07280
commit
143cd24e09
20 changed files with 314 additions and 286 deletions
|
|
@ -1,14 +1,34 @@
|
|||
use crate::*;
|
||||
use std::sync::Arc;
|
||||
#[derive(Default, Clone, PartialEq)] pub enum EdnItem {
|
||||
#[derive(Default, Clone, PartialEq)] pub enum EdnItem<T> {
|
||||
#[default] Nil,
|
||||
Num(usize),
|
||||
Sym(Arc<str>),
|
||||
Key(Arc<str>),
|
||||
Exp(Vec<EdnItem>),
|
||||
Sym(T),
|
||||
Key(T),
|
||||
Exp(Vec<EdnItem<T>>),
|
||||
}
|
||||
impl EdnItem {
|
||||
pub fn read_all (mut source: &str) -> Result<Vec<Self>, ParseError> {
|
||||
impl<'a, T: 'a> EdnItem<T> {
|
||||
pub fn transform <U: 'a, F: Fn(&'a T)->U + Clone> (&'a self, f: F) -> EdnItem<U> {
|
||||
use EdnItem::*;
|
||||
match self {
|
||||
Nil => Nil,
|
||||
Num(n) => Num(*n),
|
||||
Sym(t) => Sym(f(t)),
|
||||
Key(t) => Key(f(t)),
|
||||
Exp(e) => Exp(e.iter().map(|i|i.transform(f.clone())).collect())
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'a, T: AsRef<str>> EdnItem<T> {
|
||||
pub fn to_ref (&'a self) -> EdnItem<&'a str> {
|
||||
self.transform(|t|t.as_ref())
|
||||
}
|
||||
pub fn to_arc (&'a self) -> EdnItem<Arc<str>> {
|
||||
self.transform(|t|t.as_ref().into())
|
||||
}
|
||||
}
|
||||
impl<'a> EdnItem<Arc<str>> {
|
||||
pub fn read_all (mut source: &'a str) -> Result<Vec<Self>, ParseError> {
|
||||
let mut items = vec![];
|
||||
loop {
|
||||
if source.len() == 0 {
|
||||
|
|
@ -20,7 +40,7 @@ impl EdnItem {
|
|||
}
|
||||
Ok(items)
|
||||
}
|
||||
pub fn read_one (source: &str) -> Result<(Self, &str), ParseError> {
|
||||
pub fn read_one (source: &'a str) -> Result<(Self, &'a str), ParseError> {
|
||||
Ok({
|
||||
if source.len() == 0 {
|
||||
return Err(ParseError::Code(5))
|
||||
|
|
@ -29,23 +49,19 @@ impl EdnItem {
|
|||
(Self::read(token)?, remaining)
|
||||
})
|
||||
}
|
||||
pub fn read <'a> (token: Token<'a>) -> Result<Self, ParseError> {
|
||||
use Token::*;
|
||||
pub fn read (token: Token<'a>) -> Result<Self, ParseError> {
|
||||
use EdnItem::*;
|
||||
Ok(match token {
|
||||
Nil => EdnItem::Nil,
|
||||
Num(chars, index, length) =>
|
||||
Self::Num(Token::number(&chars[index..index+length])),
|
||||
Sym(chars, index, length) =>
|
||||
Self::Sym((&chars[index..index+length]).into()),
|
||||
Key(chars, index, length) =>
|
||||
Self::Key((&chars[index..index+length]).into()),
|
||||
Exp(chars, index, length, 0) =>
|
||||
Self::Exp(Self::read_all(&chars[index+1..(index+length).saturating_sub(1)])?),
|
||||
Token::Nil => Nil,
|
||||
Token::Num(_, _, _) => Num(Token::number(token.string())),
|
||||
Token::Sym(_, _, _) => Sym(token.string().into()),
|
||||
Token::Key(_, _, _) => Key(token.string().into()),
|
||||
Token::Exp(_, _, _, 0) => Exp(EdnItem::read_all(token.string())?),
|
||||
_ => panic!("unclosed delimiter")
|
||||
})
|
||||
}
|
||||
}
|
||||
impl Debug for EdnItem {
|
||||
impl<T: Debug> Debug for EdnItem<T> {
|
||||
fn fmt (&self, f: &mut Formatter<'_>) -> Result<(), FormatError> {
|
||||
use EdnItem::*;
|
||||
match self {
|
||||
|
|
@ -58,7 +74,7 @@ impl Debug for EdnItem {
|
|||
}
|
||||
}
|
||||
}
|
||||
impl Display for EdnItem {
|
||||
impl<T: Display> Display for EdnItem<T> {
|
||||
fn fmt (&self, f: &mut Formatter<'_>) -> Result<(), FormatError> {
|
||||
use EdnItem::*;
|
||||
use itertools::join;
|
||||
|
|
@ -71,18 +87,3 @@ impl Display for EdnItem {
|
|||
}
|
||||
}
|
||||
}
|
||||
impl<'a> TryFrom<Token<'a>> for EdnItem {
|
||||
type Error = ParseError;
|
||||
fn try_from (token: Token<'a>) -> Result<Self, Self::Error> {
|
||||
use Token::*;
|
||||
Ok(match token {
|
||||
Nil => Self::Nil,
|
||||
Num(chars, index, length) => Self::Num(Token::number(&chars[index..index+length])),
|
||||
Sym(chars, index, length) => Self::Sym((&chars[index..index+length]).into()),
|
||||
Key(chars, index, length) => Self::Key((&chars[index..index+length]).into()),
|
||||
Exp(chars, index, length, 0) => Self::Exp(Self::read_all(
|
||||
&chars[index+1..(index+length).saturating_sub(1)])?),
|
||||
_ => panic!("unclosed delimiter")
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,69 +1,95 @@
|
|||
use crate::*;
|
||||
/// Implement `EdnProvide` for a type and context
|
||||
/// Map EDN tokens to parameters of a given type for a given context
|
||||
pub trait EdnProvide<'a, U>: Sized {
|
||||
fn get (&'a self, _edn: &'a EdnItem<impl AsRef<str>>) -> Option<U> {
|
||||
None
|
||||
}
|
||||
fn get_or_fail (&'a self, edn: &'a EdnItem<impl AsRef<str>>) -> U {
|
||||
self.get(edn).expect("no value")
|
||||
}
|
||||
}
|
||||
impl<'a, T: EdnProvide<'a, U>, U> EdnProvide<'a, U> for &T {
|
||||
fn get (&'a self, edn: &'a EdnItem<impl AsRef<str>>) -> Option<U> {
|
||||
(*self).get(edn)
|
||||
}
|
||||
fn get_or_fail (&'a self, edn: &'a EdnItem<impl AsRef<str>>) -> U {
|
||||
(*self).get_or_fail(edn)
|
||||
}
|
||||
}
|
||||
impl<'a, T: EdnProvide<'a, U>, U> EdnProvide<'a, U> for Option<T> {
|
||||
fn get (&'a self, edn: &'a EdnItem<impl AsRef<str>>) -> Option<U> {
|
||||
self.as_ref().map(|s|s.get(edn)).flatten()
|
||||
}
|
||||
fn get_or_fail (&'a self, edn: &'a EdnItem<impl AsRef<str>>) -> U {
|
||||
self.as_ref().map(|s|s.get_or_fail(edn)).expect("no provider")
|
||||
}
|
||||
}
|
||||
/// Implement `EdnProvide` for a context and type.
|
||||
#[macro_export] macro_rules! edn_provide {
|
||||
// Provide a value to the EDN template
|
||||
($type:ty:|$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
|
||||
impl<'a> EdnProvide<'a, $type> for $State {
|
||||
fn get (&'a $self, edn: &'a EdnItem) -> Option<$type> {
|
||||
Some(match EdnItem::<&str>::from(edn) { $(EdnItem::Sym($pat) => $expr,)* _ => return None })
|
||||
fn get (&'a $self, edn: &'a EdnItem<impl AsRef<str>>) -> Option<$type> {
|
||||
use EdnItem::*;
|
||||
Some(match edn.to_ref() { $(Sym($pat) => $expr,)* _ => return None })
|
||||
}
|
||||
}
|
||||
};
|
||||
// Provide a value more generically
|
||||
($lt:lifetime: $type:ty:|$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
|
||||
impl<$lt> EdnProvide<$lt, $type> for $State {
|
||||
fn get (&$lt $self, edn: &$lt EdnItem) -> Option<$type> {
|
||||
Some(match EdnItem::<&str>::from(edn) { $(EdnItem::Sym($pat) => $expr,)* _ => return None })
|
||||
fn get (&$lt $self, edn: &$lt EdnItem<impl AsRef<str>>) -> Option<$type> {
|
||||
use EdnItem::*;
|
||||
Some(match edn.to_ref() { $(Sym($pat) => $expr,)* _ => return None })
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
/// Implement `EdnProvide` for a context and numeric type.
|
||||
///
|
||||
/// This enables support for numeric literals.
|
||||
#[macro_export] macro_rules! edn_provide_num {
|
||||
// Provide a value that may also be a numeric literal in the EDN, to a generic implementation.
|
||||
(# $type:ty:|$self:ident:<$T:ident:$Trait:path>|{ $($pat:pat => $expr:expr),* $(,)? }) => {
|
||||
($type:ty:|$self:ident:<$T:ident:$Trait:path>|{ $($pat:pat => $expr:expr),* $(,)? }) => {
|
||||
impl<'a, $T: $Trait> EdnProvide<'a, $type> for $T {
|
||||
fn get (&'a $self, edn: &'a EdnItem) -> Option<$type> {
|
||||
Some(match edn {
|
||||
$(EdnItem::Sym($pat) => $expr,)*
|
||||
EdnItem::Num(n) => *n as $type,
|
||||
_ => return None
|
||||
})
|
||||
fn get (&'a $self, edn: &'a EdnItem<impl AsRef<str>>) -> Option<$type> {
|
||||
use EdnItem::*;
|
||||
Some(match edn.to_ref() { $(Sym($pat) => $expr,)* Num(n) => n as $type, _ => return None })
|
||||
}
|
||||
}
|
||||
};
|
||||
// Provide a value that may also be a numeric literal in the EDN, to a concrete implementation.
|
||||
(# $type:ty:|$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
|
||||
($type:ty:|$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
|
||||
impl<'a> EdnProvide<'a, $type> for $State {
|
||||
fn get (&'a $self, edn: &'a EdnItem) -> Option<$type> {
|
||||
Some(match edn {
|
||||
$(EdnItem::Sym($pat) => $expr,)*
|
||||
EdnItem::Num(n) => *n as $type,
|
||||
fn get (&'a $self, edn: &'a EdnItem<impl AsRef<str>>) -> Option<$type> {
|
||||
use EdnItem::*;
|
||||
Some(match edn.to_ref() { $(Sym($pat) => $expr,)* Num(n) => n as $type, _ => return None })
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
/// Implement `EdnProvide` for a context and content type.
|
||||
///
|
||||
/// This enables support for layout expressions.
|
||||
#[macro_export] macro_rules! edn_provide_content {
|
||||
(|$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
|
||||
impl<'a, E: Output> EdnProvide<'a, Box<dyn Render<E> + 'a>> for $State {
|
||||
fn get (&'a $self, edn: &'a EdnItem<impl AsRef<str>>) -> Option<Box<dyn Render<E> + 'a>> {
|
||||
Some(match edn.to_ref() {
|
||||
$(EdnItem::Sym($pat) => $expr),*,
|
||||
_ => return None
|
||||
})
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
/// Map EDN tokens to parameters of a given type for a given context
|
||||
pub trait EdnProvide<'a, U>: Sized {
|
||||
fn get (&'a self, _edn: &'a EdnItem) -> Option<U> {
|
||||
None
|
||||
}
|
||||
fn get_or_fail (&'a self, edn: &'a EdnItem) -> U {
|
||||
self.get(edn).expect("no value")
|
||||
}
|
||||
}
|
||||
impl<'a, T: EdnProvide<'a, U>, U> EdnProvide<'a, U> for &T {
|
||||
fn get (&'a self, edn: &'a EdnItem) -> Option<U> {
|
||||
(*self).get(edn)
|
||||
}
|
||||
fn get_or_fail (&'a self, edn: &'a EdnItem) -> U {
|
||||
(*self).get_or_fail(edn)
|
||||
}
|
||||
}
|
||||
impl<'a, T: EdnProvide<'a, U>, U> EdnProvide<'a, U> for Option<T> {
|
||||
fn get (&'a self, edn: &'a EdnItem) -> Option<U> {
|
||||
self.as_ref().map(|s|s.get(edn)).flatten()
|
||||
}
|
||||
fn get_or_fail (&'a self, edn: &'a EdnItem) -> U {
|
||||
self.as_ref().map(|s|s.get_or_fail(edn)).expect("no provider")
|
||||
($Output:ty: |$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
|
||||
impl<'a> EdnProvide<'a, Box<dyn Render<$Output> + 'a>> for $State {
|
||||
fn get (&'a $self, edn: &'a EdnItem<impl AsRef<str>>) -> Option<Box<dyn Render<$Output> + 'a>> {
|
||||
Some(match edn.to_ref() {
|
||||
$(EdnItem::Sym($pat) => $expr),*,
|
||||
_ => return None
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -72,7 +72,17 @@ impl<'a> Token<'a> {
|
|||
}
|
||||
Ok(("", state))
|
||||
}
|
||||
|
||||
pub fn string (&self) -> &str {
|
||||
use Token::*;
|
||||
match self {
|
||||
Nil => "",
|
||||
Num(src, start, len) => &src[*start..start+len],
|
||||
Sym(src, start, len) => &src[*start..start+len],
|
||||
Key(src, start, len) => &src[*start..start+len],
|
||||
Exp(src, start, len, 0) => &src[*start..(start+len).saturating_sub(1)],
|
||||
_ => panic!("unclosed delimiter")
|
||||
}
|
||||
}
|
||||
pub const fn number (digits: &str) -> usize {
|
||||
let mut value = 0;
|
||||
let mut chars = konst::string::char_indices(digits);
|
||||
|
|
@ -82,7 +92,6 @@ impl<'a> Token<'a> {
|
|||
}
|
||||
value
|
||||
}
|
||||
|
||||
pub const fn digit (c: char) -> usize {
|
||||
match c { '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4,
|
||||
'5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9, _ => panic!("not a digit") }
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
use crate::*;
|
||||
|
||||
pub trait TryFromEdn<'a, T>: Sized {
|
||||
fn try_from_edn (state: &'a T, head: &EdnItem, tail: &'a [EdnItem]) ->
|
||||
fn try_from_edn (state: &'a T, head: &EdnItem<impl AsRef<str>>, tail: &'a [EdnItem<impl AsRef<str>>]) ->
|
||||
Option<Self>;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue