# HG changeset patch
# User Tuomo Valkonen <tuomov@iki.fi>
# Date 1756947305 18000
# Node ID 221728aeeb7ea0c02217517c9bdb9401b1ea5179
# Parent  114ecdf63ce5f01b9cbed89e2285390cd4b20d28
either

diff -r 114ecdf63ce5 -r 221728aeeb7e src/instance.rs
--- a/src/instance.rs	Wed Sep 03 19:37:15 2025 -0500
+++ b/src/instance.rs	Wed Sep 03 19:55:05 2025 -0500
@@ -340,6 +340,20 @@
         X: 'b,
         Self: 'b;
 
+    #[inline]
+    /// Evaluates `f` or `g` depending on whether a reference or owned value is available.
+    fn either<'b, R>(
+        self,
+        f: impl FnOnce(D::Decomposition<'b>) -> R,
+        g: impl FnOnce(D::Reference<'b>) -> R,
+    ) -> R
+    where
+        X: 'b,
+        Self: 'b,
+    {
+        self.eval_decompose(f)
+    }
+
     /// Returns an owned instance of `X`, cloning or converting non-true instances when necessary.
     fn own(self) -> X::Principal;
 
@@ -361,27 +375,17 @@
     {
         f(&*self.cow())
     }
+}
 
+impl<X: Space> Instance<X, BasicDecomposition> for X {
     #[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::Principal) -> R,
-        g: impl FnOnce(&X::Principal) -> R,
-    ) -> R
+    fn either<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R, _g: impl FnOnce(&'b X) -> R) -> R
     where
         Self: 'b,
     {
-        match self.cow() {
-            EitherDecomp::Owned(x) => f(x),
-            EitherDecomp::Borrowed(x) => g(x),
-        }
+        f(MyCow::Owned(self))
     }
-}
 
-impl<X: Space> Instance<X, BasicDecomposition> for X {
     #[inline]
     fn eval_decompose<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R) -> R
     where
@@ -416,6 +420,14 @@
 
 impl<'a, X: Space> Instance<X, BasicDecomposition> for &'a X {
     #[inline]
+    fn either<'b, R>(self, _f: impl FnOnce(MyCow<'b, X>) -> R, g: impl FnOnce(&'b X) -> R) -> R
+    where
+        Self: 'b,
+    {
+        g(self)
+    }
+
+    #[inline]
     fn eval_decompose<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R) -> R
     where
         X: 'b,
@@ -449,6 +461,14 @@
 
 impl<'a, X: Space> Instance<X, BasicDecomposition> for &'a mut X {
     #[inline]
+    fn either<'b, R>(self, _f: impl FnOnce(MyCow<'b, X>) -> R, g: impl FnOnce(&'b X) -> R) -> R
+    where
+        Self: 'b,
+    {
+        g(self)
+    }
+
+    #[inline]
     fn eval_decompose<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R) -> R
     where
         X: 'b,
@@ -482,6 +502,14 @@
 
 impl<'a, X: Space> Instance<X, BasicDecomposition> for MyCow<'a, X> {
     #[inline]
+    fn either<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R, _g: impl FnOnce(&'b X) -> R) -> R
+    where
+        Self: 'b,
+    {
+        f(self)
+    }
+
+    #[inline]
     fn eval_decompose<'b, R>(self, f: impl FnOnce(MyCow<'b, X>) -> R) -> R
     where
         X: 'b,
diff -r 114ecdf63ce5 -r 221728aeeb7e src/nalgebra_support.rs
--- a/src/nalgebra_support.rs	Wed Sep 03 19:37:15 2025 -0500
+++ b/src/nalgebra_support.rs	Wed Sep 03 19:55:05 2025 -0500
@@ -146,6 +146,19 @@
     ShapeConstraint: StridesOk<E, M, K, S1> + StridesOk<E, M, K, S2>,
 {
     #[inline]
+    fn either<'b, R>(
+        self,
+        f: impl FnOnce(OMatrix<E, M, K>) -> R,
+        _g: impl FnOnce(MatrixView<'b, E, M, K, Dyn, Dyn>) -> R,
+    ) -> R
+    where
+        Self: 'b,
+    {
+        // TODO: should not turn non-owned matrices into owned
+        f(self.into_owned())
+    }
+
+    #[inline]
     fn eval_decompose<'b, R>(self, f: impl FnOnce(OMatrix<E, M, K>) -> R) -> R
     where
         Self: 'b,
@@ -190,6 +203,18 @@
     DefaultAllocator: Allocator<M, K>,
     ShapeConstraint: StridesOk<E, M, K, S1> + StridesOk<E, M, K, S2>,
 {
+    #[inline]
+    fn either<'b, R>(
+        self,
+        _f: impl FnOnce(OMatrix<E, M, K>) -> R,
+        g: impl FnOnce(MatrixView<'b, E, M, K, Dyn, Dyn>) -> R,
+    ) -> R
+    where
+        Self: 'b,
+    {
+        g(self.as_view())
+    }
+
     fn eval_decompose<'b, R>(self, f: impl FnOnce(OMatrix<E, M, K>) -> R) -> R
     where
         Self: 'b,