chore(protocol)!: clean up traits (including making extension traits pub), trying auto implementing Toggle for GetState and SetState - we'll see how that goes

protocol/src/light.rs

@@ -1,7 +1,6 @@
 use std::{error::Error, future::Future};
 
 use deranged::RangedU16;
-use palette::Oklch;
 use snafu::{ResultExt, Snafu};
 
 #[derive(
@@ -43,14 +42,14 @@ pub trait GetState {
     fn get_state(&self) -> impl Future<Output = Result<State, Self::Error>> + Send;
 }
 
-#[ext_trait::extension(trait IsOff)]
+#[ext_trait::extension(pub trait IsOff)]
 impl<T: GetState> T {
     async fn is_off(&self) -> Result<bool, T::Error> {
         Ok(self.get_state().await?.is_off())
     }
 }
 
-#[ext_trait::extension(trait IsOn)]
+#[ext_trait::extension(pub trait IsOn)]
 impl<T: GetState> T {
     async fn is_on(&self) -> Result<bool, T::Error> {
         Ok(self.get_state().await?.is_on())
@@ -62,36 +61,39 @@ pub trait SetState {
     fn set_state(&mut self, state: State) -> impl Future<Output = Result<(), Self::Error>> + Send;
 }
 
-#[ext_trait::extension(trait TurnOff)]
+#[ext_trait::extension(pub trait TurnOff)]
 impl<T: SetState> T {
     async fn turn_off(&mut self) -> Result<(), T::Error> {
         self.set_state(State::Off).await
     }
 }
 
-#[ext_trait::extension(trait TurnOn)]
+#[ext_trait::extension(pub trait TurnOn)]
 impl<T: SetState> T {
     async fn turn_on(&mut self) -> Result<(), T::Error> {
         self.set_state(State::On).await
     }
 }
 
+pub trait Toggle {
+    type Error: Error;
+    fn toggle(&mut self) -> impl Future<Output = Result<(), Self::Error>> + Send;
+}
+
 #[derive(Debug, Clone, Snafu)]
-enum InvertToToggleError<GetStateError: Error + 'static, SetStateError: Error + 'static> {
+pub enum InvertToToggleError<GetStateError: Error + 'static, SetStateError: Error + 'static> {
     GetStateError { source: GetStateError },
     SetStateError { source: SetStateError },
 }
 
-#[ext_trait::extension(trait InvertToToggle)]
+impl<T: GetState + SetState + Send> Toggle for T
-impl<T: GetState + SetState> T
 where
     <T as GetState>::Error: 'static,
     <T as SetState>::Error: 'static,
 {
+    type Error = InvertToToggleError<<T as GetState>::Error, <T as SetState>::Error>;
     /// Toggle the light by setting it to the inverse of its current state
-    async fn toggle(
+    async fn toggle(&mut self) -> Result<(), Self::Error> {
-        &mut self,
-    ) -> Result<(), InvertToToggleError<<T as GetState>::Error, <T as SetState>::Error>> {
         let state = self.get_state().await.context(GetStateSnafu)?;
         self.set_state(state.invert())
             .await
@@ -101,26 +103,22 @@ where
     }
 }
 
-pub trait Toggle {
+pub type Kelvin = RangedU16<2000, 10000>;
-    type Error: Error;
-    fn toggle(&mut self, state: State) -> impl Future<Output = Result<(), Self::Error>> + Send;
-}
-
-#[derive(Debug, Clone, Copy, derive_more::From, derive_more::Into)]
-pub struct Kelvin(pub RangedU16<2000, 10000>);
 
 pub trait TurnToTemperature {
-    type TurnToTemperatureError: Error;
+    type Error: Error;
     fn turn_to_temperature(
         &mut self,
         temperature: Kelvin,
-    ) -> impl Future<Output = Result<(), Self::TurnToTemperatureError>> + Send;
+    ) -> impl Future<Output = Result<(), Self::Error>> + Send;
 }
 
+pub type Oklch = palette::Oklch<f64>;
+
 pub trait TurnToColor {
-    type TurnToColorError: Error;
+    type Error: Error;
     fn turn_to_color(
         &mut self,
-        color: Oklch<f64>,
+        color: Oklch,
-    ) -> impl Future<Output = Result<(), Self::TurnToColorError>> + Send;
+    ) -> impl Future<Output = Result<(), Self::Error>> + Send;
 }