alg_tools: comparison src/instance.rs

-:2f1798c65fd6
+:c4e394a9c84c
 EitherDecomp::Borrowed(x) => x,
 }
 }
 }
-impl<'b, X> MyCow<'b, X> {
+/// Trait for ownable-by-consumption objects
-#[inline]
+pub trait Ownable {
-pub fn into_owned(self) -> X
+type OwnedVariant: Clone;
-where
-X: Clone,
+/// Returns an owned instance, possibly consuming the original,
-{
+/// avoiding cloning when possible.
-match self {
+fn into_owned(self) -> Self::OwnedVariant;
-EitherDecomp::Owned(x) => x,
-EitherDecomp::Borrowed(x) => x.clone(),
+/// Returns an owned instance of a reference.
+fn clone_owned(&self) -> Self::OwnedVariant;
+}
+impl<'a, X: Ownable> Ownable for &'a X {
+type OwnedVariant = X::OwnedVariant;
+#[inline]
+/// Returns an owned instance.
+fn into_owned(self) -> Self::OwnedVariant {
+self.clone_owned()
+}
+#[inline]
+/// Returns an owned instance.
+fn clone_owned(&self) -> Self::OwnedVariant {
+(*self).into_owned()
+}
+}
+impl<'a, X: Ownable> Ownable for &'a mut X {
+type OwnedVariant = X::OwnedVariant;
+#[inline]
+/// Returns an owned instance.
+fn into_owned(self) -> Self::OwnedVariant {
+self.clone_owned()
+}
+#[inline]
+/// Returns an owned instance.
+fn clone_owned(&self) -> Self::OwnedVariant {
+(&**self).into_owned()
+}
+}
+impl<'a, X: Ownable> Ownable for MyCow<'a, X> {
+type OwnedVariant = X::OwnedVariant;
+#[inline]
+/// Returns an owned instance.
+fn into_owned(self) -> Self::OwnedVariant {
+match self {
+EitherDecomp::Owned(x) => x.into_owned(),
+EitherDecomp::Borrowed(x) => x.into_owned(),
+}
+}
+#[inline]
+/// Returns an owned instance.
+fn clone_owned(&self) -> Self::OwnedVariant {
+match self {
+EitherDecomp::Owned(x) => x.into_owned(),
+EitherDecomp::Borrowed(x) => x.into_owned(),
 }
 }
 }
 /// Trait for abitrary mathematical spaces.
-pub trait Space: Instance<Self, Self::Decomp> {
+pub trait Space: Ownable<OwnedVariant = Self::OwnedSpace> + Sized {
+type OwnedSpace: ClosedSpace;
 /// Default decomposition for the space
 type Decomp: Decomposition<Self>;
 }
+mod private {
+pub trait Sealed {}
+}
+/// Helper trait for working with own types.
+pub trait Owned: Ownable<OwnedVariant = Self> + private::Sealed {}
+impl<X: Ownable<OwnedVariant = X>> private::Sealed for X {}
+impl<X: Ownable<OwnedVariant = X>> Owned for X {}
+/// Helper trait for working with closed spaces, operations in which should
+/// return members of the same space
+pub trait ClosedSpace: Space<OwnedSpace = Self> + Owned + Instance<Self> {}
+impl<X: Space<OwnedSpace = Self> + Owned + Instance<Self>> ClosedSpace for X {}
 #[macro_export]
 macro_rules! impl_basic_space {
-($($type:ty)*) => { $(
+($($type:ty)*) => {
-impl $crate::instance::Space for $type {
+$( $crate::impl_basic_space!($type where ); )*
-type Decomp = $crate::instance::BasicDecomposition;
+};
-}
-)* };
 ($type:ty where $($where:tt)*) => {
 impl<$($where)*> $crate::instance::Space for $type {
+type OwnedSpace = Self;
 type Decomp = $crate::instance::BasicDecomposition;
+}
+impl<$($where)*> $crate::instance::Ownable for $type {
+type OwnedVariant = Self;
+#[inline]
+fn into_owned(self) -> Self::OwnedVariant {
+self
+}
+#[inline]
+fn clone_owned(&self) -> Self::OwnedVariant {
+*self
+}
 }
 };
 }
 impl_basic_space!(u8 u16 u32 u64 u128 usize
 /// Most common [`Decomposition`] (into `Either<X, &'b X>`) that allows working with owned
 /// values and all sorts of references.
 #[derive(Copy, Clone, Debug)]
 pub struct BasicDecomposition;
-impl<X: Space + Clone> Decomposition<X> for BasicDecomposition {
+impl<X: Space> Decomposition<X> for BasicDecomposition {
 type Decomposition<'b>
 = MyCow<'b, X>
 where
 X: 'b;
 type Reference<'b>
 /// Helper trait for functions to work with either owned values or references to either the
 /// “principal type” `X` or types some present a subset of `X`. In the latter sense, this
 /// generalises [`std::borrow::ToOwned`], [`std::borrow::Borrow`], and [`std::borrow::Cow`].
 ///
 /// This is used, for example, by [`crate::mapping::Mapping::apply`].
-pub trait Instance<X: Space, D = <X as Space>::Decomp>: Sized
+pub trait Instance<X, D = <X as Space>::Decomp>: Sized + Ownable
 where
+X: Space,
 D: Decomposition<X>,
 {
 /// Decomposes self according to `decomposer`, and evaluate `f` on the result.
 /// Consumes self.
 fn eval_decompose<'b, R>(self, f: impl FnOnce(D::Decomposition<'b>) -> R) -> R
 EitherDecomp::Borrowed(x) => g(x),
 }
 }
 }
-impl<X: Space + Clone> Instance<X, BasicDecomposition> for X {
+impl<X: Space> Instance<X, BasicDecomposition> for X {
 #[inline]
 fn eval_decompose<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R) -> R
 where
 X: 'b,
 Self: 'b,
 {
 MyCow::Owned(self)
 }
 }
-impl<'a, X: Space + Clone> Instance<X, BasicDecomposition> for &'a X {
+impl<'a, X: Space> Instance<X, BasicDecomposition> for &'a X {
 #[inline]
 fn eval_decompose<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R) -> R
 where
 X: 'b,
 Self: 'b,
 f(*self)
 }
 #[inline]
 fn own(self) -> X {
-self.clone()
+self.into_owned()
 }
 #[inline]
 fn cow<'b>(self) -> MyCow<'b, X>
 where
 {
 MyCow::Borrowed(self)
 }
 }
-impl<'a, X: Space + Clone> Instance<X, BasicDecomposition> for &'a mut X {
+impl<'a, X: Space> Instance<X, BasicDecomposition> for &'a mut X {
 #[inline]
 fn eval_decompose<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R) -> R
 where
 X: 'b,
 Self: 'b,
 f(*self)
 }
 #[inline]
 fn own(self) -> X {
-self.clone()
+self.into_owned()
 }
 #[inline]
 fn cow<'b>(self) -> MyCow<'b, X>
 where
 Self: 'b,
-X: Clone,
 {
 EitherDecomp::Borrowed(self)
 }
 }
-impl<'a, X: Space + Clone> Instance<X, BasicDecomposition> for MyCow<'a, X> {
+impl<'a, X: Space> Instance<X, BasicDecomposition> for MyCow<'a, X> {
 #[inline]
 fn eval_decompose<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R) -> R
 where
 X: 'b,
 Self: 'b,

Mercurial > repos > alg_tools / file comparison

comparison: src/instance.rs

src/instance.rs