Rename `Rotation::unwrap` to `Rotation::into_inner` and deprecate `Rotation::unwrap`

See #460

src/geometry/quaternion_conversion.rs

@@ -228,7 +228,7 @@ impl<N: Real> From<UnitQuaternion<N>> for Matrix4<N> {
 impl<N: Real> From<UnitQuaternion<N>> for Matrix3<N> {
     #[inline]
     fn from(q: UnitQuaternion<N>) -> Matrix3<N> {
-        q.to_rotation_matrix().unwrap()
+        q.to_rotation_matrix().into_inner()
     }
 }
 

src/geometry/rotation.rs

@@ -154,7 +154,7 @@ where DefaultAllocator: Allocator<N, D, D>
     /// # use nalgebra::{Rotation2, Rotation3, Vector3, Matrix2, Matrix3};
     /// # use std::f32;
     /// let rot = Rotation3::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
-    /// let mat = rot.unwrap();
+    /// let mat = rot.into_inner();
     /// let expected = Matrix3::new(0.8660254, -0.5,      0.0,
     ///                             0.5,       0.8660254, 0.0,
     ///                             0.0,       0.0,       1.0);
@@ -162,12 +162,20 @@ where DefaultAllocator: Allocator<N, D, D>
     ///
     ///
     /// let rot = Rotation2::new(f32::consts::FRAC_PI_6);
-    /// let mat = rot.unwrap();
+    /// let mat = rot.into_inner();
     /// let expected = Matrix2::new(0.8660254, -0.5,
     ///                             0.5,       0.8660254);
     /// assert_eq!(mat, expected);
     /// ```
     #[inline]
+    pub fn into_inner(self) -> MatrixN<N, D> {
+        self.matrix
+    }
+
+    /// Unwraps the underlying matrix.
+    /// Deprecated: Use [Rotation::into_inner] instead.
+    #[deprecated(note="use `.into_inner()` instead")]
+    #[inline]
     pub fn unwrap(self) -> MatrixN<N, D> {
         self.matrix
     }

src/geometry/rotation_conversion.rs

@@ -227,7 +227,7 @@ impl<N: Real> From<Rotation2<N>> for Matrix3<N> {
 impl<N: Real> From<Rotation2<N>> for Matrix2<N> {
     #[inline]
     fn from(q: Rotation2<N>) -> Matrix2<N> {
-        q.unwrap()
+        q.into_inner()
     }
 }
 
@@ -241,6 +241,6 @@ impl<N: Real> From<Rotation3<N>> for Matrix4<N> {
 impl<N: Real> From<Rotation3<N>> for Matrix3<N> {
     #[inline]
     fn from(q: Rotation3<N>) -> Matrix3<N> {
-        q.unwrap()
+        q.into_inner()
     }
 }

src/geometry/rotation_ops.rs

@@ -46,9 +46,9 @@ md_impl_all!(
     Mul, mul;
     (D, D), (D, D) for D: DimName;
     self: Rotation<N, D>, right: Rotation<N, D>, Output = Rotation<N, D>;
-    [val val] => Rotation::from_matrix_unchecked(self.unwrap() * right.unwrap());
+    [val val] => Rotation::from_matrix_unchecked(self.into_inner() * right.into_inner());
-    [ref val] => Rotation::from_matrix_unchecked(self.matrix() * right.unwrap());
+    [ref val] => Rotation::from_matrix_unchecked(self.matrix() * right.into_inner());
-    [val ref] => Rotation::from_matrix_unchecked(self.unwrap() * right.matrix());
+    [val ref] => Rotation::from_matrix_unchecked(self.into_inner() * right.matrix());
     [ref ref] => Rotation::from_matrix_unchecked(self.matrix() * right.matrix());
 );
 
@@ -71,9 +71,9 @@ md_impl_all!(
     where DefaultAllocator: Allocator<N, D1, C2>
     where ShapeConstraint: AreMultipliable<D1, D1, R2, C2>;
     self: Rotation<N, D1>, right: Matrix<N, R2, C2, SB>, Output = MatrixMN<N, D1, C2>;
-    [val val] => self.unwrap() * right;
+    [val val] => self.into_inner() * right;
     [ref val] => self.matrix() * right;
-    [val ref] => self.unwrap() * right;
+    [val ref] => self.into_inner() * right;
     [ref ref] => self.matrix() * right;
 );
 
@@ -84,8 +84,8 @@ md_impl_all!(
     where DefaultAllocator: Allocator<N, R1, D2>
     where ShapeConstraint:  AreMultipliable<R1, C1, D2, D2>;
     self: Matrix<N, R1, C1, SA>, right: Rotation<N, D2>, Output = MatrixMN<N, R1, D2>;
-    [val val] => self * right.unwrap();
+    [val val] => self * right.into_inner();
-    [ref val] => self * right.unwrap();
+    [ref val] => self * right.into_inner();
     [val ref] => self * right.matrix();
     [ref ref] => self * right.matrix();
 );
@@ -112,9 +112,9 @@ md_impl_all!(
     where DefaultAllocator: Allocator<N, D>
     where ShapeConstraint:  AreMultipliable<D, D, D, U1>;
     self: Rotation<N, D>, right: Point<N, D>, Output = Point<N, D>;
-    [val val] => self.unwrap() * right;
+    [val val] => self.into_inner() * right;
     [ref val] => self.matrix() * right;
-    [val ref] => self.unwrap() * right;
+    [val ref] => self.into_inner() * right;
     [ref ref] => self.matrix() * right;
 );
 
@@ -125,9 +125,9 @@ md_impl_all!(
     where DefaultAllocator: Allocator<N, D>
     where ShapeConstraint:  AreMultipliable<D, D, D, U1>;
     self: Rotation<N, D>, right: Unit<Vector<N, D, S>>, Output = Unit<VectorN<N, D>>;
-    [val val] => Unit::new_unchecked(self.unwrap() * right.into_inner());
+    [val val] => Unit::new_unchecked(self.into_inner() * right.into_inner());
     [ref val] => Unit::new_unchecked(self.matrix() * right.into_inner());
-    [val ref] => Unit::new_unchecked(self.unwrap() * right.as_ref());
+    [val ref] => Unit::new_unchecked(self.into_inner() * right.as_ref());
     [ref ref] => Unit::new_unchecked(self.matrix() * right.as_ref());
 );
 
@@ -138,7 +138,7 @@ md_assign_impl_all!(
     MulAssign, mul_assign;
     (D, D), (D, D) for D: DimName;
     self: Rotation<N, D>, right: Rotation<N, D>;
-    [val] => self.matrix_mut_unchecked().mul_assign(right.unwrap());
+    [val] => self.matrix_mut_unchecked().mul_assign(right.into_inner());
     [ref] => self.matrix_mut_unchecked().mul_assign(right.matrix());
 );
 
@@ -146,7 +146,7 @@ md_assign_impl_all!(
     DivAssign, div_assign;
     (D, D), (D, D) for D: DimName;
     self: Rotation<N, D>, right: Rotation<N, D>;
-    [val] => self.matrix_mut_unchecked().mul_assign(right.inverse().unwrap());
+    [val] => self.matrix_mut_unchecked().mul_assign(right.inverse().into_inner());
     [ref] => self.matrix_mut_unchecked().mul_assign(right.inverse().matrix());
 );
 
@@ -160,7 +160,7 @@ md_assign_impl_all!(
     MulAssign, mul_assign;
     (R1, C1), (C1, C1) for R1: DimName, C1: DimName;
     self: MatrixMN<N, R1, C1>, right: Rotation<N, C1>;
-    [val] => self.mul_assign(right.unwrap());
+    [val] => self.mul_assign(right.into_inner());
     [ref] => self.mul_assign(right.matrix());
 );
 
@@ -168,6 +168,6 @@ md_assign_impl_all!(
     DivAssign, div_assign;
     (R1, C1), (C1, C1) for R1: DimName, C1: DimName;
     self: MatrixMN<N, R1, C1>, right: Rotation<N, C1>;
-    [val] => self.mul_assign(right.inverse().unwrap());
+    [val] => self.mul_assign(right.inverse().into_inner());
     [ref] => self.mul_assign(right.inverse().matrix());
 );

src/geometry/unit_complex.rs

@@ -320,6 +320,6 @@ impl<N: Real> From<UnitComplex<N>> for Matrix3<N> {
 impl<N: Real> From<UnitComplex<N>> for Matrix2<N> {
     #[inline]
     fn from(q: UnitComplex<N>) -> Matrix2<N> {
-        q.to_rotation_matrix().unwrap()
+        q.to_rotation_matrix().into_inner()
     }
 }