input/input.rs

@@ -26,8 +26,8 @@ flex_trait_mut!(Handle <E: Input> {
 });
 
 pub trait Command<S>: Send + Sync + Sized {
-    fn execute (&self, state: &mut S) -> Perhaps<Self>;
-    fn delegate <T> (&self, state: &mut S, wrap: impl Fn(Self)->T) -> Perhaps<T>
+    fn execute (self, state: &mut S) -> Perhaps<Self>;
+    fn delegate <T> (self, state: &mut S, wrap: impl Fn(Self)->T) -> Perhaps<T>
         where Self: Sized
     {
         Ok(self.execute(state)?.map(wrap))
@@ -35,10 +35,10 @@ pub trait Command<S>: Send + Sync + Sized {
 }
 
 impl<S, T: Command<S>> Command<S> for Option<T> {
-    fn execute (&self, _: &mut S) -> Perhaps<Self> {
+    fn execute (self, _: &mut S) -> Perhaps<Self> {
         Ok(None)
     }
-    fn delegate <U> (&self, _: &mut S, _: impl Fn(Self)->U) -> Perhaps<U>
+    fn delegate <U> (self, _: &mut S, _: impl Fn(Self)->U) -> Perhaps<U>
         where Self: Sized
     {
         Ok(None)
@@ -49,30 +49,13 @@ impl<S, T: Command<S>> Command<S> for Option<T> {
 #[macro_export] macro_rules! command {
     ($(<$($l:lifetime),+>)?|$self:ident:$Command:ty,$state:ident:$State:ty|$handler:expr) => {
         impl$(<$($l),+>)? ::tengri::input::Command<$State> for $Command {
-            fn execute (&$self, $state: &mut $State) -> Perhaps<Self> {
+            fn execute ($self, $state: &mut $State) -> Perhaps<Self> {
                 Ok($handler)
             }
         }
     };
 }
 
-#[macro_export] macro_rules! def_command (($Command:ident: |$state:ident: $State:ty| {
-    $($Variant:ident$({$($arg:ident:$Arg:ty),+ $(,)?})?=>$body:expr),* $(,)?
-})=>{
-    #[derive(Debug)]
-    pub enum $Command {
-        $($Variant $({ $($arg: $Arg),* })?),*
-    }
-    impl Command<$State> for $Command {
-        fn execute (&self, $state: &mut $State) -> Perhaps<Self> {
-            match self {
-                $(Self::$Variant $({ $($arg),* })? => $body,)*
-                _ => unimplemented!("Command<{}>: {self:?}", stringify!($State)),
-            }
-        }
-    }
-});
-
 /// Implement [Handle] for given `State` and `handler`.
 #[macro_export] macro_rules! handle {
     (|$self:ident:$State:ty,$input:ident|$handler:expr) => {

output/src/space.rs

@@ -208,13 +208,6 @@ pub struct Measure<E: Output> {
     pub y: Arc<AtomicUsize>,
 }
 
-impl<E: Output> PartialEq for Measure<E> {
-    fn eq (&self, other: &Self) -> bool {
-        self.x.load(Relaxed) == other.x.load(Relaxed) &&
-            self.y.load(Relaxed) == other.y.load(Relaxed)
-    }
-}
-
 // TODO: 🡘  🡙 ←🡙→ indicator to expand window when too small
 impl<E: Output> Content<E> for Measure<E> {
     fn render (&self, to: &mut E) {

proc/src/proc_command.rs

@@ -144,7 +144,7 @@ impl ToTokens for CommandDef {
             /// 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> {
+                fn execute (self, state: &mut #state) -> Perhaps<Self> {
                     match self { #(#implementations)* }
                 }
             }