alg_tools: comparison src/instance.rs

-:402d717bb5c0
+:dab30b331f49
 }
 }
 }
 /// Trait for ownable-by-consumption objects
-pub trait Ownable {
+pub trait Ownable: Sized {
 type OwnedVariant: Clone;
 /// Returns an owned instance, possibly consuming the original,
 /// avoiding cloning when possible.
 fn into_owned(self) -> Self::OwnedVariant;
 /// Returns an owned instance of a reference.
 fn clone_owned(&self) -> Self::OwnedVariant;
+/// Returns either an owned instance or a reference to one
+fn owned_cow<'b>(self) -> MyCow<'b, Self::OwnedVariant>
+where
+Self: 'b;
+/// Returns either an owned instance or a reference to one, preferring a reference.
+fn ref_owned_cow<'b>(&'b self) -> MyCow<'b, Self::OwnedVariant>
+where
+Self: 'b;
 }
 impl<'a, X: Ownable> Ownable for &'a X {
+type OwnedVariant = X::OwnedVariant;
+#[inline]
+fn into_owned(self) -> Self::OwnedVariant {
+self.clone_owned()
+}
+#[inline]
+fn clone_owned(&self) -> Self::OwnedVariant {
+(*self).into_owned()
+}
+fn owned_cow<'b>(self) -> MyCow<'b, Self::OwnedVariant>
+where
+Self: 'b,
+{
+(*self).ref_owned_cow()
+}
+#[inline]
+fn ref_owned_cow<'b>(&'b self) -> MyCow<'b, Self::OwnedVariant>
+where
+Self: 'b,
+{
+(*self).ref_owned_cow()
+}
+}
+impl<'a, X: Ownable> Ownable for &'a mut X {
 type OwnedVariant = X::OwnedVariant;
 #[inline]
 /// Returns an owned instance.
 fn into_owned(self) -> Self::OwnedVariant {
 }
 #[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()
+}
+fn owned_cow<'b>(self) -> MyCow<'b, Self::OwnedVariant>
+where
+Self: 'b,
+{
+(&*self).ref_owned_cow()
+}
+#[inline]
+fn ref_owned_cow<'b>(&'b self) -> MyCow<'b, Self::OwnedVariant>
+where
+Self: 'b,
+{
+(&**self).ref_owned_cow()
 }
 }
 impl<'a, X: Ownable> Ownable for MyCow<'a, X> {
 type OwnedVariant = X::OwnedVariant;
 fn clone_owned(&self) -> Self::OwnedVariant {
 match self {
 EitherDecomp::Owned(x) => x.into_owned(),
 EitherDecomp::Borrowed(x) => x.into_owned(),
 }
+}
+fn owned_cow<'b>(self) -> MyCow<'b, Self::OwnedVariant>
+where
+Self: 'b,
+{
+match self {
+EitherDecomp::Owned(x) => x.owned_cow(),
+EitherDecomp::Borrowed(x) => x.ref_owned_cow(),
+}
+}
+#[inline]
+fn ref_owned_cow<'b>(&'b self) -> MyCow<'b, Self::OwnedVariant>
+where
+Self: 'b,
+{
+(&**self).ref_owned_cow()
 }
 }
 /// Trait for abitrary mathematical spaces.
 pub trait Space: Ownable<OwnedVariant = Self::OwnedSpace> + Sized {
 #[inline]
 fn clone_owned(&self) -> Self::OwnedVariant {
 *self
 }
+#[inline]
+fn owned_cow<'b>(self) -> MyCow<'b, Self::OwnedVariant> where Self : 'b {
+EitherDecomp::Owned(self)
+}
+#[inline]
+fn ref_owned_cow<'b>(&'b self) -> MyCow<'b, Self::OwnedVariant> where Self : 'b{
+EitherDecomp::Owned(*self)
+}
 }
 };
 }
 impl_basic_space!(u8 u16 u32 u64 u128 usize
 /// 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, D = <X as Space>::Decomp>: Sized + Ownable
+pub trait Instance<X, D = <X as Space>::Decomp>:
+Sized + Ownable<OwnedVariant = X::OwnedSpace>
 where
 X: Space,
 D: Decomposition<X>,
 {
 /// Decomposes self according to `decomposer`, and evaluate `f` on the result.
 fn eval_ref_decompose<'b, R>(&'b self, f: impl FnOnce(D::Reference<'b>) -> R) -> R
 where
 X: 'b,
 Self: 'b;
+// fn eval_<'b, R>(
+//     &'b self,
+//     _f: impl FnOnce(D::Decomposition<'b>) -> R,
+//     g: impl FnOnce(D::Reference<'b>) -> R,
+// ) -> R
+// where
+//     X: 'b,
+//     Self: 'b,
+// {
+//     self.eval_ref_decompose(g)
+// }
 /// Returns an owned instance of `X`, cloning or converting non-true instances when necessary.
-fn own(self) -> X;
+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, X>
+fn cow<'b>(self) -> MyCow<'b, X::OwnedSpace>
 where
 Self: 'b,
 {
-MyCow::Owned(self.own())
+self.owned_cow()
 }
 #[inline]
 /// Evaluates `f` on a reference to self.
 ///
 /// Default implementation uses [`Self::cow`]. Consumes the input.
-fn eval<'b, R>(self, f: impl FnOnce(&X) -> R) -> R
+fn eval<'b, R>(self, f: impl FnOnce(&X::OwnedSpace) -> R) -> R
 where
 X: 'b,
 Self: 'b,
 {
 f(&*self.cow())
 #[inline]
 /// 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(X) -> R, g: impl FnOnce(&X) -> R) -> R
+fn either<'b, R>(
+self,
+f: impl FnOnce(X::OwnedSpace) -> R,
+g: impl FnOnce(&X::OwnedSpace) -> R,
+) -> R
 where
 Self: 'b,
 {
 match self.cow() {
 EitherDecomp::Owned(x) => f(x),
 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> 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.into_owned()
-}
-#[inline]
-fn cow<'b>(self) -> MyCow<'b, X>
-where
-Self: 'b,
-{
-MyCow::Borrowed(self)
-}
 }
 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.into_owned()
-}
-#[inline]
-fn cow<'b>(self) -> MyCow<'b, X>
-where
-Self: 'b,
-{
-EitherDecomp::Borrowed(self)
 }
 }
 impl<'a, X: Space> 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