diff --git a/src/lib.rs b/src/lib.rs
index 2ab74aa..4d3b454 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,64 +1,268 @@
 #![doc = include_str!("../README.md")]
 #![no_std] // <-- yeah, in case you wondered - there you are, feel free to use it
 
-type TNum<const N: usize> = typenum::Const<N>;
-type AlgNum<const N: usize> = nalgebra::Const<N>;
-type ArrLen<const N: usize> = <TNum<N> as generic_array::IntoArrayLength>::ArrayLength;
+/// Nothing to see here
+///
+/// Congratulations, you've found a cute seal pup!
+///
+/// <img src="https://www.startpage.com/av/proxy-image?piurl=https%3A%2F%2Fi.pinimg.com%2Foriginals%2Fb8%2F2f%2F61%2Fb82f6130b6a8d6afbefc07b08e1f8750.jpg&sp=1731807377Td567a79c382f033584e92b2a748b4f2c5e21b672386c3919dd66700457951351" alt="cute baby seal!" width="10%"/>
+///
+/// This tiny thing ensures that [`Conv`], [`Corr`] and [`Comp`] traits are not implemented outside of this crate. There's no strict reasoning for this now, but I might want to use some **unsafe** operations in these trait implementations in the future.
+#[derive(Debug)]
+pub struct Seal(());
 
-use generic_array::{ArrayLength, GenericArray, IntoArrayLength};
+/// Convenience trait, used to defining type **conv**ersions
+///
+/// Also, this is the only bound to [`GenericMatrix`] type alias, meaning that all of the following are valid [`GenericMatrix`]es:
+/// ```rust
+/// # use generic_array_storage::GenericMatrix;
+/// type NalgebraMatrix = GenericMatrix<i32, nalgebra::U3, nalgebra::U4>;
+/// type TypenumMatrix = GenericMatrix<i32, typenum::U3, typenum::U4>;
+/// type TypenumConstMatrix = GenericMatrix<i32, typenum::Const<3>, typenum::Const<3>>;
+/// // (nalgebra::Const are actually aliased by nalgebra::{U1, U2, ...})
+/// ```
+///
+/// If you need to convert between them, see [`Comp`].
+///
+/// This trait is sealed.
+pub trait Conv {
+    /// See [`Seal`]
+    const SEAL: Seal;
+
+    /// A core `usize` corresponding to length/size
+    const NUM: usize;
+
+    /// [`nalgebra`]-faced type (matrix dimension)
+    type Nalg: Dim;
+
+    /// [`typenum`]/[`generic_array`]-faced type (generic array length)
+    type ArrLen: ArrayLength;
+
+    /// Constructor method used in [`nalgebra`] implementations
+    fn new_nalg() -> Self::Nalg;
+}
+
+impl<const N: usize> Conv for nalgebra::Const<N>
+where
+    typenum::Const<N>: generic_array::IntoArrayLength,
+{
+    const SEAL: Seal = Seal(());
+
+    const NUM: usize = N;
+
+    type Nalg = nalgebra::Const<N>;
+
+    type ArrLen = <typenum::Const<N> as generic_array::IntoArrayLength>::ArrayLength;
+
+    fn new_nalg() -> Self::Nalg {
+        nalgebra::Const::<N>
+    }
+}
+
+impl<const N: usize> Conv for typenum::Const<N>
+where
+    typenum::Const<N>: generic_array::IntoArrayLength,
+{
+    const SEAL: Seal = Seal(());
+
+    const NUM: usize = N;
+
+    type Nalg = nalgebra::Const<N>;
+
+    type ArrLen = <typenum::Const<N> as generic_array::IntoArrayLength>::ArrayLength;
+
+    fn new_nalg() -> Self::Nalg {
+        nalgebra::Const::<N>
+    }
+}
+
+impl Conv for typenum::UTerm {
+    const SEAL: Seal = Seal(());
+
+    const NUM: usize = 0;
+
+    type Nalg = nalgebra::Const<0>;
+
+    type ArrLen = Self;
+
+    fn new_nalg() -> Self::Nalg {
+        nalgebra::Const::<0>
+    }
+}
+
+impl<U> Conv for typenum::UInt<U, B0>
+where
+    U: Conv,
+    U::Nalg: nalgebra::dimension::DimMul<nalgebra::U2>,
+    U::ArrLen: core::ops::Mul<typenum::U2>,
+    typenum::Prod<U::ArrLen, typenum::U2>: ArrayLength,
+{
+    const SEAL: Seal = Seal(());
+
+    const NUM: usize = 2 * U::NUM;
+
+    type Nalg = <U::Nalg as nalgebra::dimension::DimMul<nalgebra::U2>>::Output;
+
+    type ArrLen = typenum::operator_aliases::Prod<U::ArrLen, typenum::U2>;
+
+    fn new_nalg() -> Self::Nalg {
+        Self::Nalg::from_usize(Self::NUM)
+    }
+}
+
+impl<U> Conv for typenum::UInt<U, B1>
+where
+    typenum::UInt<U, B0>: Conv,
+    <typenum::UInt<U, B0> as Conv>::Nalg: nalgebra::dimension::DimAdd<nalgebra::U1>,
+    <typenum::UInt<U, B0> as Conv>::ArrLen: core::ops::Add<typenum::U1>,
+    typenum::Sum<<typenum::UInt<U, B0> as Conv>::ArrLen, typenum::U1>: ArrayLength,
+{
+    const SEAL: Seal = Seal(());
+
+    const NUM: usize = 1 + <typenum::UInt<U, B0> as Conv>::NUM;
+
+    type Nalg =
+        <<typenum::UInt<U, B0> as Conv>::Nalg as nalgebra::dimension::DimAdd<nalgebra::U1>>::Output;
+
+    type ArrLen =
+        typenum::operator_aliases::Sum<<typenum::UInt<U, B0> as Conv>::ArrLen, typenum::U1>;
+
+    fn new_nalg() -> Self::Nalg {
+        Self::Nalg::from_usize(Self::NUM)
+    }
+}
+
+/// Convenience trait, used to signify that particular [`Conv`] implementor **corr**esponds to some integer. This has to be a separate trait, since integer correspondence is not something we always need, and the actual point of this crate is to get rid of such bounds. This trait is a way to reintroduce it, if you happen to need that.
+///
+/// Trait defines methods for core array to/from [`GenericArray`] conversion. Implementations are expected to be trivial, i.e. [`GenericArray`] method call or unsafe transmute backed by some explanation.
+///
+/// This trait is sealed.
+pub trait Corr<const N: usize>: Conv {
+    /// See [`Seal`]
+    const SEAL: Seal;
+
+    /// Converts core array to [`GenericArray`]
+    fn array_to_generic<E>(array: [E; N]) -> GenericArray<E, Self::ArrLen>;
+
+    /// Converts [`GenericArray`] to core array
+    fn generic_to_array<E>(generic: GenericArray<E, Self::ArrLen>) -> [E; N];
+}
+
+impl<const N: usize, T> Corr<N> for T
+where
+    T: Conv,
+    typenum::Const<N>: IntoArrayLength<ArrayLength = T::ArrLen>,
+{
+    const SEAL: Seal = Seal(());
+
+    #[inline]
+    fn array_to_generic<E>(array: [E; N]) -> GenericArray<E, Self::ArrLen> {
+        GenericArray::from_array(array)
+    }
+
+    #[inline]
+    fn generic_to_array<E>(generic: GenericArray<E, Self::ArrLen>) -> [E; N] {
+        generic.into_array()
+    }
+}
+
+/// Convenience trait, used to signify that a pair of [`Conv`] implementors are **comp**atible with each other, meaning that [`GenericArray`]s sized with them can be converted [`Comp::fwd`] and [`Comp::bwd`].
+///
+/// This trait is sealed.
+pub trait Comp<Other: Conv>: Conv {
+    /// See [`Seal`]
+    const SEAL: Seal;
+
+    /// "forward" conversion
+    fn fwd<E>(value: GenericArray<E, Self::ArrLen>) -> GenericArray<E, Other::ArrLen>;
+
+    /// "backward" conversion
+    fn bwd<E>(value: GenericArray<E, Other::ArrLen>) -> GenericArray<E, Self::ArrLen>;
+}
+
+impl<T: Conv, Other: Conv> Comp<Other> for T
+where
+    T: Conv<ArrLen = Other::ArrLen>,
+{
+    const SEAL: Seal = Seal(());
+
+    #[inline]
+    fn fwd<E>(value: GenericArray<E, Self::ArrLen>) -> GenericArray<E, <Other as Conv>::ArrLen> {
+        value
+    }
+
+    #[inline]
+    fn bwd<E>(value: GenericArray<E, <Other as Conv>::ArrLen>) -> GenericArray<E, Self::ArrLen> {
+        value
+    }
+}
+
+use generic_array::{functional::FunctionalSequence, ArrayLength, GenericArray, IntoArrayLength};
 use nalgebra::{
-    allocator::Allocator, ArrayStorage, Dim, IsContiguous, Matrix, Owned, RawStorage, ToTypenum,
+    allocator::Allocator, ArrayStorage, Dim, IsContiguous, Matrix, Owned, RawStorage,
+    RawStorageMut, Scalar, Storage,
 };
+use typenum::{B0, B1};
+
+/// A stack-allocated storage, of [`typenum`]-backed col-major two dimensional array
+///
+/// This struct is transparent and completely public, since it has nothing to hide! Note that [`GenericArray`] is transparent itself, so this struct effectively has the same layout as a two-dimensional array of the corresponding size.
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct GenericArrayStorage<T, R: Conv, C: Conv>(
+    pub GenericArray<GenericArray<T, R::ArrLen>, C::ArrLen>,
+);
 
-/// A stack-allocated storage, of [`typenum`]-backed row-major two dimensional array
-#[derive(Debug, Clone)]
-pub struct GenericArrayStorage<T, R, C>(GenericArray<GenericArray<T, R>, C>)
+impl<T, R: Conv, C: Conv> Clone for GenericArrayStorage<T, R, C>
 where
-    R: ArrayLength,
-    C: ArrayLength;
+    T: Clone,
+    GenericArray<GenericArray<T, R::ArrLen>, C::ArrLen>: Clone,
+{
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
 
-impl<T, R, C> Copy for GenericArrayStorage<T, R, C>
+impl<T, R: Conv, C: Conv> Copy for GenericArrayStorage<T, R, C>
 where
     T: Copy,
-    R: ArrayLength,
-    R::ArrayType<T>: Copy,
-    C: ArrayLength,
-    C::ArrayType<GenericArray<T, R>>: Copy,
+    <R::ArrLen as ArrayLength>::ArrayType<T>: Copy,
+    <C::ArrLen as ArrayLength>::ArrayType<GenericArray<T, R::ArrLen>>: Copy,
 {
 }
 
+impl<T, R: Conv, C: Conv> AsRef<[T]> for GenericArrayStorage<T, R, C> {
+    fn as_ref(&self) -> &[T] {
+        GenericArray::slice_from_chunks(&self.0)
+    }
+}
+
+impl<T, R: Conv, C: Conv> AsMut<[T]> for GenericArrayStorage<T, R, C> {
+    fn as_mut(&mut self) -> &mut [T] {
+        GenericArray::slice_from_chunks_mut(&mut self.0)
+    }
+}
+
 #[allow(unsafe_code, reason = "nalgebra storage traits are unsafe")]
-unsafe impl<const R: usize, const C: usize, T> RawStorage<T, AlgNum<R>, AlgNum<C>>
-    for GenericArrayStorage<T, ArrLen<R>, ArrLen<C>>
-where
-    TNum<R>: IntoArrayLength,
-    TNum<C>: IntoArrayLength,
-    AlgNum<R>: Dim,
-    AlgNum<C>: Dim,
-{
-    type RStride = AlgNum<1>;
+unsafe impl<T, R: Conv, C: Conv> RawStorage<T, R::Nalg, C::Nalg> for GenericArrayStorage<T, R, C> {
+    type RStride = nalgebra::U1;
 
-    type CStride = AlgNum<R>;
+    type CStride = R::Nalg;
 
     fn ptr(&self) -> *const T {
-        // SAFETY:
-        // Trait doc does not state it, but I assume that pointer should be valid and non-null.
-        //
-        // So this actually returns cast of [`NonNull::dangling`], in case array contains no elements
-        if let Some(first) = self.0.first() {
-            // there is at least one element - grab it's pointer
-            first.as_ptr()
+        if self.0.is_empty() {
+            core::ptr::NonNull::<T>::dangling().as_ptr()
         } else {
-            core::ptr::NonNull::<T>::dangling().as_ptr().cast_const()
+            self.0.as_ptr().cast()
         }
     }
 
-    fn shape(&self) -> (nalgebra::Const<R>, nalgebra::Const<C>) {
-        (nalgebra::Const, nalgebra::Const)
+    fn shape(&self) -> (R::Nalg, C::Nalg) {
+        (R::new_nalg(), C::new_nalg())
     }
 
     fn strides(&self) -> (Self::RStride, Self::CStride) {
-        (nalgebra::Const, nalgebra::Const)
+        (nalgebra::U1, R::new_nalg())
     }
 
     fn is_contiguous(&self) -> bool {
@@ -66,69 +270,48 @@ where
     }
 
     unsafe fn as_slice_unchecked(&self) -> &[T] {
-        core::slice::from_raw_parts(
-            <Self as nalgebra::RawStorage<T, nalgebra::Const<R>, nalgebra::Const<C>>>::ptr(self),
-            R * C,
-        )
+        self.as_ref()
     }
 }
 
 #[allow(unsafe_code, reason = "nalgebra storage traits are unsafe")]
-unsafe impl<const R: usize, const C: usize, T>
-    nalgebra::RawStorageMut<T, nalgebra::Const<R>, nalgebra::Const<C>>
-    for GenericArrayStorage<T, ArrLen<R>, ArrLen<C>>
-where
-    typenum::Const<R>: IntoArrayLength,
-    typenum::Const<C>: IntoArrayLength,
-    nalgebra::Const<R>: Dim,
-    nalgebra::Const<C>: Dim,
+unsafe impl<T, R: Conv, C: Conv> RawStorageMut<T, R::Nalg, C::Nalg>
+    for GenericArrayStorage<T, R, C>
 {
     fn ptr_mut(&mut self) -> *mut T {
-        self.0
-            .first_mut()
-            .map_or(core::ptr::NonNull::<T>::dangling().as_ptr(), |first| {
-                first.as_mut_ptr()
-            })
+        if self.0.is_empty() {
+            core::ptr::NonNull::<T>::dangling().as_ptr()
+        } else {
+            self.0.as_mut_ptr().cast()
+        }
     }
 
     unsafe fn as_mut_slice_unchecked(&mut self) -> &mut [T] {
-        core::slice::from_raw_parts_mut(
-            <Self as nalgebra::RawStorageMut<T, nalgebra::Const<R>, nalgebra::Const<C>>>::ptr_mut(
-                self,
-            ),
-            R * C,
-        )
+        // SAFETY: see struct's doc - it's layout is guaranteed to be like that of a two-dimensional array
+        self.as_mut()
     }
 }
 
 #[allow(unsafe_code, reason = "nalgebra storage traits are unsafe")]
-unsafe impl<const R: usize, const C: usize, T: nalgebra::Scalar>
-    nalgebra::Storage<T, nalgebra::Const<R>, nalgebra::Const<C>>
-    for GenericArrayStorage<T, ArrLen<R>, ArrLen<C>>
+unsafe impl<T: Scalar, R: Conv, C: Conv> Storage<T, R::Nalg, C::Nalg>
+    for GenericArrayStorage<T, R, C>
 where
-    T: Clone,
-    typenum::Const<R>: IntoArrayLength,
-    typenum::Const<C>: IntoArrayLength,
-    nalgebra::Const<R>: Dim,
-    nalgebra::Const<C>: Dim,
+    nalgebra::DefaultAllocator: nalgebra::allocator::Allocator<R::Nalg, C::Nalg>,
 {
-    fn into_owned(self) -> Owned<T, nalgebra::Const<R>, nalgebra::Const<C>>
+    fn into_owned(self) -> Owned<T, R::Nalg, C::Nalg>
     where
-        nalgebra::DefaultAllocator:
-            nalgebra::allocator::Allocator<nalgebra::Const<R>, nalgebra::Const<C>>,
+        nalgebra::DefaultAllocator: nalgebra::allocator::Allocator<R::Nalg, C::Nalg>,
     {
-        let init: [[T; R]; C] = self.0.into_array().map(GenericArray::into_array);
         nalgebra::DefaultAllocator::allocate_from_iterator(
-            nalgebra::Const::<R>,
-            nalgebra::Const::<C>,
-            init.into_iter().flatten(),
+            R::new_nalg(),
+            C::new_nalg(),
+            self.0.into_iter().flatten(),
         )
     }
 
-    fn clone_owned(&self) -> Owned<T, nalgebra::Const<R>, nalgebra::Const<C>>
+    fn clone_owned(&self) -> Owned<T, R::Nalg, C::Nalg>
     where
-        nalgebra::DefaultAllocator:
-            nalgebra::allocator::Allocator<nalgebra::Const<R>, nalgebra::Const<C>>,
+        nalgebra::DefaultAllocator: nalgebra::allocator::Allocator<R::Nalg, C::Nalg>,
     {
         self.clone().into_owned()
     }
@@ -139,131 +322,127 @@ where
 }
 
 #[allow(unsafe_code, reason = "nalgebra storage traits are unsafe")]
-unsafe impl<R: ArrayLength, C: ArrayLength, T: nalgebra::Scalar> IsContiguous
-    for GenericArrayStorage<T, R, C>
+unsafe impl<R: Conv, C: Conv, T: nalgebra::Scalar> IsContiguous for GenericArrayStorage<T, R, C> {}
+
+/// Alias to [`nalgebra::Matrix`], completely "hiding" `const usize`s away. See crate's documentation on how this is possible.
+pub type GenericMatrix<T, R, C> =
+    nalgebra::Matrix<T, <R as Conv>::Nalg, <C as Conv>::Nalg, GenericArrayStorage<T, R, C>>;
+
+impl<T, const AR: usize, const AC: usize, R: Conv + Corr<AR>, C: Conv + Corr<AC>>
+    From<[[T; AR]; AC]> for GenericArrayStorage<T, R, C>
 {
+    fn from(value: [[T; AR]; AC]) -> Self {
+        GenericArrayStorage(C::array_to_generic(value.map(R::array_to_generic)))
+    }
 }
 
-/// Alias to [`nalgebra::Matrix`], completely "hinding" `const usize`s away. See crate's documentation on how this is possible.
-pub type GenericMatrix<T, R, C> = nalgebra::Matrix<
-    T,
-    R,
-    C,
-    GenericArrayStorage<
-        T,
-        <<R as ToTypenum>::Typenum as IntoArrayLength>::ArrayLength,
-        <<C as ToTypenum>::Typenum as IntoArrayLength>::ArrayLength,
-    >,
->;
-
-impl<T, const R: usize, const C: usize> From<[[T; R]; C]>
-    for GenericArrayStorage<
-        T,
-        <<AlgNum<R> as ToTypenum>::Typenum as IntoArrayLength>::ArrayLength,
-        <<AlgNum<C> as ToTypenum>::Typenum as IntoArrayLength>::ArrayLength,
-    >
-where
-    AlgNum<R>: ToTypenum,
-    TNum<R>: IntoArrayLength,
-    <AlgNum<R> as ToTypenum>::Typenum:
-        IntoArrayLength<ArrayLength = <TNum<R> as IntoArrayLength>::ArrayLength>,
-    AlgNum<C>: ToTypenum,
-    TNum<C>: IntoArrayLength,
-    <AlgNum<C> as ToTypenum>::Typenum:
-        IntoArrayLength<ArrayLength = <TNum<C> as IntoArrayLength>::ArrayLength>,
+impl<T, const AR: usize, const AC: usize, R: Conv + Corr<AR>, C: Conv + Corr<AC>>
+    From<GenericArrayStorage<T, R, C>> for [[T; AR]; AC]
 {
-    fn from(value: [[T; R]; C]) -> Self {
-        GenericArrayStorage(GenericArray::from_array(
-            value.map(GenericArray::from_array),
-        ))
+    fn from(value: GenericArrayStorage<T, R, C>) -> Self {
+        C::generic_to_array(value.0).map(R::generic_to_array)
     }
 }
 
-impl<T, const R: usize, const C: usize>
-    From<
-        GenericArrayStorage<
-            T,
-            <<AlgNum<R> as ToTypenum>::Typenum as IntoArrayLength>::ArrayLength,
-            <<AlgNum<C> as ToTypenum>::Typenum as IntoArrayLength>::ArrayLength,
-        >,
-    > for [[T; R]; C]
-where
-    AlgNum<R>: ToTypenum,
-    TNum<R>: IntoArrayLength,
-    <AlgNum<R> as ToTypenum>::Typenum:
-        IntoArrayLength<ArrayLength = <TNum<R> as IntoArrayLength>::ArrayLength>,
-    AlgNum<C>: ToTypenum,
-    TNum<C>: IntoArrayLength,
-    <AlgNum<C> as ToTypenum>::Typenum:
-        IntoArrayLength<ArrayLength = <TNum<C> as IntoArrayLength>::ArrayLength>,
+/// [`GenericMatrix`]-conversion trait intended for core arrays and regular [`nalgebra`] matrices
+pub trait GenericMatrixFromExt<R: Conv, C: Conv> {
+    /// Type of the elements.
+    ///
+    /// This an associated type for the simple reason that is can be such.
+    type T;
+
+    /// Creates [`GenericMatrix`] from core Rust array.
+    fn into_generic_matrix(self) -> GenericMatrix<Self::T, R, C>;
+}
+
+impl<T, const AR: usize, const AC: usize, R: Conv + Corr<AR>, C: Conv + Corr<AC>>
+    GenericMatrixFromExt<R, C> for [[T; AR]; AC]
 {
-    fn from(
-        value: GenericArrayStorage<
-            T,
-            <<AlgNum<R> as ToTypenum>::Typenum as IntoArrayLength>::ArrayLength,
-            <<AlgNum<C> as ToTypenum>::Typenum as IntoArrayLength>::ArrayLength,
-        >,
-    ) -> Self {
-        value.0.into_array().map(GenericArray::into_array)
+    type T = T;
+
+    fn into_generic_matrix(self) -> GenericMatrix<Self::T, R, C> {
+        GenericMatrix::from_data(self.into())
     }
 }
 
-/// Extension trait, providing convenience operations conversion operations so easier intertop with rest of the ecosystem.
-pub trait GenericMatrixExt<T, const R: usize, const C: usize>
-where
-    AlgNum<R>: ToTypenum,
-    TNum<R>: IntoArrayLength,
-    <AlgNum<R> as ToTypenum>::Typenum:
-        IntoArrayLength<ArrayLength = <TNum<R> as IntoArrayLength>::ArrayLength>,
-    AlgNum<C>: ToTypenum,
-    TNum<C>: IntoArrayLength,
-    <AlgNum<C> as ToTypenum>::Typenum:
-        IntoArrayLength<ArrayLength = <TNum<C> as IntoArrayLength>::ArrayLength>,
+// Yes, I AM sorry for the `T: Clone` here.
+impl<T: Clone, R: Conv, C: Conv, S: RawStorage<T, R::Nalg, C::Nalg> + IsContiguous>
+    GenericMatrixFromExt<R, C> for Matrix<T, R::Nalg, C::Nalg, S>
 {
-    /// Creates [`GenericMatrix`] from core Rust array.
-    fn from_array(array: [[T; R]; C]) -> Self;
+    type T = T;
 
-    /// Creates [`GenericMatrix`] from regular `nalgebra` matrix, backed up by [`nalgebra::ArrayStorage`].
-    fn from_regular(
-        regular: Matrix<T, AlgNum<R>, AlgNum<C>, nalgebra::ArrayStorage<T, R, C>>,
-    ) -> Self;
+    fn into_generic_matrix(self) -> GenericMatrix<Self::T, R, C> {
+        let (rows, rest) = GenericArray::<_, R::ArrLen>::chunks_from_slice(self.as_slice());
+        debug_assert!(rest.is_empty(), "Should be no leftover");
+        let arr = GenericArray::<_, C::ArrLen>::from_slice(rows);
+        let storage = GenericArrayStorage(arr.clone());
+        GenericMatrix::from_data(storage)
+    }
+}
+
+/// Convenience trait defining [`GenericMatrix`] conversions.
+pub trait GenericMatrixExt {
+    /// Type of the elements.
+    ///
+    /// This an associated type for the simple reason that is can be such.
+    type T;
+
+    /// Type defining rows count
+    type R: Conv;
 
-    /// Converts [`GenericMatrix`] into core Rust array.
-    fn into_array(self) -> [[T; R]; C];
+    /// Type defining column count
+    type C: Conv;
 
-    /// Converts [`GenericMatrix`] into regular `nalgebra` matrix, backed up by [`nalgebra::ArrayStorage`].
-    fn into_regular(self) -> Matrix<T, AlgNum<R>, AlgNum<C>, nalgebra::ArrayStorage<T, R, C>>;
+    /// Changes type of [`GenericMatrix`] to a different row and column count descriptors.
+    fn conv<NewR: Conv + Comp<Self::R>, NewC: Conv + Comp<Self::C>>(
+        self,
+    ) -> GenericMatrix<Self::T, NewR, NewC>;
+
+    /// Converts [`GenericMatrix`] into core array-backed regular [`nalgebra`] matrix
+    fn into_array_matrix<const AR: usize, const AC: usize>(
+        self,
+    ) -> Matrix<
+        Self::T,
+        nalgebra::Const<AR>,
+        nalgebra::Const<AC>,
+        nalgebra::ArrayStorage<Self::T, AR, AC>,
+    >
+    where
+        Self::R: Corr<AR>,
+        Self::C: Corr<AC>;
 }
 
-impl<T, const R: usize, const C: usize> GenericMatrixExt<T, R, C>
-    for GenericMatrix<T, AlgNum<R>, AlgNum<C>>
-where
-    AlgNum<R>: ToTypenum,
-    TNum<R>: IntoArrayLength,
-    <AlgNum<R> as ToTypenum>::Typenum:
-        IntoArrayLength<ArrayLength = <TNum<R> as IntoArrayLength>::ArrayLength>,
-    AlgNum<C>: ToTypenum,
-    TNum<C>: IntoArrayLength,
-    <AlgNum<C> as ToTypenum>::Typenum:
-        IntoArrayLength<ArrayLength = <TNum<C> as IntoArrayLength>::ArrayLength>,
-{
-    fn from_array(array: [[T; R]; C]) -> Self {
-        Self::from_data(array.into())
-    }
+impl<T, R: Conv, C: Conv> GenericMatrixExt for GenericMatrix<T, R, C> {
+    type T = T;
 
-    fn from_regular(
-        regular: Matrix<T, AlgNum<R>, AlgNum<C>, nalgebra::ArrayStorage<T, R, C>>,
-    ) -> Self {
-        Self::from_data(regular.data.0.into())
-    }
+    type R = R;
+
+    type C = C;
 
-    fn into_array(self) -> [[T; R]; C] {
-        self.data.into()
+    fn conv<NewR: Conv + Comp<Self::R>, NewC: Conv + Comp<Self::C>>(
+        self,
+    ) -> GenericMatrix<Self::T, NewR, NewC> {
+        let data = self.data.0;
+        let mapped_cols = data.map(NewR::bwd);
+        let full_mapped = NewC::bwd(mapped_cols);
+        GenericMatrix::from_data(GenericArrayStorage(full_mapped))
     }
 
-    fn into_regular(self) -> Matrix<T, AlgNum<R>, AlgNum<C>, nalgebra::ArrayStorage<T, R, C>> {
-        let array_storage: nalgebra::ArrayStorage<T, R, C> = ArrayStorage(self.data.into());
-        Matrix::from_data(array_storage)
+    fn into_array_matrix<const AR: usize, const AC: usize>(
+        self,
+    ) -> Matrix<
+        Self::T,
+        nalgebra::Const<AR>,
+        nalgebra::Const<AC>,
+        nalgebra::ArrayStorage<Self::T, AR, AC>,
+    >
+    where
+        Self::R: Corr<AR>,
+        Self::C: Corr<AC>,
+    {
+        let data = self.data;
+        let array: [[Self::T; AR]; AC] = data.into();
+        Matrix::from_data(ArrayStorage(array))
     }
 }
 
diff --git a/src/tests.rs b/src/tests.rs
index 12512f2..aedcaa0 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -1,6 +1,4 @@
-use nalgebra::{ArrayStorage, Matrix};
-
-use super::{GenericMatrix, GenericMatrixExt};
+use crate::{GenericMatrix, GenericMatrixExt, GenericMatrixFromExt};
 
 #[test]
 fn from_regular() {
@@ -10,7 +8,7 @@ fn from_regular() {
     ];
 
     let generic_matrix: GenericMatrix<i32, nalgebra::U2, nalgebra::U3> =
-        GenericMatrix::from_regular(regular_matrix);
+        regular_matrix.into_generic_matrix();
 
     for i in 0..2 {
         for j in 0..3 {
@@ -27,10 +25,9 @@ fn from_regular() {
 #[test]
 fn into_regular() {
     let generic_matrix: GenericMatrix<i32, nalgebra::U3, nalgebra::U2> =
-        GenericMatrix::from_array([[1, 2, 5], [3, -4, 0]]);
+        [[1, 2, 5], [3, -4, 0]].into_generic_matrix();
 
-    let regular_matrix: Matrix<i32, nalgebra::U3, nalgebra::U2, ArrayStorage<i32, 3, 2>> =
-        generic_matrix.into_regular();
+    let regular_matrix = generic_matrix.into_array_matrix::<3, 2>();
 
     for i in 0..3 {
         for j in 0..2 {
@@ -46,10 +43,11 @@ fn into_regular() {
 
 #[test]
 fn transposition() {
-    let a = GenericMatrix::from_regular(nalgebra::matrix![
+    let a: GenericMatrix<_, nalgebra::U2, nalgebra::U3> = nalgebra::matrix![
         1, 2, 4;
         5, -7, 0;
-    ]);
+    ]
+    .into_generic_matrix();
 
     let a_tr = a.transpose();
 
@@ -62,20 +60,22 @@ fn transposition() {
 
 #[test]
 fn to_owned() {
-    let a = GenericMatrix::from_regular(nalgebra::matrix![
+    let a: GenericMatrix<_, typenum::Const<2>, typenum::Const<3>> = nalgebra::matrix![
         1, 2, 4;
         5, -7, 0;
-    ]);
+    ]
+    .into_generic_matrix();
 
     assert_eq!(a.clone_owned(), nalgebra::matrix![1, 2, 4; 5, -7, 0]);
 }
 
 #[test]
 fn addition() {
-    let a = GenericMatrix::from_regular(nalgebra::matrix![
+    let a: GenericMatrix<_, typenum::U2, typenum::U3> = nalgebra::matrix![
         1, 2, 4;
         5, -7, 0;
-    ]);
+    ]
+    .into_generic_matrix();
 
     let sum = a + a;
 
@@ -84,10 +84,11 @@ fn addition() {
 
 #[test]
 fn subtraction() {
-    let a = GenericMatrix::from_regular(nalgebra::matrix![
+    let a: GenericMatrix<_, nalgebra::Const<2>, nalgebra::Const<3>> = nalgebra::matrix![
         1, 2, 4;
         5, -7, 0;
-    ]);
+    ]
+    .into_generic_matrix();
 
     let sum = a - a;
 
@@ -96,10 +97,11 @@ fn subtraction() {
 
 #[test]
 fn multiplication() {
-    let a = GenericMatrix::from_regular(nalgebra::matrix![
+    let a: GenericMatrix<_, nalgebra::Const<2>, nalgebra::Const<3>> = nalgebra::matrix![
         1, 2, 4;
         5, -7, 0;
-    ]);
+    ]
+    .into_generic_matrix();
 
     let sum = a * a.transpose();
 
@@ -109,10 +111,11 @@ fn multiplication() {
 #[allow(clippy::float_cmp)]
 #[test]
 fn determinant() {
-    let a = GenericMatrix::from_regular(nalgebra::matrix![
+    let a: GenericMatrix<_, typenum::U2, typenum::U2> = nalgebra::matrix![
         1.0, 3.0;
         -4.0, 4.0;
-    ]);
+    ]
+    .into_generic_matrix();
 
     assert_eq!(a.determinant(), 16.0);
 }
@@ -120,13 +123,52 @@ fn determinant() {
 #[allow(clippy::float_cmp)]
 #[test]
 fn inversion() {
-    let a = GenericMatrix::from_regular(nalgebra::matrix![
-        1.0, 2.0;
-        5.0, -7.0;
-    ]);
+    let a: GenericMatrix<_, typenum::U2, typenum::U2> = nalgebra::matrix![
+        1.0, 3.0;
+        -4.0, 4.0;
+    ]
+    .into_generic_matrix();
 
     assert_eq!(
         a.try_inverse().expect("Should be able to inverse"),
-        nalgebra::matrix![-7.0, -5.0; -2.0, 1.0].transpose() / -17.0
+        nalgebra::matrix![4.0, 4.0; -3.0, 1.0].transpose() / 16.0
     );
 }
+
+#[allow(
+    unused_variables,
+    unused_assignments,
+    reason = "Test is the compilation"
+)]
+#[test]
+fn comp() {
+    let data = [[1, 2, 3], [-4, 5, -0], [-232, 343, 232_111]];
+
+    let mut typenum_matrix: GenericMatrix<_, typenum::U3, typenum::U3> = data.into_generic_matrix();
+    let mut nalgebra_matrix: GenericMatrix<_, nalgebra::U3, nalgebra::U3> =
+        data.into_generic_matrix();
+    let mut typenum_const_matrix: GenericMatrix<_, typenum::Const<3>, typenum::Const<3>> =
+        data.into_generic_matrix();
+    // nalgebra's const and alias types are identical
+
+    // note, that none of them can be directly assigned to each other:
+    // typenum_matrix = nalgebra_matrix;
+    // typenum_const_matrix = typenum_matrix;
+    // nalgebra_matrix = typenum_const_matrix;
+    // (all of the above lines do fail)
+
+    // but assignments will succeed, once conversion is used:
+    typenum_matrix = nalgebra_matrix.conv();
+    typenum_const_matrix = typenum_matrix.conv();
+    nalgebra_matrix = typenum_const_matrix.conv();
+
+    // of there's matrix of different dimensions,
+    let some_different_matrix: GenericMatrix<_, typenum::U1, typenum::U3> =
+        nalgebra::matrix![1, 2, 3].into_generic_matrix();
+
+    // all of the assignments fail:
+    // typenum_matrix = some_different_matrix;
+    // nalgebra_matrix = some_different_matrix;
+    // typenum_const_matrix = some_different_matrix;
+    // (all of the above lines do fail)
+}