feat: rather than +Debug, make a newtype

src/api/controller.rs

@@ -70,9 +70,23 @@ pub trait Controller<T : Sized + Send + Sync> : Sized + Send + Sync {
 }
 
 
-/// type alias for Boxed dyn callback
+/// type wrapper for Boxed dyn callback
-pub type ControllerCallback = Box<dyn ControllerCallbackTrait>;
+pub struct ControllerCallback(Box<dyn Sync + Send + Fn()>);
 
-/// underlying trait for controller callback: must be a threadsafe repeatable non-mut closure which
+impl ControllerCallback {
-/// can be debug printed
+	pub fn call(&self) {
-pub trait ControllerCallbackTrait : Sync + Send + std::fmt::Debug + Fn() {}
+		self.0() // lmao at this syntax
+	}
+}
+
+impl std::fmt::Debug for ControllerCallback {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "ControllerCallback {{ {:p} }}", self.0)
+	}
+}
+
+impl<T: Sync + Send + Fn() + 'static> From<T> for ControllerCallback {
+	fn from(value: T) -> Self {
+		Self(Box::new(value))
+	}
+}

src/buffer/worker.rs

@@ -135,7 +135,7 @@ impl ControllerWorker<TextChange> for BufferWorker {
 									tx.send(()).unwrap_or_warn("could not wake up poller");
 								}
 								if let Some(cb) = self.callback.borrow().as_ref() {
-									cb(); // TODO should we run this on another task/thread?
+									cb.call(); // TODO should we run this on another task/thread?
 								}
 							},
 							Err(e) => tracing::error!("could not deserialize operation from server: {}", e),

src/cursor/worker.rs

@@ -62,7 +62,7 @@ impl ControllerWorker<Cursor> for CursorWorker {
 					self.channel.send(cur.clone()).unwrap_or_warn("could not broadcast event");
 					self.changed.send(cur).unwrap_or_warn("could not update last event");
 					if let Some(cb) = self.callback.borrow().as_ref() {
-						cb(); // TODO should this run in its own task/thread?
+						cb.call(); // TODO should this run in its own task/thread?
 					}
 				},
 				else => break,