unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-04-08 14:50:14 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

once again, why did i begin to refactor this

Browse source
This commit is contained in:
🪞👃🪞 2025-01-18 00:13:36 +01:00
parent 297f9b30df
commit 798de37172
15 changed files with 582 additions and 602 deletions

204
.old/tek.rs.old
View file

@ -1907,3 +1907,207 @@ from_edn!("mixer/track" => |jack: &Arc<RwLock<JackConnection>>, args| -> MixerTr
//})
//}
//}
use std::sync::{Arc, RwLock};
use std::collections::BTreeMap;
pub use clojure_reader::edn::Edn;
//#[derive(Debug, Copy, Clone, Default, PartialEq)]
//pub struct Items<'a>(&'a [Item<'a>]);
//impl<'a> Items<'a> {
//fn iter (&'a self) -> ItemsIterator<'a> {
//ItemsIterator(0, self.0)
//}
//}
//pub struct ItemsIterator<'a>(usize, &'a [Item<'a>]);
//impl<'a> Iterator for ItemsIterator<'a> {
//type Item = &'a Item<'a>;
//fn next (&mut self) -> Option<Self::Item> {
//let item = self.1.get(self.0);
//self.0 += 1;
//item
//}
//}
/*
nice but doesn't work without compile time slice concat
(which i guess could be implemeted using an unsafe linked list?)
never done that one before im ny life, might try
use konst::slice_concat;
const fn read <'a> (
chars: impl Iterator<Item = char>
) -> Result<Range<'a>, ParseError> {
use Range::*;
let mut state = Range::Nil;
let mut tokens: &[Range<'a>] = &[];
while let Some(c) = chars.next() {
state = match state {
// must begin expression
Nil => match c {
' ' => Nil,
'(' => Exp(&[]),
':' => Sym(&[]),
'1'..'9' => Num(digit(c)),
'a'..'z' => Key(&[&[c]]),
_ => return Err(ParseError::Unexpected(c))
},
Num(b) => match c {
' ' => return Ok(Num(digit(c))),
'1'..'9' => Num(b*10+digit(c)),
_ => return Err(ParseError::Unexpected(c))
}
Sym([]) => match c {
'a'..'z' => Sym(&[c]),
_ => return Err(ParseError::Unexpected(c))
},
Sym([b @ ..]) => match c {
' ' => return Ok(Sym(&b)),
'a'..'z' | '0'..'9' | '-' => Sym(&[..b, c]),
_ => return Err(ParseError::Unexpected(c))
}
Key([[b @ ..]]) => match c {
' ' => return Ok(Key(&[&b])),
'/' => Key(&[&b, &[]]),
'a'..'z' | '0'..'9' | '-' => Key(&[&[..b, c], &[]]),
_ => return Err(ParseError::Unexpected(c))
}
Key([s @ .., []]) => match c {
'a'..'z' => Key(&[..s, &[c]]),
_ => return Err(ParseError::Unexpected(c))
}
Key([s @ .., [b @ ..]]) => match c {
'/' => Key([..s, &b, &[]]),
'a'..'z' | '0'..'9' | '-' => Key(&[..s, &[..b, c]]),
_ => return Err(ParseError::Unexpected(c))
}
// expression must begin with key or symbol
Exp([]) => match c {
' ' => Exp(&[]),
')' => return Err(ParseError::Empty),
':' => Exp(&[Sym(&[':'])]),
c => Exp(&[Key(&[&[c]])]),
},
// expression can't begin with number
Exp([Num(num)]) => return Err(ParseError::Unexpected(c)),
// symbol begins with : and lowercase a-z
Exp([Sym([':'])]) => match c {
'a'..'z' => Exp(&[Sym(&[':', c])]),
_ => return Err(ParseError::Unexpected(c)),
},
// any other char is part of symbol until space or )
Exp([Sym([':', b @ ..])]) => match c {
')' => { tokens = &[..tokens, Exp(&[Sym(&[":", ..b])])]; Nil },
' ' => Exp(&[Sym(&[':', ..b]), Nil]),
c => Exp(&[Sym(&[':', ..b, c])]),
},
// key begins with lowercase a-z
Exp([Key([])]) => match c {
'a'..'z' => Exp([Key([[c]])]),
_ => return Err(ParseError::Unexpected(c)),
},
// any other char is part of key until slash space or )
Exp([Key([[b @ ..]])]) => match c {
'/' => Exp(&[Key(&[[..b], []])]),
' ' => Exp(&[Key(&[[..b]]), Nil]),
')' => { tokens = &[..tokens, Exp(&[Sym(&[":", ..b])])]; Nil },
c => Exp(&[Key(&[[..b, c]])])
}
// slash adds new section to key
Exp([Key([b @ .., []])]) => match c {
'/' => Exp(&[Key(&[[..b], []])]),
' ' => Exp(&[Key(&[[..b]]), Nil]),
')' => { tokens = &[..tokens, Exp(&[Sym(&[":", ..b])])]; Nil },
c => Exp(&[Key(&[[..b, c]])])
}
}
}
Ok(state)
}
*/
/// EDN parsing helper.
#[macro_export] macro_rules! edn {
($edn:ident { $($pat:pat => $expr:expr),* $(,)? }) => {
match $edn { $($pat => $expr),* }
};
($edn:ident in $args:ident { $($pat:pat => $expr:expr),* $(,)? }) => {
for $edn in $args {
edn!($edn { $($pat => $expr),* })
}
};
}
pub trait FromEdn<C>: Sized {
const ID: &'static str;
fn from_edn (context: C, expr: &[Edn<'_>]) ->
std::result::Result<Self, Box<dyn std::error::Error>>;
}
/// Implements the [FromEdn] trait.
#[macro_export] macro_rules! from_edn {
($id:expr => |$context:tt:$Context:ty, $args:ident| -> $T:ty $body:block) => {
impl FromEdn<$Context> for $T {
const ID: &'static str = $id;
fn from_edn <'e> ($context: $Context, $args: &[Edn<'e>]) -> Usually<Self> {
$body
}
}
}
}
use crate::*;
use std::sync::Arc;
pub enum EdnIterator {
Nil,
Sym(Arc<str>),
Exp(Vec<EdnIterator>)
}
impl EdnIterator {
pub fn new (item: &EdnItem) -> Self {
use EdnItem::*;
match item {
Sym(t) => Self::Sym(t.clone()),
Exp(i) => Self::Exp(i.iter().map(EdnIterator::new).collect()),
_ => Self::Nil,
}
}
}
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(Sym(t))
},
Exp(v) => match v.as_mut_slice() {
[a] => if let Some(next) = a.next() {
Some(next)
} else {
*self = Exp(v.split_off(1));
self.next()
},
_ => {
*self = Nil;
None
}
},
_ => {
*self = Nil;
None
}
}
}
}

2
edn/README.md
View file

@ -69,7 +69,7 @@ keys are implemented by the underlying subsystem:
### symbols
symbols that start with `:` represent the names of variables
provided by the `EdnProvide` trait - such as command parameters,
provided by the `Context` trait - such as command parameters,
or entire layout components:
```edn

158
edn/src/_edn_scratch.rs
View file

@ -1,158 +0,0 @@
use std::sync::{Arc, RwLock};
use std::collections::BTreeMap;
pub use clojure_reader::edn::Edn;
//#[derive(Debug, Copy, Clone, Default, PartialEq)]
//pub struct Items<'a>(&'a [Item<'a>]);
//impl<'a> Items<'a> {
//fn iter (&'a self) -> ItemsIterator<'a> {
//ItemsIterator(0, self.0)
//}
//}
//pub struct ItemsIterator<'a>(usize, &'a [Item<'a>]);
//impl<'a> Iterator for ItemsIterator<'a> {
//type Item = &'a Item<'a>;
//fn next (&mut self) -> Option<Self::Item> {
//let item = self.1.get(self.0);
//self.0 += 1;
//item
//}
//}
/*
nice but doesn't work without compile time slice concat
(which i guess could be implemeted using an unsafe linked list?)
never done that one before im ny life, might try
use konst::slice_concat;
const fn read <'a> (
chars: impl Iterator<Item = char>
) -> Result<Range<'a>, ParseError> {
use Range::*;
let mut state = Range::Nil;
let mut tokens: &[Range<'a>] = &[];
while let Some(c) = chars.next() {
state = match state {
// must begin expression
Nil => match c {
' ' => Nil,
'(' => Exp(&[]),
':' => Sym(&[]),
'1'..'9' => Num(digit(c)),
'a'..'z' => Key(&[&[c]]),
_ => return Err(ParseError::Unexpected(c))
},
Num(b) => match c {
' ' => return Ok(Num(digit(c))),
'1'..'9' => Num(b*10+digit(c)),
_ => return Err(ParseError::Unexpected(c))
}
Sym([]) => match c {
'a'..'z' => Sym(&[c]),
_ => return Err(ParseError::Unexpected(c))
},
Sym([b @ ..]) => match c {
' ' => return Ok(Sym(&b)),
'a'..'z' | '0'..'9' | '-' => Sym(&[..b, c]),
_ => return Err(ParseError::Unexpected(c))
}
Key([[b @ ..]]) => match c {
' ' => return Ok(Key(&[&b])),
'/' => Key(&[&b, &[]]),
'a'..'z' | '0'..'9' | '-' => Key(&[&[..b, c], &[]]),
_ => return Err(ParseError::Unexpected(c))
}
Key([s @ .., []]) => match c {
'a'..'z' => Key(&[..s, &[c]]),
_ => return Err(ParseError::Unexpected(c))
}
Key([s @ .., [b @ ..]]) => match c {
'/' => Key([..s, &b, &[]]),
'a'..'z' | '0'..'9' | '-' => Key(&[..s, &[..b, c]]),
_ => return Err(ParseError::Unexpected(c))
}
// expression must begin with key or symbol
Exp([]) => match c {
' ' => Exp(&[]),
')' => return Err(ParseError::Empty),
':' => Exp(&[Sym(&[':'])]),
c => Exp(&[Key(&[&[c]])]),
},
// expression can't begin with number
Exp([Num(num)]) => return Err(ParseError::Unexpected(c)),
// symbol begins with : and lowercase a-z
Exp([Sym([':'])]) => match c {
'a'..'z' => Exp(&[Sym(&[':', c])]),
_ => return Err(ParseError::Unexpected(c)),
},
// any other char is part of symbol until space or )
Exp([Sym([':', b @ ..])]) => match c {
')' => { tokens = &[..tokens, Exp(&[Sym(&[":", ..b])])]; Nil },
' ' => Exp(&[Sym(&[':', ..b]), Nil]),
c => Exp(&[Sym(&[':', ..b, c])]),
},
// key begins with lowercase a-z
Exp([Key([])]) => match c {
'a'..'z' => Exp([Key([[c]])]),
_ => return Err(ParseError::Unexpected(c)),
},
// any other char is part of key until slash space or )
Exp([Key([[b @ ..]])]) => match c {
'/' => Exp(&[Key(&[[..b], []])]),
' ' => Exp(&[Key(&[[..b]]), Nil]),
')' => { tokens = &[..tokens, Exp(&[Sym(&[":", ..b])])]; Nil },
c => Exp(&[Key(&[[..b, c]])])
}
// slash adds new section to key
Exp([Key([b @ .., []])]) => match c {
'/' => Exp(&[Key(&[[..b], []])]),
' ' => Exp(&[Key(&[[..b]]), Nil]),
')' => { tokens = &[..tokens, Exp(&[Sym(&[":", ..b])])]; Nil },
c => Exp(&[Key(&[[..b, c]])])
}
}
}
Ok(state)
}
*/
/// EDN parsing helper.
#[macro_export] macro_rules! edn {
($edn:ident { $($pat:pat => $expr:expr),* $(,)? }) => {
match $edn { $($pat => $expr),* }
};
($edn:ident in $args:ident { $($pat:pat => $expr:expr),* $(,)? }) => {
for $edn in $args {
edn!($edn { $($pat => $expr),* })
}
};
}
pub trait FromEdn<C>: Sized {
const ID: &'static str;
fn from_edn (context: C, expr: &[Edn<'_>]) ->
std::result::Result<Self, Box<dyn std::error::Error>>;
}
/// Implements the [FromEdn] trait.
#[macro_export] macro_rules! from_edn {
($id:expr => |$context:tt:$Context:ty, $args:ident| -> $T:ty $body:block) => {
impl FromEdn<$Context> for $T {
const ID: &'static str = $id;
fn from_edn <'e> ($context: $Context, $args: &[Edn<'e>]) -> Usually<Self> {
$body
}
}
}
}

11
edn/src/describe.rs
View file

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

46
edn/src/edn_iter.rs
View file

@ -1,46 +0,0 @@
use crate::*;
use std::sync::Arc;
pub enum EdnIterator {
Nil,
Sym(Arc<str>),
Exp(Vec<EdnIterator>)
}
impl EdnIterator {
pub fn new (item: &EdnItem) -> Self {
use EdnItem::*;
match item {
Sym(t) => Self::Sym(t.clone()),
Exp(i) => Self::Exp(i.iter().map(EdnIterator::new).collect()),
_ => Self::Nil,
}
}
}
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(Sym(t))
},
Exp(v) => match v.as_mut_slice() {
[a] => if let Some(next) = a.next() {
Some(next)
} else {
*self = Exp(v.split_off(1));
self.next()
},
_ => {
*self = Nil;
None
}
},
_ => {
*self = Nil;
None
}
}
}
}

18
edn/src/lib.rs
View file

@ -1,8 +1,6 @@
#![feature(type_alias_impl_trait)]
#![feature(impl_trait_in_fn_trait_return)]
mod token; pub use self::token::*;
mod provide; pub use self::provide::*;
mod describe; pub use self::describe::*;
mod token; pub use self::token::*;
pub(crate) use std::fmt::{Debug, Display, Formatter, Error as FormatError};
pub(crate) use std::sync::Arc;
#[cfg(test)] #[test] fn test_lang () -> Result<(), ParseError> {
@ -32,10 +30,18 @@ pub(crate) use std::sync::Arc;
] {
let items = Atom::read_all(example)?;
//panic!("{layout:?}");
//let content = <dyn EdnViewData<::tek_engine::tui::Tui>>::from(&layout);
//let content = <dyn ViewContext<::tek_engine::tui::Tui>>::from(&layout);
}
Ok(())
}
#[macro_export] macro_rules! from_edn {
($($x:tt)*) => {}
#[cfg(test)] #[test] fn test_token () -> Result<(), Box<dyn std::error::Error>> {
use Token::*;
assert_eq!(Nil, Token::chomp_one("")?);
assert_eq!(Nil, Token::chomp_one(" \n \r \t ")?);
assert_eq!(Num("8", 0, 1), Token::chomp_one("8")?);
assert_eq!(Num(" 8 ", 3, 1), Token::chomp_one(" 8 ")?);
assert_eq!(Sym(":foo", 0, 4), Token::chomp_one(":foo")?);
assert_eq!(Sym("@bar", 0, 4), Token::chomp_one("@bar")?);
assert_eq!(Key("foo/bar", 0, 7), Token::chomp_one("foo/bar")?);
Ok(())
}

95
edn/src/provide.rs
View file

@ -1,95 +0,0 @@
use crate::*;
/// 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 Atom<impl AsRef<str>>) -> Option<U> {
None
}
fn get_or_fail (&'a self, edn: &'a Atom<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 Atom<impl AsRef<str>>) -> Option<U> {
(*self).get(edn)
}
fn get_or_fail (&'a self, edn: &'a Atom<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 Atom<impl AsRef<str>>) -> Option<U> {
self.as_ref().map(|s|s.get(edn)).flatten()
}
fn get_or_fail (&'a self, edn: &'a Atom<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 Atom<impl AsRef<str>>) -> Option<$type> {
use Atom::*;
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 Atom<impl AsRef<str>>) -> Option<$type> {
use Atom::*;
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),* $(,)? }) => {
impl<'a, $T: $Trait> EdnProvide<'a, $type> for $T {
fn get (&'a $self, edn: &'a Atom<impl AsRef<str>>) -> Option<$type> {
use Atom::*;
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),* $(,)? }) => {
impl<'a> EdnProvide<'a, $type> for $State {
fn get (&'a $self, edn: &'a Atom<impl AsRef<str>>) -> Option<$type> {
use Atom::*;
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 Atom<impl AsRef<str>>) -> Option<Box<dyn Render<E> + 'a>> {
Some(match edn.to_ref() {
$(Atom::Sym($pat) => $expr),*,
_ => return None
})
}
}
};
($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 Atom<impl AsRef<str>>) -> Option<Box<dyn Render<$Output> + 'a>> {
Some(match edn.to_ref() {
$(Atom::Sym($pat) => $expr),*,
_ => return None
})
}
}
}
}

430
edn/src/token.rs
View file

@ -1,9 +1,14 @@
use crate::*;
//use std::iter::IntoIterator;
use konst::iter::{ConstIntoIter, IsIteratorKind};
use konst::string::{split_at, str_range, char_indices};
use itertools::join;
use self::ParseError::*;
use self::TokenKind::*;
#[derive(Debug)] pub enum ParseError { Unimplemented, Empty, Incomplete, Unexpected(char), Code(u8), }
type TokenResult<'a> = Result<Token<'a>, ParseError>;
#[derive(Debug)] pub enum ParseError {
Unimplemented, Empty, Incomplete, Unexpected(char), Code(u8),
}
impl std::fmt::Display for ParseError {
fn fmt (&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
@ -16,7 +21,6 @@ impl std::fmt::Display for ParseError {
}
}
impl std::error::Error for ParseError {}
/// Iterator helper macro because I can't find the canonical one in [konst] docs.
macro_rules! iterate {
($expr:expr => $arg: pat => $body:expr) => {
let mut iter = $expr;
@ -26,7 +30,11 @@ macro_rules! iterate {
}
}
}
pub struct TokenIterator<'a>(&'a str);
#[derive(Clone, PartialEq)] pub struct TokenIterator<'a>(&'a str);
impl<'a> Iterator for TokenIterator<'a> {
type Item = TokenResult<'a>;
fn next (&mut self) -> Option<TokenResult<'a>> { self.next_mut().map(|(result, _)|result) }
}
impl<'a> ConstIntoIter for TokenIterator<'a> {
type Kind = IsIteratorKind;
type Item = Token<'a>;
@ -34,16 +42,18 @@ impl<'a> ConstIntoIter for TokenIterator<'a> {
}
impl<'a> TokenIterator<'a> {
pub const fn new (source: &'a str) -> Self { Self(source) }
pub const fn split (self, index: usize) -> Self { Self(split_at(self.0, index).1) }
pub const fn next (self) -> Option<(Result<Token<'a>, ParseError>, Self)> {
let src = self.0;
let mut token: Token<'a> = Token::new(src, Nil, 0, 0, 0);
iterate!(char_indices(src) => (index, c) => token = match token.kind() {
pub const fn split (&self, index: usize) -> Self { Self(split_at(self.0, index).1) }
pub const fn next (mut self) -> Option<(TokenResult<'a>, Self)> {
Self::next_mut(&mut self)
}
pub const fn next_mut (&mut self) -> Option<(TokenResult<'a>, Self)> {
let mut token: Token<'a> = Token::new(self.0, Nil, 0, 0, 0);
iterate!(char_indices(self.0) => (index, c) => token = match token.kind() {
Nil => match c {
'(' => Token::new(src, Exp, index, 1, 1),
':'|'@' => Token::new(src, Sym, index, 1, 0),
'0'..='9' => Token::new(src, Num, index, 1, 0),
'/'|'a'..='z' => Token::new(src, Key, index, 1, 0),
'(' => Token::new(self.0, Exp, index, 1, 1),
':'|'@' => Token::new(self.0, Sym, index, 1, 0),
'0'..='9' => Token::new(self.0, Num, index, 1, 0),
'/'|'a'..='z' => Token::new(self.0, Key, index, 1, 0),
' '|'\n'|'\r'|'\t' => token.grow(),
_ => return Some((Err(Unexpected(c)), self.split(token.end())))
},
@ -63,7 +73,7 @@ impl<'a> TokenIterator<'a> {
_ => return Some((Err(Unexpected(c)), self.split(token.end())))
},
Exp => match token.depth {
0 => return Some((Ok(token), Self(split_at(src, token.end()).1))),
0 => return Some((Ok(token), Self(split_at(self.0, token.end()).1))),
_ => match c {
')' => match token.grow_out() {
Ok(token) => token,
@ -77,31 +87,10 @@ impl<'a> TokenIterator<'a> {
match token.kind() { Nil => None, _ => Some((Err(ParseError::Incomplete), self.split(token.end()))) }
}
}
pub struct AtomIterator<'a>(TokenIterator<'a>);
impl<'a> ConstIntoIter for AtomIterator<'a> {
type Kind = IsIteratorKind;
type Item = Atom<&'a str>;
type IntoIter = Self;
#[derive(Debug, Copy, Clone, Default, PartialEq)] pub enum TokenKind {
#[default] Nil, Num, Sym, Key, Exp
}
impl<'a> AtomIterator<'a> {
pub const fn new (tokens: TokenIterator<'a>) -> Self { Self(tokens) }
pub const fn next (mut self) -> Option<(Result<Atom<&'a str>, ParseError>, Self)> {
match self.0.next() {
None => None,
Some((result, next)) => match result {
Err(e) => Some((Err(e), Self(next))),
Ok(token) => match token.to_ref_atom() {
Err(e) => Some((Err(e), Self(next))),
Ok(atom) => Some((Ok(atom), Self(next))),
}
}
}
}
}
#[derive(Debug, Copy, Clone, Default, PartialEq)]
pub enum TokenKind { #[default] Nil, Num, Sym, Key, Exp }
#[derive(Debug, Copy, Clone, Default, PartialEq)]
pub struct Token<'a> {
#[derive(Debug, Copy, Clone, Default, PartialEq)] pub struct Token<'a> {
source: &'a str,
kind: TokenKind,
start: usize,
@ -115,7 +104,13 @@ impl<'a> Token<'a> {
Self { source, kind, start, length, depth }
}
pub const fn end (&self) -> usize { self.start + self.length }
pub const fn slice (&self) -> &str { str_range(self.source, self.start, self.end()) }
pub const fn slice (&'a self) -> &'a 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 {
str_range(source, self.start, self.end())
}
pub const fn kind (&self) -> TokenKind { Nil }
pub const fn grow (self) -> Self {
Self { length: self.length + 1, ..self }
@ -129,27 +124,15 @@ impl<'a> Token<'a> {
d => Ok(Self { length: self.length + 1, depth: d - 1, ..self })
}
}
pub const fn to_ref_atom (&'a self) -> Result<Atom<&'a str>, ParseError> {
pub const fn to_ref_atom (&'a self) -> Result<RefAtom<'a>, ParseError> {
Ok(match self.kind {
Nil => return Err(ParseError::Empty),
Num => match to_number(self.slice()) {
Ok(n) => Atom::Num(n),
Ok(n) => RefAtom::Num(n),
Err(e) => return Err(e)
},
Sym => Atom::Sym(self.slice()),
Key => Atom::Key(self.slice()),
Exp => todo!()
})
}
pub fn to_arc_atom (&self) -> Result<Atom<Arc<str>>, ParseError> {
Ok(match self.kind {
Nil => return Err(ParseError::Empty),
Num => match to_number(self.slice()) {
Ok(n) => Atom::Num(n),
Err(e) => return Err(e)
},
Sym => Atom::Sym(self.slice().into()),
Key => Atom::Key(self.slice().into()),
Sym => RefAtom::Sym(self.slice()),
Key => RefAtom::Key(self.slice()),
Exp => todo!()
})
}
@ -169,156 +152,225 @@ const fn to_digit (c: char) -> Result<usize, ParseError> {
_ => return Err(Unexpected(c))
})
}
#[derive(Clone, PartialEq)] pub enum Atom<T> { Num(usize), Sym(T), Key(T), Exp(Vec<Atom<T>>) }
impl<'a, T: 'a> Atom<T> {
pub fn transform <U: 'a, F: Fn(&'a T)->U + Clone> (&'a self, f: F) -> Atom<U> {
use Atom::*;
pub trait Atom<'a>: Sized {
fn kind (&self) -> TokenKind;
fn text (&self) -> &str;
fn read_all (source: &'a str) -> impl Iterator<Item = Result<Self, ParseError>>;
}
#[derive(Clone, PartialEq)] pub enum RefAtom<'a> {
Num(usize),
Sym(&'a str),
Key(&'a str),
Exp(TokenIterator<'a>),
}
impl<'a> RefAtom<'a> {
pub fn to_arc_atom (&self) -> ArcAtom {
todo!()
}
}
impl<'a> Atom<'a> for RefAtom<'a> {
fn kind (&self) -> TokenKind {
match self {
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())
Self::Num(_) => TokenKind::Num,
Self::Sym(_) => TokenKind::Sym,
Self::Key(_) => TokenKind::Key,
Self::Exp(_) => TokenKind::Exp,
}
}
}
impl<'a, T: AsRef<str>> Atom<T> {
pub fn to_ref (&'a self) -> Atom<&'a str> {
self.transform(|t|t.as_ref())
fn text (&self) -> &str {
match self {
Self::Num(_)|Self::Exp(_) => "",
Self::Sym(s) => s,
Self::Key(k) => k,
}
}
pub fn to_arc (&'a self) -> Atom<Arc<str>> {
self.transform(|t|t.as_ref().into())
fn read_all (source: &'a str) -> impl Iterator<Item = Result<Self, ParseError>> {
TokenIterator::new(source).map(move |result: TokenResult<'a>|match result{
Err(e) => Err(e),
Ok(token) => match token.kind {
Nil => Err(ParseError::Empty),
Num => match to_number(token.slice_source(source)) {
Ok(n) => Ok(RefAtom::Num(n)),
Err(e) => return Err(e)
},
Sym => Ok(RefAtom::Sym(token.slice_source(source))),
Key => Ok(RefAtom::Key(token.slice_source(source))),
Exp => Ok(RefAtom::Exp(TokenIterator::new(token.slice_source(source))))
},
})
}
}
impl<'a> Atom<&'a str> {
pub const fn read_all_ref (_: &'a str) -> Result<Vec<Self>, ParseError> {
Err(Unimplemented)
}
}
impl<T: Debug> Debug for Atom<T> {
impl<'a> Debug for RefAtom<'a> {
fn fmt (&self, f: &mut Formatter<'_>) -> Result<(), FormatError> {
use Atom::*;
match self {
Num(u) => write!(f, "(num {u})"),
Sym(u) => write!(f, "(sym {u:?})"),
Key(u) => write!(f, "(key {u:?})"),
Exp(e) => write!(f, "(exp {})",
itertools::join(e.iter().map(|i|format!("{:?}", i)), ","))
RefAtom::Num(n) => write!(f, "(num {n})"),
RefAtom::Sym(t) => write!(f, "(sym {t:?})"),
RefAtom::Key(t) => write!(f, "(key {t:?})"),
RefAtom::Exp(u) => write!(f, "(exp {})", join(u.clone().map(|t|format!("{t:?}")), ","))
}
}
}
impl<T: Display> Display for Atom<T> {
#[derive(Clone, PartialEq)] pub enum ArcAtom {
Num(usize),
Sym(Arc<str>),
Key(Arc<str>),
Exp(Vec<ArcAtom>),
}
impl<'a> Atom<'a> for ArcAtom {
fn kind (&self) -> TokenKind {
match self {
Self::Num(_) => TokenKind::Num,
Self::Sym(_) => TokenKind::Sym,
Self::Key(_) => TokenKind::Key,
Self::Exp(_) => TokenKind::Exp,
}
}
fn text (&self) -> &str {
match self {
Self::Num(_)|Self::Exp(_) => "",
Self::Sym(s) => s.as_ref(),
Self::Key(k) => k.as_ref(),
}
}
fn read_all (source: &'a str) -> impl Iterator<Item = Result<Self, ParseError>> {
TokenIterator::new(source).map(move |result: TokenResult<'a>|match result{
Err(e) => Err(e),
Ok(token) => match token.kind {
Nil => Err(ParseError::Empty),
Num => match to_number(token.slice_source(source).into()) {
Ok(n) => Ok(ArcAtom::Num(n)),
Err(e) => return Err(e)
},
Sym => Ok(ArcAtom::Sym(token.slice_source(source).into())),
Key => Ok(ArcAtom::Key(token.slice_source(source).into())),
Exp => Ok(ArcAtom::Exp({
let mut iter = Self::read_all(token.slice_source(source));
let mut atoms = vec![];
while let Some(atom) = iter.next() {
atoms.push(atom?);
}
atoms
}))
},
})
}
}
impl<'a> Debug for ArcAtom {
fn fmt (&self, f: &mut Formatter<'_>) -> Result<(), FormatError> {
use Atom::*;
use itertools::join;
match self {
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)), " "))
Self::Num(n) => write!(f, "(num {n})"),
Self::Sym(t) => write!(f, "(sym {t:?})"),
Self::Key(t) => write!(f, "(key {t:?})"),
Self::Exp(u) => write!(f, "(exp {u:?})"),
}
}
}
//impl<'a> Token<'a> {
//pub const fn chomp_one (source: &'a str) -> Result<Token<'a>, ParseError> {
//match Self::chomp(source) {
//Ok((_, token)) => Ok(token),
//Err(e) => Err(e)
//}
//}
//pub const fn from_nil (c: char) -> Result<(&'a str, Token<'a>), ParseError> {
//match c {
//' '|'\n'|'\r'|'\t' => Nil,
//'(' => Exp(source, index, 1, 1),
//':'|'@' => Sym(source, index, 1),
//'0'..='9' => Num(source, index, 1),
//'a'..='z' => Key(source, index, 1),
//_ => return Err(Unexpected(c))
//}
//}
//pub const fn chomp (source: &'a str) -> Result<(&'a str, Token<'a>), ParseError> {
//let mut state = Self::Nil;
//let mut chars = char_indices(source);
//while let Some(((index, c), next)) = chars.next() {
//state = match state {
//// must begin expression
//Nil => Self::from_nil(c),
//Num(_, _, 0) => unreachable!(),
//Sym(_, _, 0) => unreachable!(),
//Key(_, _, 0) => unreachable!(),
//Num(src, idx, len) => match c {
//'0'..='9' => Num(src, idx, len + 1),
//' '|'\n'|'\r'|'\t' => return Ok((split(src, idx+len).1, Num(src, idx, len))),
//_ => return Err(Unexpected(c))
//},
//Sym(src, idx, len) => match c {
//'a'..='z'|'0'..='9'|'-' => Sym(src, idx, len + 1),
//' '|'\n'|'\r'|'\t' => return Ok((split(src, idx+len).1, Sym(src, idx, len))),
//_ => return Err(Unexpected(c))
//},
//Key(src, idx, len) => match c {
//'a'..='z'|'0'..='9'|'-'|'/' => Key(src, idx, len + 1),
//' '|'\n'|'\r'|'\t' => return Ok((split(src, idx+len).1, Key(src, idx, len))),
//_ => return Err(Unexpected(c))
//},
//Exp(src, idx, len, 0) => match c {
//' '|'\n'|'\r'|'\t' => return Ok((split(src, idx+len).1, Exp(src, idx, len, 0))),
//_ => return Err(Unexpected(c))
//},
//Exp(src, idx, len, balance) => match c {
//')' => Exp(src, idx, len + 1, balance - 1),
//'(' => Exp(src, idx, len + 1, balance + 1),
//_ => Exp(src, idx, len + 1, balance)
//},
//};
//chars = next
//}
//Ok(("", state))
//}
//pub fn src (&self) -> &str {
//match self {
//Self::Nil => "",
//Self::Num(src, _, _) => src,
//Self::Sym(src, _, _) => src,
//Self::Key(src, _, _) => src,
//Self::Exp(src, _, _, _) => src,
//}
//}
//pub fn str (&self) -> &str {
//match self {
//Self::Nil => "",
//Self::Num(src, start, len) => &src[*start..start+len],
//Self::Sym(src, start, len) => &src[*start..start+len],
//Self::Key(src, start, len) => &src[*start..start+len],
//Self::Exp(src, start, len, 0) => &src[*start..(start+len)],
//Self::Exp(src, start, len, d) => panic!(
//"unclosed delimiter with depth {d} in:\n{}",
//&src[*start..(start+len)]
//)
//}
//}
//pub fn to_atom_ref (&'a self) -> Result<Atom<&'a str>, ParseError> {
//use Atom::*;
//Ok(match self {
//Token::Nil => Nil,
//Token::Num(_, _, _) => Num(Token::number(self.str())),
//Token::Sym(_, _, _) => Sym(self.str().into()),
//Token::Key(_, _, _) => Key(self.str().into()),
//Token::Exp(_, _, _, _) => Exp(match Atom::read_all_ref(self.str()) {
//Ok(exp) => exp,
//Err(e) => return Err(e)
//}),
//})
//}
//}
impl<'a> Display for ArcAtom {
fn fmt (&self, f: &mut Formatter<'_>) -> Result<(), FormatError> {
match self {
Self::Num(n) => write!(f, "{n}"),
Self::Sym(t) => write!(f, "{t}"),
Self::Key(t) => write!(f, "{t}"),
Self::Exp(u) => write!(f, "({})", join(u.iter().map(|i|format!("{}", &i)), " "))
}
}
}
/// Map EDN tokens to parameters of a given type for a given context
pub trait Context<'a, U>: Sized {
fn get (&'a self, _edn: &'a impl Atom<'a>) -> Option<U> {
None
}
fn get_or_fail (&'a self, edn: &'a impl Atom<'a>) -> U {
self.get(edn).expect("no value")
}
}
impl<'a, T: Context<'a, U>, U> Context<'a, U> for &T {
fn get (&'a self, edn: &'a impl Atom<'a>) -> Option<U> {
(*self).get(edn)
}
fn get_or_fail (&'a self, edn: &'a impl Atom<'a>) -> U {
(*self).get_or_fail(edn)
}
}
impl<'a, T: Context<'a, U>, U> Context<'a, U> for Option<T> {
fn get (&'a self, edn: &'a impl Atom<'a>) -> Option<U> {
self.as_ref().map(|s|s.get(edn)).flatten()
}
fn get_or_fail (&'a self, edn: &'a impl Atom<'a>) -> U {
self.as_ref().map(|s|s.get_or_fail(edn)).expect("no provider")
}
}
/// Implement `Context` 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> Context<'a, $type> for $State {
fn get (&'a $self, edn: &'a impl Atom<'a>) -> Option<$type> {
use RefAtom::*;
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> Context<$lt, $type> for $State {
fn get (&$lt $self, edn: &$lt impl Atom<'a>) -> Option<$type> {
use RefAtom::*;
Some(match edn.to_ref() { $(Sym($pat) => $expr,)* _ => return None })
}
}
};
}
/// Implement `Context` 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),* $(,)? }) => {
impl<'a, $T: $Trait> Context<'a, $type> for $T {
fn get (&'a $self, edn: &'a impl Atom<'a>) -> Option<$type> {
use RefAtom::*;
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),* $(,)? }) => {
impl<'a> Context<'a, $type> for $State {
fn get (&'a $self, edn: &'a impl Atom<'a>) -> Option<$type> {
use RefAtom::*;
Some(match edn.to_ref() { $(Sym($pat) => $expr,)* Num(n) => n as $type, _ => return None })
}
}
};
}
/// Implement `Context` 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> Context<'a, Box<dyn Render<E> + 'a>> for $State {
fn get (&'a $self, edn: &'a impl Atom<'a>) -> Option<Box<dyn Render<E> + 'a>> {
use RefAtom::*;
Some(match edn.to_ref() { $(RefAtom::Sym($pat) => $expr),*, _ => return None })
}
}
};
($Output:ty: |$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
impl<'a> Context<'a, Box<dyn Render<$Output> + 'a>> for $State {
fn get (&'a $self, edn: &'a impl Atom<'a>) -> Option<Box<dyn Render<$Output> + 'a>> {
use RefAtom::*;
Some(match edn.to_ref() { $(Sym($pat) => $expr),*, _ => return None })
}
}
}
}
pub trait TryFromEdn<'a, T>: Sized {
fn try_from_edn (state: &'a T, head: &impl Atom<'a>, tail: &'a [impl Atom<'a>]) ->
Option<Self>;
}
#[cfg(test)] #[test] fn test_edn_token () -> Result<(), Box<dyn std::error::Error>> {
use Token::*;
assert_eq!(Nil, Token::chomp_one("")?);
assert_eq!(Nil, Token::chomp_one(" \n \r \t ")?);
assert_eq!(Num("8", 0, 1), Token::chomp_one("8")?);
assert_eq!(Num(" 8 ", 3, 1), Token::chomp_one(" 8 ")?);
assert_eq!(Sym(":foo", 0, 4), Token::chomp_one(":foo")?);
assert_eq!(Sym("@bar", 0, 4), Token::chomp_one("@bar")?);
assert_eq!(Key("foo/bar", 0, 7), Token::chomp_one("foo/bar")?);
Ok(())
pub trait TryIntoEdn<'a, T>: Sized {
fn try_from_edn (state: &'a T, head: &impl Atom<'a>, tail: &'a [impl Atom<'a>]) ->
Option<Self>;
}

115
input/src/keymap.rs
View file

@ -1,46 +1,77 @@
use crate::*;
pub struct KeyMap<'a, T>(AtomIterator<'a>);
impl<'a, T> KeyMap<'a, T> {
pub const fn new (source: &'a str) -> Self {
Self(AtomIterator::new(TokenIterator::new(source)))
pub trait KeyMap {
/// Try to find a command that matches the currently pressed key
fn command <S, C: EdnCommand<S>> (&self, state: &S, input: &impl EdnInput) -> Option<C>;
}
pub struct SourceKeyMap<'a>(&'a str);
impl<'a> KeyMap for SourceKeyMap<'a> {
fn command <S, C: EdnCommand<S>> (&self, state: &S, input: &impl EdnInput) -> Option<C> {
todo!();
None
}
/// Try to find a binding matching the currently pressed key
pub fn command <S, C> (&self, state: &S, input: &impl EdnInput) -> Option<C>
where
C: Command<S> + EdnCommand<S>
{
use Atom::*;
let mut command: Option<C> = None;
match self {
Self::TokenIterator(t) => todo!(),
Self::TokenSlice(t) => todo!(),
Self::TokenVec(t) => todo!(),
//Self::AtomIterator(t) => todo!(),
Self::AtomSlice(t) => todo!(),
Self::Atom(t) => todo!(),
}
for item in self.0.iter() {
if let Exp(e) = item {
match e.as_slice() {
[Sym(key), c, args @ ..] if input.matches_edn(key) => {
command = C::from_edn(state, c, args);
if command.is_some() {
break
}
}
pub struct ParsedKeyMap<'a>(TokenIterator<'a>);
impl<'a> KeyMap for ParsedKeyMap<'a> {
fn command <S, C: EdnCommand<S>> (&self, state: &S, input: &impl EdnInput) -> Option<C> {
todo!();
None
}
}
pub struct RefKeyMap<'a>(TokenIterator<'a>);
impl<'a> KeyMap for RefKeyMap<'a> {
fn command <S, C: EdnCommand<S>> (&self, state: &S, input: &impl EdnInput) -> Option<C> {
todo!();
//for token in self.0 {
//match token?.kind() {
//TokenKind::Exp => match atoms.as_slice() {
//[key, command, args @ ..] => match (key.kind(), key.text()) {
//(TokenKind::Sym, key) => {
//if input.matches_edn(key) {
//let command = C::from_edn(state, command, args);
//if command.is_some() {
//return command
//}
//}
//},
//_ => panic!("invalid config: {item}")
//},
//_ => panic!("invalid config: {item}")
//}
//_ => panic!("invalid config: {item}")
//}
//}
None
}
}
pub struct ArcKeyMap(Vec<ArcAtom>);
impl<'a> KeyMap for ArcKeyMap {
fn command <S, C: EdnCommand<S>> (&self, state: &S, input: &impl EdnInput) -> Option<C> {
for atom in self.0.iter() {
match atom {
ArcAtom::Exp(atoms) => match atoms.as_slice() {
[key, command, args @ ..] => match (key.kind(), key.text()) {
(TokenKind::Sym, key) => {
if input.matches_edn(key) {
let command = C::from_edn(state, command, args);
if command.is_some() {
return command
}
}
},
_ => panic!("invalid config: {atom}")
},
_ => {}
_ => panic!("invalid config: {atom}")
}
} else {
panic!("invalid config")
_ => panic!("invalid config: {atom}")
}
}
command
None
}
}
/// [Input] state that can be matched against an [Atom].
pub trait EdnInput: Input {
fn matches_edn (&self, token: &str) -> bool;
fn get_event (_: &Atom<impl AsRef<str>>) -> Option<Self::Event> {
fn get_event <'a> (_: &impl Atom<'a>) -> Option<Self::Event> {
None
}
}
@ -48,8 +79,8 @@ pub trait EdnInput: Input {
pub trait EdnCommand<C>: Command<C> {
fn from_edn <'a> (
state: &C,
head: &Atom<impl AsRef<str>>,
tail: &'a [Atom<impl AsRef<str>>]
head: &impl Atom<'a>,
tail: &'a [impl Atom<'a>]
) -> Option<Self>;
}
/** Implement `EdnCommand` for given `State` and `Command` */
@ -78,8 +109,8 @@ pub trait EdnCommand<C>: Command<C> {
impl<$T: $Trait> EdnCommand<$T> for $Command {
fn from_edn <'a> (
$state: &$T,
head: &Atom<impl AsRef<str>>,
tail: &'a [Atom<impl AsRef<str>>]
head: &impl Atom,
tail: &'a [impl Atom]
) -> Option<Self> {
$(if let (Atom::Key($key), [ // if the identifier matches
// bind argument ids
@ -88,7 +119,7 @@ pub trait EdnCommand<C>: Command<C> {
$(, $rest @ ..)?
]) = (head.to_ref(), tail) {
$(
$(let $arg: Option<$type> = EdnProvide::<$type>::get($state, $arg);)?
$(let $arg: Option<$type> = Context::<$type>::get($state, $arg);)?
)*
//$(edn_command!(@bind $state => $arg $(?)? : $type);)*
return Some($command)
@ -121,8 +152,8 @@ pub trait EdnCommand<C>: Command<C> {
impl EdnCommand<$State> for $Command {
fn from_edn <'a> (
$state: &$State,
head: &Atom<impl AsRef<str>>,
tail: &'a [Atom<impl AsRef<str>>],
head: &impl Atom,
tail: &'a [impl Atom],
) -> Option<Self> {
$(if let (Atom::Key($key), [ // if the identifier matches
// bind argument ids
@ -131,7 +162,7 @@ pub trait EdnCommand<C>: Command<C> {
$(, $rest @ ..)?
]) = (head.to_ref(), tail) {
$(
$(let $arg: Option<$type> = EdnProvide::<$type>::get($state, $arg);)?
$(let $arg: Option<$type> = Context::<$type>::get($state, $arg);)?
)*
//$(edn_command!(@bind $state => $arg $(?)? : $type);)*
return Some($command)
@ -141,10 +172,10 @@ pub trait EdnCommand<C>: Command<C> {
}
};
(@bind $state:ident =>$arg:ident ? : $type:ty) => {
let $arg: Option<$type> = EdnProvide::<$type>::get($state, $arg);
let $arg: Option<$type> = Context::<$type>::get($state, $arg);
};
(@bind $state:ident => $arg:ident : $type:ty) => {
let $arg: $type = EdnProvide::<$type>::get_or_fail($state, $arg);
let $arg: $type = Context::<$type>::get_or_fail($state, $arg);
};
}
#[cfg(test)] #[test] fn test_edn_keymap () -> Usually<()> {

8
output/src/op_align.rs
View file

@ -1,4 +1,5 @@
use crate::*;
use RefAtom::*;
#[derive(Debug, Copy, Clone, Default)] pub enum Alignment { #[default] Center, X, Y, NW, N, NE, E, SE, S, SW, W }
pub struct Align<E, A>(PhantomData<E>, Alignment, A);
impl<E, A> Align<E, A> {
@ -44,13 +45,12 @@ impl<E: Output, A: Content<E>> Content<E> for Align<E, A> {
to.place(Content::layout(self, to.area()), &self.content())
}
}
impl<'a, E: Output + 'a, T: EdnViewData<'a, E>> TryFromEdn<'a, T> for Align<E, RenderBox<'a, E>> {
impl<'a, E: Output + 'a, T: ViewContext<'a, E>> TryFromEdn<'a, T> for Align<E, RenderBox<'a, E>> {
fn try_from_edn (
state: &'a T,
head: &Atom<impl AsRef<str>>,
tail: &'a [Atom<impl AsRef<str>>]
head: &impl Atom,
tail: &'a [impl Atom]
) -> Option<Self> {
use Atom::*;
Some(match (head.to_ref(), tail) {
(Key("align/c"), [a]) => Self::c(state.get_content(a).expect("no content")),
(Key("align/x"), [a]) => Self::x(state.get_content(a).expect("no content")),

6
output/src/op_bsp.rs
View file

@ -1,4 +1,5 @@
use crate::*;
use RefAtom::*;
pub use self::Direction::*;
/// A cardinal direction.
#[derive(Copy, Clone, PartialEq)]
@ -92,9 +93,8 @@ impl<E: Output, A: Content<E>, B: Content<E>> BspAreas<E, A, B> for Bsp<E, A, B>
fn direction (&self) -> Direction { self.1 }
fn contents (&self) -> (&A, &B) { (&self.2, &self.3) }
}
impl<'a, E: Output + 'a, T: EdnViewData<'a, E>> TryFromEdn<'a, T> for Bsp<E, RenderBox<'a, E>, RenderBox<'a, E>> {
fn try_from_edn (s: &'a T, head: &Atom<impl AsRef<str>>, tail: &'a [Atom<impl AsRef<str>>]) -> Option<Self> {
use Atom::*;
impl<'a, E: Output + 'a, T: ViewContext<'a, E>> TryFromEdn<'a, T> for Bsp<E, RenderBox<'a, E>, RenderBox<'a, E>> {
fn try_from_edn (s: &'a T, head: &impl Atom, tail: &'a [impl Atom]) -> Option<Self> {
Some(match (head.to_ref(), tail) {
(Key("bsp/n"), [a, b]) => Self::n(
s.get_content(a).expect("no south"),

11
output/src/op_cond.rs
View file

@ -1,4 +1,5 @@
use crate::*;
use RefAtom::*;
/// Show an item only when a condition is true.
pub struct When<E, A>(pub PhantomData<E>, pub bool, pub A);
impl<E, A> When<E, A> {
@ -6,11 +7,10 @@ impl<E, A> When<E, A> {
Self(Default::default(), c, a)
}
}
impl<'a, E: Output + 'a, T: EdnViewData<'a, E>> TryFromEdn<'a, T> for When<E, RenderBox<'a, E>> {
impl<'a, E: Output + 'a, T: ViewContext<'a, E>> TryFromEdn<'a, T> for When<E, RenderBox<'a, E>> {
fn try_from_edn (
state: &'a T, head: &Atom<impl AsRef<str>>, tail: &'a [Atom<impl AsRef<str>>]
state: &'a T, head: &impl Atom, tail: &'a [impl Atom]
) -> Option<Self> {
use Atom::*;
if let (Key("when"), [condition, content]) = (head.to_ref(), tail) {
Some(Self(
Default::default(),
@ -47,9 +47,8 @@ impl<E, A, B> Either<E, A, B> {
Self(Default::default(), c, a, b)
}
}
impl<'a, E: Output + 'a, T: EdnViewData<'a, E>> TryFromEdn<'a, T> for Either<E, RenderBox<'a, E>, RenderBox<'a, E>> {
fn try_from_edn (state: &'a T, head: &Atom<impl AsRef<str>>, tail: &'a [Atom<impl AsRef<str>>]) -> Option<Self> {
use Atom::*;
impl<'a, E: Output + 'a, T: ViewContext<'a, E>> TryFromEdn<'a, T> for Either<E, RenderBox<'a, E>, RenderBox<'a, E>> {
fn try_from_edn (state: &'a T, head: &impl Atom, tail: &'a [impl Atom]) -> Option<Self> {
if let (Key("either"), [condition, content, alternative]) = (head.to_ref(), tail) {
Some(Self::new(
state.get_bool(condition).expect("either: no condition"),

2
output/src/op_iter.rs
View file

@ -1,5 +1,5 @@
use crate::*;
use RefAtom::*;
pub fn map_south<O: Output>(
item_offset: O::Unit,
item_height: O::Unit,

11
output/src/op_transform.rs
View file

@ -1,4 +1,5 @@
use crate::*;
use RefAtom::*;
/// Defines an enum that transforms its content
/// along either the X axis, the Y axis, or both.
///
@ -26,11 +27,10 @@ macro_rules! transform_xy {
$area
}
}
impl<'a, E: Output + 'a, T: EdnViewData<'a, E>> TryFromEdn<'a, T> for $Enum<E, RenderBox<'a, E>> {
impl<'a, E: Output + 'a, T: ViewContext<'a, E>> TryFromEdn<'a, T> for $Enum<E, RenderBox<'a, E>> {
fn try_from_edn (
state: &'a T, head: &Atom<impl AsRef<str>>, tail: &'a [Atom<impl AsRef<str>>]
state: &'a T, head: &impl Atom, tail: &'a [impl Atom]
) -> Option<Self> {
use Atom::*;
Some(match (head.to_ref(), tail) {
(Key($x), [a]) => Self::x(state.get_content(a).expect("no content")),
(Key($y), [a]) => Self::y(state.get_content(a).expect("no content")),
@ -82,11 +82,10 @@ macro_rules! transform_xy_unit {
$layout.into()
}
}
impl<'a, E: Output + 'a, T: EdnViewData<'a, E>> TryFromEdn<'a, T> for $Enum<E, E::Unit, RenderBox<'a, E>> {
impl<'a, E: Output + 'a, T: ViewContext<'a, E>> TryFromEdn<'a, T> for $Enum<E, E::Unit, RenderBox<'a, E>> {
fn try_from_edn (
state: &'a T, head: &Atom<impl AsRef<str>>, tail: &'a [Atom<impl AsRef<str>>]
state: &'a T, head: &impl Atom, tail: &'a [impl Atom]
) -> Option<Self> {
use Atom::*;
Some(match (head.to_ref(), tail) {
(Key($x), [x, a]) => Self::x(
state.get_unit(x).expect("no x"),

67
output/src/view.rs
View file

@ -1,11 +1,10 @@
use crate::*;
use std::{sync::Arc, marker::PhantomData};
use Atom::*;
/// Define an EDN-backed view.
///
/// This consists of:
/// * render callback (implementation of [Content])
/// * value providers (implementations of [EdnProvide])
/// * value providers (implementations of [Context])
#[macro_export] macro_rules! edn_view {
($Output:ty: |$self:ident: $App:ty| $content:expr; {
$( $type:ty { $($sym:literal => $value:expr),* } );*
@ -14,19 +13,19 @@ use Atom::*;
fn content(&$self) -> impl Render<$Output> { $content }
}
$(
impl<'a> EdnProvide<'a, $type> for $App {
fn get (&'a $self, edn: &'a Atom<impl AsRef<str>>) -> Option<$type> {
impl<'a> Context<'a, $type> for $App {
fn get (&'a $self, edn: &'a impl Atom<'a>) -> Option<$type> {
Some(match edn.to_ref() { $(Atom::Sym($sym) => $value,)* _ => return None })
}
}
)*
}
}
/// Implements `EdnProvide` for content components and expressions
/// Implements `Context` for content components and 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 Atom<impl AsRef<str>>) -> Option<Box<dyn Render<E> + 'a>> {
impl<'a, E: Output> Context<'a, Box<dyn Render<E> + 'a>> for $State {
fn get (&'a $self, edn: &'a impl Atom<'a>) -> Option<Box<dyn Render<E> + 'a>> {
Some(match edn.to_ref() {
$(Atom::Sym($pat) => $expr),*,
_ => return None
@ -35,8 +34,8 @@ use Atom::*;
}
};
($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 Atom<impl AsRef<str>>) -> Option<Box<dyn Render<$Output> + 'a>> {
impl<'a> Context<'a, Box<dyn Render<$Output> + 'a>> for $State {
fn get (&'a $self, edn: &'a impl Atom<'a>) -> Option<Box<dyn Render<$Output> + 'a>> {
Some(match edn.to_ref() {
$(Atom::Sym($pat) => $expr),*,
_ => return None
@ -46,14 +45,14 @@ use Atom::*;
}
}
/// Renders from EDN source and context.
#[derive(Default)] pub enum EdnView<'a, E: Output, T: EdnViewData<'a, E> + std::fmt::Debug> {
#[derive(Default)] pub enum EdnView<'a, E: Output, T: ViewContext<'a, E> + std::fmt::Debug> {
#[default] Inert,
Ok(T, Atom<Arc<str>>),
//render: Box<dyn Fn(&'a T)->Box<dyn Render<E> + Send + Sync + 'a> + Send + Sync + 'a>
Err(String),
_Unused(PhantomData<&'a E>),
}
impl<'a, E: Output, T: EdnViewData<'a, E> + std::fmt::Debug> std::fmt::Debug for EdnView<'a, E, T> {
impl<'a, E: Output, T: ViewContext<'a, E> + std::fmt::Debug> std::fmt::Debug for EdnView<'a, E, T> {
fn fmt (&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
match self {
Self::Inert | Self::_Unused(_) =>
@ -66,24 +65,24 @@ impl<'a, E: Output, T: EdnViewData<'a, E> + std::fmt::Debug> std::fmt::Debug for
}
}
}
impl<'a, E: Output, T> EdnViewData<'a, E> for T where T:
EdnProvide<'a, bool> +
EdnProvide<'a, usize> +
EdnProvide<'a, E::Unit> +
EdnProvide<'a, Box<dyn Render<E> + 'a>>
impl<'a, E: Output, T> ViewContext<'a, E> for T where T:
Context<'a, bool> +
Context<'a, usize> +
Context<'a, E::Unit> +
Context<'a, Box<dyn Render<E> + 'a>>
{}
impl<'a, E: Output, T: EdnViewData<'a, E> + std::fmt::Debug> EdnView<'a, E, T> {
impl<'a, E: Output, T: ViewContext<'a, E> + std::fmt::Debug> EdnView<'a, E, T> {
pub fn from_source (state: T, source: &'a str) -> Self {
match Atom::read_one(&source) {
Ok((layout, _)) => Self::Ok(state, layout),
Err(error) => Self::Err(format!("{error} in {source}"))
}
}
pub fn from_items (state: T, items: Vec<Atom<impl AsRef<str>>>) -> Self {
pub fn from_items (state: T, items: Vec<impl Atom<'a>>) -> Self {
Self::Ok(state, Atom::Exp(items).to_arc())
}
}
impl<E: Output, T: for<'a>EdnViewData<'a, E> + Send + Sync + std::fmt::Debug> Content<E> for EdnView<'_, E, T> {
impl<E: Output, T: for<'a>ViewContext<'a, E> + Send + Sync + std::fmt::Debug> Content<E> for EdnView<'_, E, T> {
fn content (&self) -> impl Render<E> {
match self {
Self::Ok(state, layout) => state.get_content(layout),
@ -107,31 +106,31 @@ macro_rules! edn_try_delegate {
}
/// Provides values to the template
pub trait EdnViewData<'a, E: Output>:
EdnProvide<'a, bool> +
EdnProvide<'a, usize> +
EdnProvide<'a, E::Unit> +
EdnProvide<'a, Box<dyn Render<E> + 'a>>
pub trait ViewContext<'a, E: Output>:
Context<'a, bool> +
Context<'a, usize> +
Context<'a, E::Unit> +
Context<'a, Box<dyn Render<E> + 'a>>
{
fn get_bool (&'a self, item: &'a Atom<impl AsRef<str>>) -> Option<bool> {
fn get_bool (&'a self, item: &'a impl Atom<'a>) -> Option<bool> {
Some(match &item {
Sym(s) => match s.as_ref() {
":false" | ":f" => false,
":true" | ":t" => true,
_ => return EdnProvide::get(self, item)
_ => return Context::get(self, item)
},
Num(0) => false,
Num(_) => true,
_ => return EdnProvide::get(self, item)
_ => return Context::get(self, item)
})
}
fn get_usize (&'a self, item: &'a Atom<impl AsRef<str>>) -> Option<usize> {
Some(match &item { Num(n) => *n, _ => return EdnProvide::get(self, item) })
fn get_usize (&'a self, item: &'a impl Atom<'a>) -> Option<usize> {
Some(match &item { Num(n) => *n, _ => return Context::get(self, item) })
}
fn get_unit (&'a self, item: &'a Atom<impl AsRef<str>>) -> Option<E::Unit> {
Some(match &item { Num(n) => (*n as u16).into(), _ => return EdnProvide::get(self, item) })
fn get_unit (&'a self, item: &'a impl Atom<'a>) -> Option<E::Unit> {
Some(match &item { Num(n) => (*n as u16).into(), _ => return Context::get(self, item) })
}
fn get_content (&'a self, item: &'a Atom<impl AsRef<str>>) -> Option<Box<dyn Render<E> + 'a>> where E: 'a {
fn get_content (&'a self, item: &'a impl Atom<'a>) -> Option<Box<dyn Render<E> + 'a>> where E: 'a {
Some(match item {
Nil => Box::new(()),
Exp(ref e) => {
@ -149,9 +148,9 @@ pub trait EdnViewData<'a, E: Output>:
edn_try_delegate!(self, e, Pull::<_, _, RenderBox<'a, E>>);
edn_try_delegate!(self, e, Margin::<_, _, RenderBox<'a, E>>);
edn_try_delegate!(self, e, Padding::<_, _, RenderBox<'a, E>>);
EdnProvide::get_or_fail(self, &item)
Context::get_or_fail(self, &item)
},
_ => EdnProvide::get_or_fail(self, &item)
_ => Context::get_or_fail(self, &item)
})
//panic!("no content")
}