unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-12-06 11:46:41 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

wip: make EdnItem work on Arc<str>

Browse source
This commit is contained in:
🪞👃🪞 2025-01-17 18:49:04 +01:00
parent d4f962fbfa
commit 1b9da07280
17 changed files with 152 additions and 260 deletions
Download patch file Download diff file Expand all files Collapse all files

8
edn/src/edn_error.rs
View file

@ -1,11 +1,9 @@
use crate::*;
#[derive(Debug)]
pub enum ParseError {
Unknown(u8),
#[derive(Debug)] pub enum ParseError {
Empty,
Incomplete,
Unexpected(char),
Code(u8),
}
impl std::fmt::Display for ParseError {
fn fmt (&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@ -13,7 +11,7 @@ impl std::fmt::Display for ParseError {
Self::Empty => write!(f, "empty"),
Self::Incomplete => write!(f, "incomplete"),
Self::Unexpected(c) => write!(f, "unexpected '{c}'"),
Self::Unknown(i) => write!(f, "unknown #{i}"),
Self::Code(i) => write!(f, "error #{i}"),
}
}
}

208
edn/src/edn_item.rs
View file

@ -1,31 +1,51 @@
use crate::*;
pub enum EdnItem<T> {
Nil,
use std::sync::Arc;
#[derive(Default, Clone, PartialEq)] pub enum EdnItem {
#[default] Nil,
Num(usize),
Sym(T),
Key(T),
Exp(Vec<EdnItem<T>>),
Sym(Arc<str>),
Key(Arc<str>),
Exp(Vec<EdnItem>),
}
impl<T> Default for EdnItem<T> {
fn default () -> Self {
Self::Nil
}
}
impl<T: Debug + Display> Display for EdnItem<T> {
fn fmt (&self, f: &mut Formatter<'_>) -> Result<(), FormatError> {
use EdnItem::*;
use itertools::join;
match self {
Nil => write!(f, ""),
Num(u) => write!(f, "{u}"),
Sym(u) => write!(f, "{u}"),
Key(u) => write!(f, "{u}"),
Exp(e) => write!(f, "({})", join(e.iter().map(|i|format!("{}", i)), " "))
impl EdnItem {
pub fn read_all (mut source: &str) -> Result<Vec<Self>, ParseError> {
let mut items = vec![];
loop {
if source.len() == 0 {
break
}
let (remaining, token) = Token::chomp(source)?;
match Self::read(token)? { Self::Nil => {}, item => items.push(item) };
source = remaining
}
Ok(items)
}
pub fn read_one (source: &str) -> Result<(Self, &str), ParseError> {
Ok({
if source.len() == 0 {
return Err(ParseError::Code(5))
}
let (remaining, token) = Token::chomp(source)?;
(Self::read(token)?, remaining)
})
}
pub fn read <'a> (token: Token<'a>) -> Result<Self, ParseError> {
use Token::*;
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)])?),
_ => panic!("unclosed delimiter")
})
}
}
impl<T: Debug> Debug for EdnItem<T> {
impl Debug for EdnItem {
fn fmt (&self, f: &mut Formatter<'_>) -> Result<(), FormatError> {
use EdnItem::*;
match self {
@ -38,147 +58,31 @@ impl<T: Debug> Debug for EdnItem<T> {
}
}
}
impl<T: PartialEq> PartialEq for EdnItem<T> {
fn eq (&self, other: &Self) -> bool {
use EdnItem::*;
match (self, other) {
(Nil, Nil) => true,
(Num(a), Num(b)) => a == b,
(Sym(a), Sym(b)) => a == b,
(Key(a), Key(b)) => a == b,
(Exp(a), Exp(b)) => a == b,
_ => false
}
}
}
impl EdnItem<&str> {
pub fn clone (&self) -> EdnItem<String> {
impl Display for EdnItem {
fn fmt (&self, f: &mut Formatter<'_>) -> Result<(), FormatError> {
use EdnItem::*;
use itertools::join;
match self {
Nil => Nil,
Num(u) => Num(*u),
Sym(u) => Sym(u.to_string()),
Key(u) => Key(u.to_string()),
Exp(e) => Exp(e.iter().map(|i|i.clone()).collect()),
Nil => write!(f, ""),
Num(u) => write!(f, "{u}"),
Sym(u) => write!(f, "{u}"),
Key(u) => write!(f, "{u}"),
Exp(e) => write!(f, "({})", join(e.iter().map(|i|format!("{}", i)), " "))
}
}
}
impl<T: AsRef<str>> EdnItem<T> {
pub fn to_ref (&self) -> EdnItem<&str> {
match self {
Self::Nil => EdnItem::Nil,
Self::Num(x) => EdnItem::Num(*x),
Self::Key(x) => EdnItem::Key(x.as_ref()),
Self::Sym(x) => EdnItem::Sym(x.as_ref()),
Self::Exp(x) => EdnItem::Exp(x.iter().map(|x|x.to_ref()).collect::<Vec<_>>()),
}
}
pub fn to_str (&self) -> &str {
match self {
Self::Nil => "",
Self::Num(_) => "",
Self::Key(x) => x.as_ref(),
Self::Sym(x) => x.as_ref(),
Self::Exp(_) => "",
}
}
pub fn symbols <'a> (&'a self) -> EdnIterator<'a, T> {
EdnIterator::new(&self)
}
}
impl EdnItem<String> {
pub fn from (other: EdnItem<impl AsRef<str>>) -> EdnItem<String> {
use EdnItem::*;
match other {
Nil => Nil,
Key(t) => Key(t.as_ref().to_string()),
_ => todo!()
}
}
}
impl<'a> TryFrom<Token<'a>> for EdnItem<String> {
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(String::from(&chars[index..index+length])),
Key(chars, index, length) =>
Self::Key(String::from(&chars[index..index+length])),
Exp(chars, index, length, 0) =>
Self::Exp(Self::read_all(&chars[index+1..(index+length).saturating_sub(1)])?),
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")
})
}
}
impl<'a> TryFrom<Token<'a>> for EdnItem<&'a str> {
type Error = ParseError;
fn try_from (token: Token<'a>) -> Result<Self, Self::Error> {
use Token::*;
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]),
Key(chars, index, length) =>
Self::Key(&chars[index..index+length]),
Exp(chars, index, length, 0) =>
Self::Exp(Self::read_all(&chars[index+1..(index+length).saturating_sub(1)])?),
_ => panic!("unclosed delimiter")
})
}
}
impl<'a, T: std::fmt::Debug + Clone + Default + PartialEq + From<&'a str>> EdnItem<T> {
pub fn read_all (mut source: &'a str) -> Result<Vec<Self>, ParseError> {
let mut items = vec![];
loop {
if source.len() == 0 {
break
}
let (remaining, token) = Token::chomp(source)?;
match Self::read(token)? { Self::Nil => {}, item => items.push(item) };
source = remaining
}
Ok(items)
}
pub fn read_one (source: &'a str) -> Result<(Self, &'a str), ParseError> {
Ok({
if source.len() == 0 {
return Err(ParseError::Unknown(5))
}
let (remaining, token) = Token::chomp(source)?;
(Self::read(token)?, remaining)
})
}
pub fn read (token: Token<'a>) -> Result<Self, ParseError> {
use Token::*;
Ok(match token {
Nil => EdnItem::Nil,
Num(chars, index, length) =>
Self::Num(Token::number(&chars[index..index+length])),
Sym(chars, index, length) =>
Self::Sym(T::from(&chars[index..index+length])),
Key(chars, index, length) =>
Self::Key(T::from(&chars[index..index+length])),
Exp(chars, index, length, 0) =>
Self::Exp(Self::read_all(&chars[index+1..(index+length).saturating_sub(1)])?),
_ => panic!("unclosed delimiter")
})
}
//pub fn to_str <'a> (&'a self) -> EdnItem<&'a str> {
//use EdnItem::*;
//match self {
//Nil => Nil,
//Num(n) => Num(*n),
//Sym(t) => Sym(t.as_str()),
//Key(t) => Key(t.as_str()),
//Exp(t) => Exp(t.iter().map(|x|x.to_str()).collect())
//}
//}
}

19
edn/src/edn_iter.rs
View file

@ -1,28 +1,29 @@
use crate::*;
pub enum EdnIterator<'a, T>{
use std::sync::Arc;
pub enum EdnIterator {
Nil,
Sym(&'a T),
Exp(Vec<EdnIterator<'a, T>>)
Sym(Arc<str>),
Exp(Vec<EdnIterator>)
}
impl<'a, T: AsRef<str>> EdnIterator<'a, T> {
pub fn new (item: &'a EdnItem<T>) -> Self {
impl EdnIterator {
pub fn new (item: &EdnItem) -> Self {
use EdnItem::*;
match item {
Sym(t) => Self::Sym(t),
Sym(t) => Self::Sym(t.clone()),
Exp(i) => Self::Exp(i.iter().map(EdnIterator::new).collect()),
_ => Self::Nil,
}
}
}
impl<'a, T: AsRef<str>> Iterator for EdnIterator<'a, T> {
type Item = &'a T;
impl Iterator for EdnIterator {
type Item = EdnItem;
fn next (&mut self) -> Option<Self::Item> {
use EdnIterator::*;
match self {
Sym(t) => {
let t = *t;
*self = Nil;
Some(t)
Some(Sym(t))
},
Exp(v) => match v.as_mut_slice() {
[a] => if let Some(next) = a.next() {

32
edn/src/edn_provide.rs
View file

@ -4,26 +4,26 @@ use crate::*;
// 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 <S: AsRef<str>> (&'a $self, edn: &'a EdnItem<S>) -> Option<$type> {
Some(match edn.to_ref() { $(EdnItem::Sym($pat) => $expr,)* _ => return None })
fn get (&'a $self, edn: &'a EdnItem) -> Option<$type> {
Some(match EdnItem::<&str>::from(edn) { $(EdnItem::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 <S: AsRef<str>> (&$lt $self, edn: &$lt EdnItem<S>) -> Option<$type> {
Some(match edn.to_ref() { $(EdnItem::Sym($pat) => $expr,)* _ => return None })
fn get (&$lt $self, edn: &$lt EdnItem) -> Option<$type> {
Some(match EdnItem::<&str>::from(edn) { $(EdnItem::Sym($pat) => $expr,)* _ => return None })
}
}
};
// 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),* $(,)? }) => {
impl<'a, $T: $Trait> EdnProvide<'a, $type> for $T {
fn get <S: AsRef<str>> (&'a $self, edn: &'a EdnItem<S>) -> Option<$type> {
Some(match edn.to_ref() {
fn get (&'a $self, edn: &'a EdnItem) -> Option<$type> {
Some(match edn {
$(EdnItem::Sym($pat) => $expr,)*
EdnItem::Num(n) => n as $type,
EdnItem::Num(n) => *n as $type,
_ => return None
})
}
@ -32,10 +32,10 @@ use crate::*;
// 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),* $(,)? }) => {
impl<'a> EdnProvide<'a, $type> for $State {
fn get <S: AsRef<str>> (&'a $self, edn: &'a EdnItem<S>) -> Option<$type> {
Some(match edn.to_ref() {
fn get (&'a $self, edn: &'a EdnItem) -> Option<$type> {
Some(match edn {
$(EdnItem::Sym($pat) => $expr,)*
EdnItem::Num(n) => n as $type,
EdnItem::Num(n) => *n as $type,
_ => return None
})
}
@ -44,26 +44,26 @@ use crate::*;
}
/// Map EDN tokens to parameters of a given type for a given context
pub trait EdnProvide<'a, U>: Sized {
fn get <S: AsRef<str>> (&'a self, _edn: &'a EdnItem<S>) -> Option<U> {
fn get (&'a self, _edn: &'a EdnItem) -> Option<U> {
None
}
fn get_or_fail <S: AsRef<str>> (&'a self, edn: &'a EdnItem<S>) -> U {
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 <S: AsRef<str>> (&'a self, edn: &'a EdnItem<S>) -> Option<U> {
fn get (&'a self, edn: &'a EdnItem) -> Option<U> {
(*self).get(edn)
}
fn get_or_fail <S: AsRef<str>> (&'a self, edn: &'a EdnItem<S>) -> U {
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 <S: AsRef<str>> (&'a self, edn: &'a EdnItem<S>) -> Option<U> {
fn get (&'a self, edn: &'a EdnItem) -> Option<U> {
self.as_ref().map(|s|s.get(edn)).flatten()
}
fn get_or_fail <S: AsRef<str>> (&'a self, edn: &'a EdnItem<S>) -> U {
fn get_or_fail (&'a self, edn: &'a EdnItem) -> U {
self.as_ref().map(|s|s.get_or_fail(edn)).expect("no provider")
}
}

9
edn/src/lib.rs
View file

@ -1,15 +1,12 @@
#![feature(type_alias_impl_trait)]
#![feature(impl_trait_in_fn_trait_return)]
pub(crate) use std::{fmt::{Debug, Display, Formatter, Error as FormatError}};
mod edn_error; pub use self::edn_error::*;
mod edn_item; pub use self::edn_item::*;
mod edn_iter; pub use self::edn_iter::*;
//mod edn_iter; pub use self::edn_iter::*;
mod edn_token; pub use self::edn_token::*;
mod edn_provide; pub use self::edn_provide::*;
mod try_from_edn; pub use self::try_from_edn::*;
pub(crate) use std::{fmt::{Debug, Display, Formatter, Error as FormatError}};
#[cfg(test)] #[test] fn test_edn () -> Result<(), ParseError> {
use EdnItem::*;
assert_eq!(EdnItem::<String>::read_all("")?,
@ -30,7 +27,6 @@ mod try_from_edn; pub use self::try_from_edn::*;
vec![Exp(vec![Key("foo/bar".into()), Sym(":baz".into()), Num(456)])]);
Ok(())
}
#[cfg(test)] #[test] fn test_edn_layout () -> Result<(), ParseError> {
EdnItem::<String>::read_all(include_str!("../../output/examples/edn01.edn"))?;
EdnItem::<String>::read_all(include_str!("../../output/examples/edn02.edn"))?;
@ -38,7 +34,6 @@ mod try_from_edn; pub use self::try_from_edn::*;
//let content = <dyn EdnViewData<::tek_engine::tui::Tui>>::from(&layout);
Ok(())
}
#[macro_export] macro_rules! from_edn {
($($x:tt)*) => {}
}

2
edn/src/try_from_edn.rs
View file

@ -1,6 +1,6 @@
use crate::*;
pub trait TryFromEdn<'a, T>: Sized {
fn try_from_edn (state: &'a T, head: &EdnItem<&str>, tail: &'a [EdnItem<&str>]) ->
fn try_from_edn (state: &'a T, head: &EdnItem, tail: &'a [EdnItem]) ->
Option<Self>;
}