alg_tools: comparison src/instance.rs

-:e7920e205785
+:bea0c3841ced
 /// avoiding cloning when possible.
 fn into_owned(self) -> Self::OwnedVariant;
 /// Returns an owned instance of a reference.
 fn clone_owned(&self) -> Self::OwnedVariant;
+/// Returns an owned instance or a reference to one.
+fn cow_owned<'b>(self) -> MyCow<'b, Self::OwnedVariant>
+where
+Self: 'b;
 }
 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()
 }
+#[inline]
+fn cow_owned<'b>(self) -> MyCow<'b, Self::OwnedVariant>
+where
+Self: 'b,
+{
+todo!();
+}
 }
 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()
 }
+#[inline]
+fn cow_owned<'b>(self) -> MyCow<'b, Self::OwnedVariant>
+where
+Self: 'b,
+{
+todo!();
+}
 }
 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(),
 }
+}
+#[inline]
+fn cow_owned<'b>(self) -> MyCow<'b, Self::OwnedVariant>
+where
+Self: 'b,
+{
+todo!();
 }
 }
 /// Trait for abitrary mathematical spaces.
 pub trait Space: Ownable<OwnedVariant = Self::OwnedSpace> + Sized {
 #[inline]
 fn clone_owned(&self) -> Self::OwnedVariant {
 *self
 }
+#[inline]
+fn cow_owned<'b>(self) -> MyCow<'b, Self::OwnedVariant> where Self : 'b {
+todo!();
+}
 }
 };
 }
 impl_basic_space!(u8 u16 u32 u64 u128 usize
 i8 i16 i32 i64 i128 isize
 f32 f64);
 /// Marker type for decompositions to be used with [`Instance`].
 pub trait Decomposition<X: Space>: Sized {
-/// Owned instance
-type OwnedInstance: Instance<X, Self>;
 /// Possibly owned form of the decomposition
 type Decomposition<'b>: Instance<X, Self>
 where
 X: 'b;
 /// Unlikely owned form of the decomposition.
 where
 X: 'b;
 /// Lift the lightweight reference type into a full decomposition type.
 fn lift<'b>(r: Self::Reference<'b>) -> Self::Decomposition<'b>;
-// /// Lift the lightweight reference type into a fully owned type
-// fn full_lift<'b>(r: Self::Reference<'b>) -> Self::OwnedInstance;
 }
 /// 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 {
-type OwnedInstance = X;
 type Decomposition<'b>
 = MyCow<'b, X>
 where
 X: 'b;
 type Reference<'b>
 where
 X: 'b,
 Self: 'b;
 /// Returns an owned instance of `X`, cloning or converting non-true instances when necessary.
-fn own(self) -> D::OwnedInstance;
+fn own(self) -> X::OwnedSpace {
+self.into_owned()
+}
 // ************** automatically implemented methods below from here **************
 /// Returns an owned instance or reference to `X`, converting non-true instances when necessary.
 ///
 /// Default implementation uses [`Self::own`]. Consumes the input.
-fn cow<'b>(self) -> MyCow<'b, D::OwnedInstance>
+fn cow<'b>(self) -> MyCow<'b, X::OwnedSpace>
 where
 Self: 'b,
 {
-MyCow::Owned(self.own())
+self.cow_owned()
 }
 #[inline]
 /// Evaluates `f` on a reference to self.
 ///
 /// Default implementation uses [`Self::cow`]. Consumes the input.
-fn eval<'b, R>(self, f: impl FnOnce(&D::OwnedInstance) -> R) -> R
+fn eval<'b, R>(self, f: impl FnOnce(&X::OwnedSpace) -> R) -> R
 where
 X: 'b,
 Self: 'b,
 {
 f(&*self.cow())
 /// Evaluates `f` or `g` depending on whether a reference or owned value is available.
 ///
 /// Default implementation uses [`Self::cow`]. Consumes the input.
 fn either<'b, R>(
 self,
-f: impl FnOnce(D::OwnedInstance) -> R,
+f: impl FnOnce(X::OwnedSpace) -> R,
-g: impl FnOnce(&D::OwnedInstance) -> R,
+g: impl FnOnce(&X::OwnedSpace) -> R,
 ) -> R
 where
 Self: 'b,
 {
 match self.cow() {
 X: 'b,
 Self: 'b,
 {
 f(self)
 }
-#[inline]
-fn own(self) -> X {
-self
-}
-#[inline]
-fn cow<'b>(self) -> MyCow<'b, X>
-where
-Self: 'b,
-{
-MyCow::Owned(self)
-}
 }
 impl<'a, X: Space + Clone> Instance<X, BasicDecomposition> for &'a X {
 #[inline]
 fn eval_decompose<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R) -> R
 X: 'b,
 Self: 'b,
 {
 f(*self)
 }
-#[inline]
-fn own(self) -> X {
-self.clone()
-}
-#[inline]
-fn cow<'b>(self) -> MyCow<'b, X>
-where
-Self: 'b,
-{
-MyCow::Borrowed(self)
-}
 }
 impl<'a, X: Space + Clone> 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()
-}
-#[inline]
-fn cow<'b>(self) -> MyCow<'b, X>
-where
-Self: 'b,
-{
-EitherDecomp::Borrowed(self)
 }
 }
 impl<'a, X: Space + Clone> Instance<X, BasicDecomposition> for MyCow<'a, X> {
 #[inline]
 Self: 'b,
 {
 match self {
 MyCow::Borrowed(a) => f(a),
 MyCow::Owned(b) => f(&b),
-}
-}
-#[inline]
-fn own(self) -> X {
-match self {
-MyCow::Borrowed(a) => a.own(),
-MyCow::Owned(b) => b.own(),
-}
-}
-#[inline]
-fn cow<'b>(self) -> MyCow<'b, X>
-where
-Self: 'b,
-{
-match self {
-MyCow::Borrowed(a) => a.cow(),
-MyCow::Owned(b) => b.cow(),
 }
 }
 }
 /// Marker type for mutable decompositions to be used with [`InstanceMut`].

Mercurial > repos > alg_tools / file comparison

comparison: src/instance.rs

src/instance.rs