unspeaker/tengri
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tengri.git synced 2025-12-06 03:36:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

read explicit lifetime to FromDsl
Some checks are pending
/ build (push) Waiting to run
Details

Browse source
This commit is contained in:
🪞👃🪞 2025-05-20 22:02:51 +03:00
parent 7c1cddc759
commit 455d6d00d5
14 changed files with 252 additions and 286 deletions
Download patch file Download diff file Expand all files Collapse all files

45
dsl/src/dsl_provide.rs
View file

@ -18,10 +18,10 @@ pub trait Dsl<Other>: Sized {
}
}
}
pub trait FromDsl<State>: Sized {
fn take_from <'state, 'source: 'state> (state: &'state State, token: &mut TokenIter<'source>)
pub trait FromDsl<'source, State>: Sized {
fn take_from <'state> (state: &'state State, token: &mut TokenIter<'source>)
-> Perhaps<Self>;
fn take_from_or_fail <'state, 'source: 'state> (
fn take_from_or_fail <'state> (
state: &'state State,
token: &mut TokenIter<'source>,
error: impl Into<Box<dyn std::error::Error>>
@ -33,13 +33,6 @@ pub trait FromDsl<State>: Sized {
}
}
}
impl<T: FromDsl<State>, State> Dsl<T> for State {
fn take <'state, 'source: 'state> (&'state self, token: &mut TokenIter<'source>)
-> Perhaps<T>
{
FromDsl::take_from(self, token)
}
}
//impl<State: Dsl<T>, T> FromDsl<State> for T {
//fn take_from <'state, 'source: 'state> (state: &'state State, token: &mut TokenIter<'source>)
//-> Perhaps<Self>
@ -51,16 +44,36 @@ impl<T: FromDsl<State>, State> Dsl<T> for State {
/// Implement the [Dsl] trait, which boils down to
/// specifying two types and providing an expression.
#[macro_export] macro_rules! from_dsl {
($T:ty: |$state:ident:$S:ty, $words:ident|$expr:expr) => {
impl ::tengri::dsl::FromDsl<$S> for $T {
fn take_from <'state, 'source: 'state> (
$state: &'state $S,
$words: &mut ::tengri::dsl::TokenIter<'source>,
) -> ::tengri::Perhaps<$T> {
(@a: $T:ty: |$state:ident, $words:ident|$expr:expr) => {
impl<'source, State: Dsl<A>, A> FromDsl<'source, State> for $T {
fn take_from <'state> (
$state: &'state State,
$words: &mut TokenIter<'source>,
) -> Perhaps<$T> {
$expr
}
}
};
(@ab: $T:ty: |$state:ident, $words:ident|$expr:expr) => {
impl<'source, State: Dsl<A> + Dsl<B>, A, B> FromDsl<'source, State> for $T {
fn take_from <'state> (
$state: &'state State,
$words: &mut TokenIter<'source>,
) -> Perhaps<$T> {
$expr
}
}
};
($T:ty: |$state:ident:$S:ty, $words:ident|$expr:expr) => {
impl<'source> FromDsl<'source, $S> for $T {
fn take_from <'state> (
$state: &'state $S,
$words: &mut TokenIter<'source>,
) -> Perhaps<$T> {
$expr
}
}
};
}
///// Maps a sequencer of EDN tokens to parameters of supported types

64
input/src/input_dsl.rs
View file

@ -5,13 +5,15 @@ use std::marker::PhantomData;
pub trait DslInput: Input { fn matches_dsl (&self, token: &str) -> bool; }
/// A pre-configured mapping of input events to commands.
pub trait KeyMap<S: Dsl<C>, C: Command<S>, I: DslInput> {
pub trait KeyMap<'source, S, C: FromDsl<'source, S> + Command<S>, I: DslInput> {
/// Try to find a command that matches the current input event.
fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C>;
}
/// A [SourceIter] can be a [KeyMap].
impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for SourceIter<'source> {
impl<'source, S, C: FromDsl<'source, S> + Command<S>, I: DslInput>
KeyMap<'source, S, C, I>
for SourceIter<'source> {
fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
let mut iter = self.clone();
while let Some((token, rest)) = iter.next() {
@ -22,7 +24,7 @@ impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for SourceI
match exp_iter.next() {
Some(Token { value: Value::Sym(binding), .. }) => {
if input.matches_dsl(binding) {
if let Some(command) = state.take(&mut exp_iter)? {
if let Some(command) = FromDsl::take_from(state, &mut exp_iter)? {
return Ok(Some(command))
}
}
@ -38,7 +40,9 @@ impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for SourceI
}
/// A [TokenIter] can be a [KeyMap].
impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for TokenIter<'source> {
impl<'source, S, C: FromDsl<'source, S> + Command<S>, I: DslInput>
KeyMap<'source, S, C, I>
for TokenIter<'source> {
fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
let mut iter = self.clone();
while let Some(next) = iter.next() {
@ -48,7 +52,7 @@ impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for TokenIt
match e.next() {
Some(Token { value: Value::Sym(binding), .. }) => {
if input.matches_dsl(binding) {
if let Some(command) = state.take(&mut e)? {
if let Some(command) = FromDsl::take_from(state, &mut e)? {
return Ok(Some(command))
}
}
@ -63,25 +67,37 @@ impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for TokenIt
}
}
pub type InputLayerCond<S> = Box<dyn Fn(&S)->Usually<bool> + Send + Sync>;
pub type InputLayerCond<'source, S> = Box<dyn Fn(&S)->Usually<bool> + 'source>;
/// A collection of pre-configured mappings of input events to commands,
/// which may be made available subject to given conditions.
pub struct InputMap<S, C, I, M>
where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
__: PhantomData<(S, C, I)>,
pub layers: Vec<(InputLayerCond<S>, M)>,
pub struct InputMap<'source,
S,
C: Command<S> + FromDsl<'source, S>,
I: DslInput,
M: KeyMap<'source, S, C, I>
> {
__: PhantomData<&'source (S, C, I)>,
pub layers: Vec<(InputLayerCond<'source, S>, M)>,
}
impl<S, C, I, M> Default for InputMap<S, C, I, M>
where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
impl<'source,
S,
C: Command<S> + FromDsl<'source, S>,
I: DslInput,
M: KeyMap<'source, S, C, I>
> Default for InputMap<'source, S, C, I, M>{
fn default () -> Self {
Self { __: PhantomData, layers: vec![] }
}
}
impl<S: 'static, C, I, M> InputMap<S, C, I, M>
where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
impl<'source,
S,
C: Command<S> + FromDsl<'source, S>,
I: DslInput,
M: KeyMap<'source, S, C, I>
> InputMap<'source, S, C, I, M> {
pub fn new (keymap: M) -> Self {
Self::default().layer(keymap)
}
@ -93,26 +109,34 @@ where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
self.add_layer_if(Box::new(|_|Ok(true)), keymap);
self
}
pub fn layer_if (mut self, condition: InputLayerCond<S>, keymap: M) -> Self {
pub fn layer_if (mut self, condition: InputLayerCond<'source, S>, keymap: M) -> Self {
self.add_layer_if(condition, keymap);
self
}
pub fn add_layer_if (&mut self, condition: InputLayerCond<S>, keymap: M) -> &mut Self {
pub fn add_layer_if (&mut self, condition: InputLayerCond<'source, S>, keymap: M) -> &mut Self {
self.layers.push((Box::new(condition), keymap));
self
}
}
impl<S, C, I, M> std::fmt::Debug for InputMap<S, C, I, M>
where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
impl<'source,
S,
C: Command<S> + FromDsl<'source, S>,
I: DslInput,
M: KeyMap<'source, S, C, I>
> std::fmt::Debug for InputMap<'source, S, C, I, M> {
fn fmt (&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
write!(f, "[InputMap: {} layer(s)]", self.layers.len())
}
}
/// An [InputMap] can be a [KeyMap].
impl<S, C, I, M> KeyMap<S, C, I> for InputMap<S, C, I, M>
where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
impl<'source,
S,
C: Command<S> + FromDsl<'source, S>,
I: DslInput,
M: KeyMap<'source, S, C, I>
> KeyMap<'source, S, C, I> for InputMap<'source, S, C, I, M> {
fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
for (condition, keymap) in self.layers.iter() {
if !condition(state)? {

4
input/src/input_handle.rs
View file

@ -2,7 +2,7 @@ use crate::*;
use std::sync::{Mutex, Arc, RwLock};
/// Event source
pub trait Input: Send + Sync + Sized {
pub trait Input: Sized {
/// Type of input event
type Event;
/// Result of handling input
@ -36,7 +36,7 @@ pub trait Input: Send + Sync + Sized {
}
/// Handle input
pub trait Handle<E: Input>: Send + Sync {
pub trait Handle<E: Input> {
fn handle (&mut self, _input: &E) -> Perhaps<E::Handled> {
Ok(None)
}

14
output/src/ops/align.rs
View file

@ -36,11 +36,7 @@ pub enum Alignment { #[default] Center, X, Y, NW, N, NE, E, SE, S, SW, W }
pub struct Align<A>(Alignment, A);
#[cfg(feature = "dsl")]
impl<State: Dsl<A>, A> FromDsl<State> for Align<A> {
fn take_from <'state, 'source: 'state> (state: &'state State, iter: &mut TokenIter<'source>)
-> Perhaps<Self>
{
if let Some(Token { value: Value::Key(key), .. }) = iter.peek() {
from_dsl!(@a: Align<A>: |state, iter|if let Some(Token { value: Value::Key(key), .. }) = iter.peek() {
match key {
"align/c"|"align/x"|"align/y"|
"align/n"|"align/s"|"align/e"|"align/w"|
@ -64,11 +60,9 @@ impl<State: Dsl<A>, A> FromDsl<State> for Align<A> {
},
_ => return Ok(None)
}
} else {
} else {
Ok(None)
}
}
}
});
impl<A> Align<A> {
#[inline] pub const fn c (a: A) -> Self { Self(Alignment::Center, a) }
@ -85,7 +79,7 @@ impl<A> Align<A> {
}
impl<E: Output, A: Content<E>> Content<E> for Align<A> {
fn content (&self) -> impl Render<E> {
fn content (&self) -> impl Render<E> + '_ {
&self.1
}
fn layout (&self, on: E::Area) -> E::Area {

12
output/src/ops/bsp.rs
View file

@ -21,12 +21,10 @@ impl<E: Output, A: Content<E>, B: Content<E>> Content<E> for Bsp<A, B> {
}
}
#[cfg(feature = "dsl")]
impl<A, B, T: Dsl<A> + Dsl<B>> FromDsl<T> for Bsp<A, B> {
fn take_from <'state, 'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
Ok(if let Some(Token {
from_dsl!(@ab: Bsp<A, B>: |state, iter|Ok(if let Some(Token {
value: Value::Key("bsp/n"|"bsp/s"|"bsp/e"|"bsp/w"|"bsp/a"|"bsp/b"),
..
}) = iter.peek() {
}) = iter.peek() {
let base = iter.clone();
return Ok(Some(match iter.next() {
Some(Token { value: Value::Key("bsp/n"), .. }) =>
@ -49,11 +47,9 @@ impl<A, B, T: Dsl<A> + Dsl<B>> FromDsl<T> for Bsp<A, B> {
state.take_or_fail(iter, "expected content 2")?),
_ => unreachable!(),
}))
} else {
} else {
None
})
}
}
}));
impl<A, B> Bsp<A, B> {
#[inline] pub const fn n (a: A, b: B) -> Self { Self(North, a, b) }
#[inline] pub const fn s (a: A, b: B) -> Self { Self(South, a, b) }

8
output/src/ops/cond.rs
View file

@ -18,8 +18,8 @@ impl<A, B> Either<A, B> {
}
}
#[cfg(feature = "dsl")]
impl<A, T: Dsl<bool> + Dsl<A>> FromDsl<T> for When<A> {
fn take_from <'state, 'source: 'state> (
impl<'source, A, T: Dsl<bool> + Dsl<A>> FromDsl<'source, T> for When<A> {
fn take_from <'state> (
state: &'state T,
token: &mut TokenIter<'source>
) -> Perhaps<Self> {
@ -56,8 +56,8 @@ impl<E: Output, A: Render<E>> Content<E> for When<A> {
}
}
#[cfg(feature = "dsl")]
impl<A, B, T: Dsl<bool> + Dsl<A> + Dsl<B>> FromDsl<T> for Either<A, B> {
fn take_from <'state, 'source: 'state> (
impl<'source, A, B, T: Dsl<bool> + Dsl<A> + Dsl<B>> FromDsl<'source, T> for Either<A, B> {
fn take_from <'state> (
state: &'state T,
token: &mut TokenIter<'source>
) -> Perhaps<Self> {

47
output/src/ops/thunk.rs
View file

@ -2,72 +2,67 @@ use crate::*;
use std::marker::PhantomData;
/// Lazily-evaluated [Render]able.
pub struct Thunk<E: Output, T: Render<E>, F: Fn()->T + Send + Sync>(
pub struct Thunk<E: Output, T: Render<E>, F: Fn()->T>(
PhantomData<E>,
F
);
impl<E: Output, T: Render<E>, F: Fn()->T + Send + Sync> Thunk<E, T, F> {
impl<E: Output, T: Render<E>, F: Fn()->T> Thunk<E, T, F> {
pub const fn new (thunk: F) -> Self {
Self(PhantomData, thunk)
}
}
impl<E: Output, T: Render<E>, F: Fn()->T + Send + Sync> Content<E> for Thunk<E, T, F> {
impl<E: Output, T: Render<E>, F: Fn()->T> Content<E> for Thunk<E, T, F> {
fn content (&self) -> impl Render<E> { (self.1)() }
}
pub struct ThunkBox<'a, E: Output>(
pub struct ThunkBox<E: Output>(
PhantomData<E>,
Box<dyn Fn()->RenderBox<'a, E> + Send + Sync + 'a>
Box<dyn Fn()->Box<dyn Render<E>>>,
);
impl<'a, E: Output> ThunkBox<'a, E> {
pub const fn new (thunk: Box<dyn Fn()->RenderBox<'a, E> + Send + Sync + 'a>) -> Self {
impl<E: Output> ThunkBox<E> {
pub const fn new (thunk: Box<dyn Fn()->Box<dyn Render<E>>>) -> Self {
Self(PhantomData, thunk)
}
}
impl<'a, E: Output> Content<E> for ThunkBox<'a, E> {
fn content (&self) -> impl Render<E> { (self.1)() }
impl<E: Output> Content<E> for ThunkBox<E> {
fn content (&self) -> impl Render<E> { (&self.1)() }
}
impl<'a, E, F, T> From<F> for ThunkBox<'a, E>
where
E: Output,
F: Fn()->T + Send + Sync + 'a,
T: Render<E> + Send + Sync + 'a
{
fn from (f: F) -> Self {
Self(PhantomData, Box::new(move||f().boxed()))
impl<E: Output> From<Box<dyn Fn()->Box<dyn Render<E>>>> for ThunkBox<E> {
fn from (f: Box<dyn Fn()->Box<dyn Render<E>>>) -> Self {
Self(PhantomData, f)
}
}
//impl<'a, E: Output, F: Fn()->Box<dyn Render<E> + 'a> + Send + Sync + 'a> From<F> for ThunkBox<'a, E> {
//impl<'a, E: Output, F: Fn()->Box<dyn Render<E> + 'a> + 'a> From<F> for ThunkBox<'a, E> {
//fn from (f: F) -> Self {
//Self(Default::default(), Box::new(f))
//}
//}
pub struct ThunkRender<E: Output, F: Fn(&mut E) + Send + Sync>(PhantomData<E>, F);
impl<E: Output, F: Fn(&mut E) + Send + Sync> ThunkRender<E, F> {
pub struct ThunkRender<E: Output, F: Fn(&mut E)>(PhantomData<E>, F);
impl<E: Output, F: Fn(&mut E)> ThunkRender<E, F> {
pub fn new (render: F) -> Self { Self(PhantomData, render) }
}
impl<E: Output, F: Fn(&mut E) + Send + Sync> Content<E> for ThunkRender<E, F> {
impl<E: Output, F: Fn(&mut E)> Content<E> for ThunkRender<E, F> {
fn render (&self, to: &mut E) { (self.1)(to) }
}
pub struct ThunkLayout<
E: Output,
F1: Fn(E::Area)->E::Area + Send + Sync,
F2: Fn(&mut E) + Send + Sync
F1: Fn(E::Area)->E::Area,
F2: Fn(&mut E)
>(
PhantomData<E>,
F1,
F2
);
impl<E: Output, F1: Fn(E::Area)->E::Area + Send + Sync, F2: Fn(&mut E) + Send + Sync> ThunkLayout<E, F1, F2> {
impl<E: Output, F1: Fn(E::Area)->E::Area, F2: Fn(&mut E)> ThunkLayout<E, F1, F2> {
pub fn new (layout: F1, render: F2) -> Self { Self(PhantomData, layout, render) }
}
impl<E, F1, F2> Content<E> for ThunkLayout<E, F1, F2>
where
E: Output,
F1: Fn(E::Area)->E::Area + Send + Sync,
F2: Fn(&mut E) + Send + Sync
F1: Fn(E::Area)->E::Area,
F2: Fn(&mut E)
{
fn layout (&self, to: E::Area) -> E::Area { (self.1)(to) }
fn render (&self, to: &mut E) { (self.2)(to) }

12
output/src/ops/transform.rs
View file

@ -33,8 +33,8 @@ macro_rules! transform_xy {
#[inline] pub const fn xy (item: A) -> Self { Self::XY(item) }
}
#[cfg(feature = "dsl")]
impl<A, T: Dsl<A>> FromDsl<T> for $Enum<A> {
fn take_from <'state, 'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
impl<'source, A, T: Dsl<A>> FromDsl<'source, T> for $Enum<A> {
fn take_from <'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
if let Some(Token { value: Value::Key(k), .. }) = iter.peek() {
let mut base = iter.clone();
return Ok(Some(match iter.next() {
@ -51,7 +51,7 @@ macro_rules! transform_xy {
}
}
impl<E: Output, T: Content<E>> Content<E> for $Enum<T> {
fn content (&self) -> impl Render<E> {
fn content (&self) -> impl Render<E> + '_ {
match self {
Self::X(item) => item,
Self::Y(item) => item,
@ -77,8 +77,8 @@ macro_rules! transform_xy_unit {
#[inline] pub const fn xy (x: U, y: U, item: A) -> Self { Self::XY(x, y, item) }
}
#[cfg(feature = "dsl")]
impl<A, U: Coordinate, T: Dsl<A> + Dsl<U>> FromDsl<T> for $Enum<U, A> {
fn take_from <'state, 'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
impl<'source, A, U: Coordinate, T: Dsl<A> + Dsl<U>> FromDsl<'source, T> for $Enum<U, A> {
fn take_from <'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
Ok(if let Some(Token { value: Value::Key($x|$y|$xy), .. }) = iter.peek() {
let mut base = iter.clone();
Some(match iter.next() {
@ -103,7 +103,7 @@ macro_rules! transform_xy_unit {
}
}
impl<E: Output, T: Content<E>> Content<E> for $Enum<E::Unit, T> {
fn content (&self) -> impl Render<E> {
fn content (&self) -> impl Render<E> + '_ {
Some(match self {
Self::X(_, content) => content,
Self::Y(_, content) => content,

26
output/src/output.rs
View file

@ -29,8 +29,8 @@ pub trait Render<E: Output> {
/// Write data to display.
fn render (&self, output: &mut E);
/// Perform type erasure, turning `self` into an opaque [RenderBox].
fn boxed <'a> (self) -> RenderBox<'a, E> where Self: Send + Sync + Sized + 'a {
Box::new(self) as RenderBox<'a, E>
fn boxed <'a> (self) -> Box<dyn Render<E> + 'a> where Self: Sized + 'a {
Box::new(self) as Box<dyn Render<E> + 'a>
}
}
@ -47,20 +47,20 @@ impl<E: Output, C: Content<E>> Render<E> for C {
/// Opaque pointer to a renderable living on the heap.
///
/// Return this from [Content::content] to use dynamic dispatch.
pub type RenderBox<'a, E> = Box<RenderDyn<'a, E>>;
pub type RenderBox<E> = Box<RenderDyn<E>>;
/// You can render from a box.
impl<'a, E: Output> Content<E> for RenderBox<'a, E> {
fn content (&self) -> impl Render<E> { self.deref() }
impl<E: Output> Content<E> for RenderBox<E> {
fn content (&self) -> impl Render<E> + '_ { self.deref() }
//fn boxed <'b> (self) -> RenderBox<'b, E> where Self: Sized + 'b { self }
}
/// Opaque pointer to a renderable.
pub type RenderDyn<'a, E> = dyn Render<E> + Send + Sync + 'a;
pub type RenderDyn<E> = dyn Render<E>;
/// You can render from an opaque pointer.
impl<'a, E: Output> Content<E> for &RenderDyn<'a, E> where Self: Sized {
fn content (&self) -> impl Render<E> {
impl<E: Output> Content<E> for &RenderDyn<E> where Self: Sized {
fn content (&self) -> impl Render<E> + '_ {
#[allow(suspicious_double_ref_op)]
self.deref()
}
@ -77,7 +77,7 @@ impl<'a, E: Output> Content<E> for &RenderDyn<'a, E> where Self: Sized {
/// Composable renderable with static dispatch.
pub trait Content<E: Output> {
/// Return a [Render]able of a specific type.
fn content (&self) -> impl Render<E> { () }
fn content (&self) -> impl Render<E> + '_ { () }
/// Perform layout. By default, delegates to [Self::content].
fn layout (&self, area: E::Area) -> E::Area { self.content().layout(area) }
/// Draw to output. By default, delegates to [Self::content].
@ -86,7 +86,7 @@ pub trait Content<E: Output> {
/// Every pointer to [Content] is a [Content].
impl<E: Output, C: Content<E>> Content<E> for &C {
fn content (&self) -> impl Render<E> { (*self).content() }
fn content (&self) -> impl Render<E> + '_ { (*self).content() }
fn layout (&self, area: E::Area) -> E::Area { (*self).layout(area) }
fn render (&self, output: &mut E) { (*self).render(output) }
}
@ -98,7 +98,7 @@ impl<E: Output> Content<E> for () {
}
impl<E: Output, T: Content<E>> Content<E> for Option<T> {
fn content (&self) -> impl Render<E> {
fn content (&self) -> impl Render<E> + '_ {
self.as_ref()
}
fn layout (&self, area: E::Area) -> E::Area {
@ -117,7 +117,7 @@ impl<E: Output, T: Content<E>> Content<E> for Option<T> {
// Implement for all [Output]s.
(|$self:ident:$Struct:ty| $content:expr) => {
impl<E: Output> Content<E> for $Struct {
fn content (&$self) -> impl Render<E> { Some($content) }
fn content (&$self) -> impl Render<E> + '_ { Some($content) }
}
};
// Implement for specific [Output].
@ -127,7 +127,7 @@ impl<E: Output, T: Content<E>> Content<E> for Option<T> {
|$content:expr) => {
impl $(<$($($L)? $($T)? $(:$Trait)?),+>)? Content<$Output>
for $Struct $(<$($($L)? $($T)?),+>)? {
fn content (&$self) -> impl Render<$Output> { $content }
fn content (&$self) -> impl Render<$Output> + '_ { $content }
}
};
}

17
proc/src/proc_command.rs
View file

@ -84,7 +84,7 @@ impl ToTokens for CommandDef {
let mut out = TokenStream2::new();
for (arg, ty) in arm.args() {
write_quote_to(&mut out, quote! {
#arg: Dsl::take_or_fail(self, words)?,
#arg: FromDsl::take_from_or_fail(self, words)?,
});
}
out
@ -137,17 +137,22 @@ impl ToTokens for CommandDef {
#[derive(Clone, Debug)] pub enum #command_enum { #(#variants)* }
/// Not generated by [tengri_proc].
#block
/// Generated by [tengri_proc].
/// Generated by [tengri_proc::command].
///
/// Means [#command_enum] is now a [Command] over [#state].
/// Instances of [#command_enum] can be consumed by a
/// mutable pointer to [#state], invoking predefined operations
/// and optionally returning undo history data.
impl ::tengri::input::Command<#state> for #command_enum {
fn execute (self, state: &mut #state) -> Perhaps<Self> {
match self { #(#implementations)* }
}
}
/// Generated by [tengri_proc].
impl ::tengri::dsl::FromDsl<#state> for #command_enum {
fn take_from <'state, 'source: 'state> (
/// Generated by [tengri_proc::command].
impl<'source> ::tengri::dsl::FromDsl<'source, #state> for #command_enum {
fn take_from <'state> (
state: &'state #state,
words: &mut TokenIter<'source>,
words: &mut ::tengri::dsl::TokenIter<'source>
) -> Perhaps<Self> {
let mut words = words.clone();
let token = words.next();

16
proc/src/proc_expose.rs
View file

@ -60,7 +60,7 @@ impl ToTokens for ExposeDef {
impl ToTokens for ExposeImpl {
fn to_tokens (&self, out: &mut TokenStream2) {
let Self(block, exposed) = self;
let exposed_impl_type = &block.self_ty;
let state = &block.self_ty;
write_quote_to(out, quote! { #block });
for (t, variants) in exposed.iter() {
let formatted_type = format!("{}", quote! { #t });
@ -84,15 +84,15 @@ impl ToTokens for ExposeImpl {
};
let values = variants.iter().map(ExposeArm::from);
write_quote_to(out, quote! {
/// Generated by [tengriproc].
impl ::tengri::dsl::Dsl<#t> for #exposed_impl_type {
fn take <'state, 'source: 'state> (
&'state self,
/// Generated by [tengri_proc::expose].
impl<'source> ::tengri::dsl::FromDsl<'source, #state> for #t {
fn take_from <'state> (
state: &'state #state,
words: &mut ::tengri::dsl::TokenIter<'source>
) -> Perhaps<#t> {
) -> Perhaps<Self> {
Ok(Some(match words.next().map(|x|x.value) {
#predefined
#(#values,)*
#(#values)*
_ => return Ok(None)
}))
}
@ -116,7 +116,7 @@ impl ToTokens for ExposeArm {
let Self(key, value) = self;
let key = LitStr::new(&key, Span::call_site());
write_quote_to(out, quote! {
Some(::tengri::dsl::Value::Sym(#key)) => self.#value()
Some(::tengri::dsl::Value::Sym(#key)) => state.#value(),
})
}
}

170
proc/src/proc_view.rs
View file

@ -14,8 +14,6 @@ pub(crate) struct ViewImpl {
exposed: BTreeMap<String, Ident>,
}
struct ViewArm(String, Ident);
impl Parse for ViewMeta {
fn parse (input: ParseStream) -> Result<Self> {
Ok(Self {
@ -41,6 +39,60 @@ impl Parse for ViewImpl {
}
}
impl ToTokens for ViewDef {
fn to_tokens (&self, out: &mut TokenStream2) {
let Self(ViewMeta { output }, ViewImpl { block, exposed }) = self;
let view = &block.self_ty;
let mut available = vec![];
let exposed: Vec<_> = exposed.iter().map(|(key, value)|{
available.push(key.clone());
write_quote(quote! { #key => Some(state.#value().boxed()), })
}).collect();
let available: String = available.join(", ");
let error_msg = LitStr::new(
&format!("expected Sym(content), got: {{token:?}}, available: {available}"),
Span::call_site()
);
write_quote_to(out, quote! {
#block
/// Generated by [tengri_proc].
///
/// Delegates the rendering of [#view] to the [#view::view} method,
/// which you will need to implement, e.g. passing a [TokenIter]
/// containing a layout and keybindings config from user dirs.
impl ::tengri::output::Content<#output> for #view {
fn content (&self) -> impl Render<#output> {
self.view()
}
}
/// Generated by [tengri_proc].
///
/// Gives [#view] the ability to construct the [Render]able
/// which might corresponds to a given [TokenStream],
/// while taking [#view]'s state into consideration.
impl<'source> ::tengri::dsl::FromDsl<'source, #view> for Box<dyn Render<#output> + 'source> {
fn take_from <'state> (
state: &'state #view,
words: &mut ::tengri::dsl::TokenIter<'source>,
) -> Perhaps<Self> {
Ok(words.peek().and_then(|::tengri::dsl::Token{ value, .. }|match value {
::tengri::dsl::Value::Exp(_, exp) => {
todo!("builtin layout ops");
//#builtins
None
},
::tengri::dsl::Value::Sym(sym) => match sym {
#(#exposed)*
_ => None
},
_ => None
}))
}
}
})
}
}
fn builtins () -> [TokenStream2;14] {
[
quote! { When::<A> },
@ -59,117 +111,3 @@ fn builtins () -> [TokenStream2;14] {
quote! { Padding::<_, A> },
]
}
impl ToTokens for ViewDef {
fn to_tokens (&self, out: &mut TokenStream2) {
let Self(ViewMeta { output }, ViewImpl { block, exposed }) = self;
let view = &block.self_ty;
let mut available = vec![];
let exposed: Vec<_> = exposed.iter()
.map(|(k,v)|{ available.push(k.clone()); ViewArm(k.clone(), v.clone()) })
.collect();
let available: String = available.join(", ");
let error_msg = LitStr::new(
&format!("expected Sym(content), got: {{token:?}}, available: {available}"),
Span::call_site()
);
for token in quote! {
#block
/// Generated by [tengri_proc].
///
/// Delegates the rendering of [#view] to the [#view::view} method,
/// which you will need to implement, e.g. passing a [TokenIter]
/// containing a layout and keybindings config from user dirs.
impl ::tengri::output::Content<#output> for #view {
fn content (&self) -> impl Render<#output> {
self.view()
}
}
/// Generated by [tengri_proc].
///
/// Gives [#view] the ability to construct the [Render]able
/// which might corresponds to a given [TokenStream],
/// while taking [#view]'s state into consideration.
impl<'context> ::tengri::dsl::FromDsl<#view> for RenderBox<'context, #output> {
fn take_from <'state, 'source: 'state> (
state: &'state #view, words: &mut ::tengri::dsl::TokenIter<'source>
) -> Perhaps<Self> {
Ok(match words.peek() {
Some(::tengri::dsl::Token { value: ::tengri::dsl::Value::Exp(exp), .. }) => {
if let Some(value) = FromDsl::take_from(state, words)? {
return Ok(Some(value.boxed()))
}
//#builtins
None
},
#(#exposed)*
_ => None
})
}
}
} {
out.append(token)
}
}
}
impl ToTokens for ViewArm {
fn to_tokens (&self, out: &mut TokenStream2) {
let Self(key, value) = self;
out.append(Ident::new("Some", Span::call_site()));
out.append(Group::new(Delimiter::Parenthesis, {
let mut out = TokenStream2::new();
out.append(Punct::new(':', Joint));
out.append(Punct::new(':', Alone));
out.append(Ident::new("tengri", Span::call_site()));
out.append(Punct::new(':', Joint));
out.append(Punct::new(':', Alone));
out.append(Ident::new("dsl", Span::call_site()));
out.append(Punct::new(':', Joint));
out.append(Punct::new(':', Alone));
out.append(Ident::new("Token", Span::call_site()));
out.append(Group::new(Delimiter::Brace, {
let mut out = TokenStream2::new();
out.append(Ident::new("value", Span::call_site()));
out.append(Punct::new(':', Alone));
out.append(Punct::new(':', Joint));
out.append(Punct::new(':', Alone));
out.append(Ident::new("tengri", Span::call_site()));
out.append(Punct::new(':', Joint));
out.append(Punct::new(':', Alone));
out.append(Ident::new("dsl", Span::call_site()));
out.append(Punct::new(':', Joint));
out.append(Punct::new(':', Alone));
out.append(Ident::new("Value", Span::call_site()));
out.append(Punct::new(':', Joint));
out.append(Punct::new(':', Alone));
out.append(Ident::new("Sym", Span::call_site()));
out.append(Group::new(Delimiter::Parenthesis, {
let mut out = TokenStream2::new();
out.append(LitStr::new(key, Span::call_site()).token());
out
}));
out.append(Punct::new(',', Alone));
out.append(Punct::new('.', Joint));
out.append(Punct::new('.', Alone));
out
}));
out
}));
out.append(Punct::new('=', Joint));
out.append(Punct::new('>', Alone));
out.append(Ident::new("Some", Span::call_site()));
out.append(Group::new(Delimiter::Parenthesis, {
let mut out = TokenStream2::new();
out.append(Ident::new("state", Span::call_site()));
out.append(Punct::new('.', Alone));
out.append(value.clone());
out.append(Group::new(Delimiter::Parenthesis, TokenStream2::new()));
out.append(Punct::new('.', Alone));
out.append(Ident::new("boxed", Span::call_site()));
out.append(Group::new(Delimiter::Parenthesis, TokenStream2::new()));
out
}));
out.append(Punct::new(',', Alone));
}
}

3
tui/src/tui_engine.rs
View file

@ -72,7 +72,8 @@ pub trait TuiRun<R: Render<TuiOut> + Handle<TuiIn> + 'static> {
fn run (&self, state: &Arc<RwLock<R>>) -> Usually<()>;
}
impl<T: Render<TuiOut> + Handle<TuiIn> + 'static> TuiRun<T> for Arc<RwLock<Tui>> {
impl<T: Render<TuiOut> + Handle<TuiIn> + Send + Sync + 'static>
TuiRun<T> for Arc<RwLock<Tui>> {
fn run (&self, state: &Arc<RwLock<T>>) -> Usually<()> {
let _input_thread = TuiIn::run_input(self, state, Duration::from_millis(100));
self.write().unwrap().setup()?;

2
tui/src/tui_engine/tui_input.rs
View file

@ -21,7 +21,7 @@ impl Input for TuiIn {
impl TuiIn {
/// Spawn the input thread.
pub fn run_input <T: Handle<TuiIn> + 'static> (
pub fn run_input <T: Handle<TuiIn> + Send + Sync + 'static> (
engine: &Arc<RwLock<Tui>>,
state: &Arc<RwLock<T>>,
timer: Duration