diff -r 1f19c6bbf07b -r 3868555d135c src/instance.rs
--- a/src/instance.rs	Sun Apr 27 20:29:43 2025 -0500
+++ b/src/instance.rs	Fri May 15 14:46:30 2026 -0500
@@ -23,32 +23,252 @@
     }
 }
 
-impl<'b, X> MyCow<'b, X> {
+/// Trait for ownable-by-consumption objects
+pub trait Ownable {
+    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 an owned instance or a reference to one.
+    fn cow_owned<'b>(self) -> MyCow<'b, Self::OwnedVariant>
+    where
+        Self: 'b;
+
+    /// Returns an owned instance or a reference to one.
+    fn ref_cow_owned<'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 {
+        X::clone_owned(self)
+    }
+
+    #[inline]
+    fn clone_owned(&self) -> Self::OwnedVariant {
+        X::clone_owned(self)
+    }
+
     #[inline]
-    pub fn into_owned(self) -> X where X : Clone {
+    fn cow_owned<'b>(self) -> MyCow<'b, Self::OwnedVariant>
+    where
+        Self: 'b,
+    {
+        X::ref_cow_owned(self)
+    }
+
+    fn ref_cow_owned<'b>(&self) -> MyCow<'b, Self::OwnedVariant>
+    where
+        Self: 'b,
+    {
+        X::ref_cow_owned(self)
+    }
+}
+
+impl<'a, X: Ownable> Ownable for &'a mut X {
+    type OwnedVariant = X::OwnedVariant;
+
+    #[inline]
+    fn into_owned(self) -> Self::OwnedVariant {
+        X::clone_owned(self)
+    }
+
+    #[inline]
+    fn clone_owned(&self) -> Self::OwnedVariant {
+        X::clone_owned(self)
+    }
+
+    #[inline]
+    fn cow_owned<'b>(self) -> MyCow<'b, Self::OwnedVariant>
+    where
+        Self: 'b,
+    {
+        X::ref_cow_owned(self)
+    }
+
+    fn ref_cow_owned<'b>(&'b self) -> MyCow<'b, Self::OwnedVariant>
+    where
+        Self: 'b,
+    {
+        X::ref_cow_owned(self)
+    }
+}
+
+impl<'a, A, B> Ownable for EitherDecomp<A, B>
+where
+    A: Ownable,
+    B: Ownable<OwnedVariant = A::OwnedVariant>,
+{
+    type OwnedVariant = A::OwnedVariant;
+
+    #[inline]
+    fn into_owned(self) -> Self::OwnedVariant {
         match self {
-            EitherDecomp::Owned(x) => x,
-            EitherDecomp::Borrowed(x) => x.clone(),
+            EitherDecomp::Owned(a) => A::into_owned(a),
+            EitherDecomp::Borrowed(b) => B::into_owned(b),
+        }
+    }
+
+    #[inline]
+    fn clone_owned(&self) -> Self::OwnedVariant {
+        match self {
+            EitherDecomp::Owned(a) => A::clone_owned(a),
+            EitherDecomp::Borrowed(b) => B::clone_owned(b),
+        }
+    }
+
+    #[inline]
+    fn cow_owned<'b>(self) -> MyCow<'b, Self::OwnedVariant>
+    where
+        A: 'b,
+        B: 'b,
+    {
+        match self {
+            EitherDecomp::Owned(a) => A::cow_owned(a),
+            EitherDecomp::Borrowed(b) => B::cow_owned(b),
+        }
+    }
+
+    #[inline]
+    fn ref_cow_owned<'b>(&'b self) -> MyCow<'b, Self::OwnedVariant>
+    where
+        Self: 'b,
+    {
+        match self {
+            EitherDecomp::Owned(a) => A::ref_cow_owned(a),
+            EitherDecomp::Borrowed(b) => B::ref_cow_owned(b),
         }
     }
 }
 
+#[macro_export]
+macro_rules! self_ownable {
+    ($type:ty where $($qual:tt)*) => {
+        impl<$($qual)*> $crate::instance::Ownable for $type {
+            type OwnedVariant = Self;
+
+            #[inline]
+            fn into_owned(self) -> Self::OwnedVariant {
+                self
+            }
+
+            fn clone_owned(&self) -> Self::OwnedVariant {
+                self.clone()
+            }
+
+            fn cow_owned<'b>(self) -> $crate::instance::MyCow<'b, Self::OwnedVariant>
+            where
+                Self: 'b,
+            {
+                $crate::instance::MyCow::Owned(self)
+            }
+
+            fn ref_cow_owned<'b>(&'b self) -> $crate::instance::MyCow<'b, Self::OwnedVariant>
+            where
+                Self: 'b,
+            {
+                $crate::instance::MyCow::Borrowed(self)
+            }
+        }
+    };
+}
+
+self_ownable!(Vec<T> where T : Clone);
+
+impl<'a, T: Clone> Ownable for &'a [T] {
+    type OwnedVariant = Vec<T>;
+
+    #[inline]
+    fn into_owned(self) -> Self::OwnedVariant {
+        Vec::from(self)
+    }
+
+    #[inline]
+    fn clone_owned(&self) -> Self::OwnedVariant {
+        Vec::from(*self)
+    }
+
+    #[inline]
+    fn cow_owned<'b>(self) -> MyCow<'b, Self::OwnedVariant>
+    where
+        Self: 'b,
+    {
+        MyCow::Owned(Vec::from(self))
+    }
+
+    fn ref_cow_owned<'b>(&'b self) -> MyCow<'b, Self::OwnedVariant>
+    where
+        Self: 'b,
+    {
+        MyCow::Owned(Vec::from(*self))
+    }
+}
+
 /// Trait for abitrary mathematical spaces.
-pub trait Space : Instance<Self, Self::Decomp> {
+pub trait Space: Ownable<OwnedVariant = Self::Principal> + Sized {
+    /// Principal, typically owned realisation of the space.
+    type Principal: ClosedSpace;
+
     /// Default decomposition for the space
-    type Decomp : Decomposition<Self>;
+    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<Principal = Self> + Owned + Instance<Self> {}
+impl<X: Space<Principal = Self> + Owned + Instance<Self>> ClosedSpace for X {}
+
 #[macro_export]
 macro_rules! impl_basic_space {
-    ($($type:ty)*) => { $(
-        impl $crate::instance::Space for $type {
+    ($($type:ty)*) => {
+        $( $crate::impl_basic_space!($type where ); )*
+    };
+    ($type:ty where $($where:tt)*) => {
+        impl<$($where)*> $crate::instance::Space for $type {
+            type Principal = Self;
             type Decomp = $crate::instance::BasicDecomposition;
         }
-    )* };
-    ($type:ty where $($where:tt)*) => {
-        impl<$($where)*> $crate::instance::Space for $type {
-            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
+            }
+
+            #[inline]
+            fn cow_owned<'b>(self) -> MyCow<'b, Self::OwnedVariant> where Self : 'b {
+                MyCow::Owned(self)
+            }
+
+            #[inline]
+            fn ref_cow_owned<'b>(&self) -> MyCow<'b, Self::OwnedVariant> where Self : 'b {
+                MyCow::Owned(*self)
+            }
         }
     };
 }
@@ -58,17 +278,21 @@
                   f32 f64);
 
 /// Marker type for decompositions to be used with [`Instance`].
-pub trait Decomposition<X : Space> : Sized {
+pub trait Decomposition<X: Space>: Sized {
     /// Possibly owned form of the decomposition
-    type Decomposition<'b> : Instance<X, Self> where X : 'b;
+    type Decomposition<'b>: Instance<X, Self>
+    where
+        X: 'b;
     /// Unlikely owned form of the decomposition.
     /// Type for a lightweight intermediate conversion that does not own the original variable.
     /// Usually this is just a reference, but may also be a lightweight structure that
     /// contains references; see the implementation for [`crate::direct_product::Pair`].
-    type Reference<'b> : Instance<X, Self> + Copy where X : 'b;
+    type Reference<'b>: Instance<X, Self> + Copy
+    where
+        X: 'b;
 
-    /// Left 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 full decomposition type.
+    fn lift<'b>(r: Self::Reference<'b>) -> Self::Decomposition<'b>;
 }
 
 /// Most common [`Decomposition`] (into `Either<X, &'b X>`) that allows working with owned
@@ -76,12 +300,18 @@
 #[derive(Copy, Clone, Debug)]
 pub struct BasicDecomposition;
 
-impl<X : Space + Clone> Decomposition<X> for BasicDecomposition {
-    type Decomposition<'b> = MyCow<'b, X> where X : 'b;
-    type Reference<'b> = &'b X where X : 'b;
+impl<X: Space> Decomposition<X> for BasicDecomposition {
+    type Decomposition<'b>
+        = MyCow<'b, X>
+    where
+        X: 'b;
+    type Reference<'b>
+        = &'b X
+    where
+        X: 'b;
 
     #[inline]
-    fn lift<'b>(r : Self::Reference<'b>) -> Self::Decomposition<'b> {
+    fn lift<'b>(r: Self::Reference<'b>) -> Self::Decomposition<'b> {
         MyCow::Borrowed(r)
     }
 }
@@ -91,192 +321,225 @@
 /// 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 where D : Decomposition<X> {
-    /// Decomposes self according to `decomposer`.
-    fn decompose<'b>(self) -> D::Decomposition<'b>
-    where Self : 'b, X : 'b;
-  
-    /// Returns a lightweight instance of `self`.
-    fn ref_instance(&self) -> D::Reference<'_>;
+pub trait Instance<X, D = <X as Space>::Decomp>: Sized
+where
+    X: Space,
+    D: Decomposition<X>,
+{
+    /// Decomposes self according to `decomposer`, and evaluate `f` on the result.
+    /// Consumes self.
+    #[inline]
+    fn eval_decompose<'b, R>(self, f: impl FnOnce(D::Decomposition<'b>) -> R) -> R
+    where
+        X: 'b,
+        Self: 'b,
+    {
+        f(self.decompose())
+    }
+
+    /// Does a light decomposition of self `decomposer`, and evaluates `f` on the result.
+    /// Does not consume self.
+    fn eval_ref<'b, R>(&'b self, f: impl FnOnce(D::Reference<'b>) -> R) -> R
+    where
+        X: 'b,
+        Self: 'b;
 
     /// Returns an owned instance of `X`, cloning or converting non-true instances when necessary.
-    fn own(self) -> X;
+    fn own(self) -> X::Principal;
 
-    // ************** automatically implemented methods below from here **************
+    fn decompose<'b>(self) -> D::Decomposition<'b>
+    where
+        Self: 'b;
 
     /// 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> where Self : 'b {
-        MyCow::Owned(self.own())
-    }
-    
+    fn cow<'b>(self) -> MyCow<'b, X::Principal>
+    where
+        Self: 'b;
+
     #[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
-    where X : 'b, Self : 'b
+    fn eval<'b, R>(self, f: impl FnOnce(&X::Principal) -> 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
-    where Self : 'b
-    {
-        match self.cow() {
-            EitherDecomp::Owned(x) => f(x),
-            EitherDecomp::Borrowed(x) => g(x),
-        }
-    }
 }
 
-
-impl<X : Space + Clone> Instance<X, BasicDecomposition> for X {
+impl<X: Space> Instance<X, BasicDecomposition> for X {
     #[inline]
-    fn decompose<'b>(self) -> <BasicDecomposition as Decomposition<X>>::Decomposition<'b>
-    where Self : 'b, X : 'b
+    fn eval_ref<'b, R>(&'b self, f: impl FnOnce(&'b X) -> R) -> R
+    where
+        X: 'b,
+        Self: 'b,
     {
-        MyCow::Owned(self)
+        f(self)
     }
 
     #[inline]
-    fn own(self) -> X {
-        self
+    fn own(self) -> X::Principal {
+        self.into_owned()
+    }
+
+    #[inline]
+    fn cow<'b>(self) -> MyCow<'b, X::Principal>
+    where
+        Self: 'b,
+    {
+        self.cow_owned()
     }
 
     #[inline]
-    fn cow<'b>(self) -> MyCow<'b, X> where Self : 'b {
+    fn decompose<'b>(self) -> MyCow<'b, X>
+    where
+        Self: 'b,
+    {
         MyCow::Owned(self)
     }
+}
+
+impl<'a, X: Space> Instance<X, BasicDecomposition> for &'a X {
+    #[inline]
+    fn eval_ref<'b, R>(&'b self, f: impl FnOnce(&'b X) -> R) -> R
+    where
+        X: 'b,
+        Self: 'b,
+    {
+        f(*self)
+    }
 
     #[inline]
-    fn ref_instance(&self) -> <BasicDecomposition as Decomposition<X>>::Reference<'_> {
-        self
+    fn own(self) -> X::Principal {
+        self.into_owned()
     }
-}
 
-impl<'a, X : Space + Clone> Instance<X, BasicDecomposition> for &'a X {
     #[inline]
-    fn decompose<'b>(self) -> <BasicDecomposition as Decomposition<X>>::Decomposition<'b>
-    where Self : 'b, X : 'b
+    fn cow<'b>(self) -> MyCow<'b, X::Principal>
+    where
+        Self: 'b,
+    {
+        self.cow_owned()
+    }
+
+    #[inline]
+    fn decompose<'b>(self) -> MyCow<'b, X>
+    where
+        Self: 'b,
     {
         MyCow::Borrowed(self)
     }
+}
 
+impl<'a, X: Space> Instance<X, BasicDecomposition> for &'a mut X {
     #[inline]
-    fn own(self) -> X {
-        self.clone()
-    }
-
-    #[inline]
-    fn cow<'b>(self) -> MyCow<'b, X> where Self : 'b {
-        MyCow::Borrowed(self)
+    fn eval_ref<'b, R>(&'b self, f: impl FnOnce(&'b X) -> R) -> R
+    where
+        X: 'b,
+        Self: 'b,
+    {
+        f(*self)
     }
 
     #[inline]
-    fn ref_instance(&self) -> <BasicDecomposition as Decomposition<X>>::Reference<'_> {
-        *self
-    }
-}
-
-impl<'a, X : Space + Clone> Instance<X, BasicDecomposition> for &'a mut X {
-    #[inline]
-    fn  decompose<'b>(self) -> <BasicDecomposition as Decomposition<X>>::Decomposition<'b>
-    where Self : 'b, X : 'b
-    {
-        EitherDecomp::Borrowed(self)
+    fn own(self) -> X::Principal {
+        self.into_owned()
     }
 
     #[inline]
-    fn own(self) -> X {
-        self.clone()
+    fn cow<'b>(self) -> MyCow<'b, X::Principal>
+    where
+        Self: 'b,
+    {
+        self.cow_owned()
     }
 
     #[inline]
-    fn cow<'b>(self) -> MyCow<'b, X> where Self : 'b, X : Clone {
-        EitherDecomp::Borrowed(self)
-    }
-
-    #[inline]
-    fn ref_instance(&self) -> <BasicDecomposition as Decomposition<X>>::Reference<'_> {
-        *self
+    fn decompose<'b>(self) -> MyCow<'b, X>
+    where
+        Self: 'b,
+    {
+        MyCow::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  decompose<'b>(self) -> <BasicDecomposition as Decomposition<X>>::Decomposition<'b>
-    where Self : 'b, X : 'b
+    fn eval_ref<'b, R>(&'b self, f: impl FnOnce(&'b X) -> R) -> R
+    where
+        X: 'b,
+        Self: 'b,
     {
-        self
-    }
-
-    #[inline]
-    fn own(self) -> X {
         match self {
-            MyCow::Borrowed(a) => a.own(),
-            MyCow::Owned(b) => b.own()
+            MyCow::Borrowed(a) => f(a),
+            MyCow::Owned(b) => f(&b),
         }
     }
 
     #[inline]
-    fn cow<'b>(self) -> MyCow<'b, X> where Self : 'b {
-        match self {
-            MyCow::Borrowed(a) => a.cow(),
-            MyCow::Owned(b) => b.cow()
-        }
+    fn own(self) -> X::Principal {
+        self.into_owned()
     }
 
     #[inline]
-    fn ref_instance(&self) -> <BasicDecomposition as Decomposition<X>>::Reference<'_> {
-        match self {
-            MyCow::Borrowed(a) => a,
-            MyCow::Owned(b) => &b,
-        }
+    fn cow<'b>(self) -> MyCow<'b, X::Principal>
+    where
+        Self: 'b,
+    {
+        self.cow_owned()
     }
-}
-
-/// Marker type for mutable decompositions to be used with [`InstanceMut`].
-pub trait DecompositionMut<X : Space> : Sized {
-    type ReferenceMut<'b> : InstanceMut<X, Self> where X : 'b;
-}
-
 
-/// Helper trait for functions to work with mutable references.
-pub trait InstanceMut<X : Space , D = <X as Space>::Decomp> : Sized where D : DecompositionMut<X> {
-    /// Returns a mutable decomposition of self.
-    fn ref_instance_mut(&mut self) -> D::ReferenceMut<'_>;
-}
-
-impl<X : Space> DecompositionMut<X> for BasicDecomposition {
-    type ReferenceMut<'b> = &'b mut X where X : 'b;
-}
-
-/// This impl may seem pointless, but allows throwaway mutable scratch variables
-impl<'a, X : Space> InstanceMut<X, BasicDecomposition> for X {
     #[inline]
-    fn ref_instance_mut(&mut self)
-        -> <BasicDecomposition as DecompositionMut<X>>::ReferenceMut<'_>
+    fn decompose<'b>(self) -> MyCow<'b, X>
+    where
+        Self: 'b,
     {
         self
     }
 }
 
-impl<'a, X : Space> InstanceMut<X, BasicDecomposition> for &'a mut X {
+/// Marker type for mutable decompositions to be used with [`InstanceMut`].
+pub trait DecompositionMut<X: Space>: Sized {
+    type ReferenceMut<'b>: InstanceMut<X, Self>
+    where
+        X: 'b;
+}
+
+/// Helper trait for functions to work with mutable references.
+pub trait InstanceMut<X: Space, D = <X as Space>::Decomp>: Sized
+where
+    D: DecompositionMut<X>,
+{
+    /// Returns a mutable decomposition of self.
+    fn ref_instance_mut(&mut self) -> D::ReferenceMut<'_>;
+}
+
+impl<X: Space> DecompositionMut<X> for BasicDecomposition {
+    type ReferenceMut<'b>
+        = &'b mut X
+    where
+        X: 'b;
+}
+
+/// This impl may seem pointless, but allows throwaway mutable scratch variables
+impl<'a, X: Space> InstanceMut<X, BasicDecomposition> for X {
     #[inline]
-    fn ref_instance_mut(&mut self)
-        -> <BasicDecomposition as DecompositionMut<X>>::ReferenceMut<'_>
-    {
+    fn ref_instance_mut(
+        &mut self,
+    ) -> <BasicDecomposition as DecompositionMut<X>>::ReferenceMut<'_> {
         self
     }
 }
+
+impl<'a, X: Space> InstanceMut<X, BasicDecomposition> for &'a mut X {
+    #[inline]
+    fn ref_instance_mut(
+        &mut self,
+    ) -> <BasicDecomposition as DecompositionMut<X>>::ReferenceMut<'_> {
+        self
+    }
+}