Creating disjoint Matrix slices

I am looking at how best to implement the creation of disjoint Matrix slices.
The purpose of this would be allow in place operations with needing temporary copies of data.

Purpose is to copies such as:
m.set_column(0, m.column(1).clone_owned());

My plan would be something similar to Rust Slice,split_at_mut() which hides the nasty unsafe code.

I think this would only be implementable on Matrix with owned Storage as otherwise in is not possible to determine what is disjoint.

Several API come to mind:
One possibility would be two methods disjoint_columns, and disjoint_rowsstrong text which return pairs of MatrixSlices
More sophisticated would be to split the Matrix in disjoint rows or columns.

Does this seem a reasonable proposition?

To make this clearer here are the implementations of disjoint_columns_mut and disjoint_rows_mut.

/// Create two mutable column slices to a Matrix.
///
/// This is safe when the columns are disjoint and the Matix has StorageMut, in this case the Matrix elements
/// refered to by the two columns must be disjoint.
pub fn disjoint_columns_mut<N: RealField, R: Dim, C: Dim, S: StorageMut<N, R, C>>(m: &mut Matrix<N, R, C, S>, col1: usize, col2: usize) ->
(Matrix<N, R, U1, SliceStorageMut<N, R, U1, U1, U1>>, MatrixSliceMut<N, R, U1, S::RStride, S::CStride>)
{
    assert!(col1 != col2, "columns not disjoint");
    let col_shape = (m.data.shape().0, U1);

    unsafe {
        let col_start_ptr = m.as_mut_ptr().offset((col1 * m.nrows()) as isize);
        let data1 = SliceStorageMut::from_raw_parts(col_start_ptr, col_shape, (U1, U1));
        let col_slice1 = Matrix::from_data_statically_unchecked(data1);
        (col_slice1, m.column_mut(col2))
    }
}

/// Create two mutable row slices to a Matrix.
///
/// This is safe when the rows are disjoint and the Matix has StorageMut, in this case the Matrix elements
/// refered to by the two rows must be disjoint.
pub fn disjoint_rows_mut<N: RealField, R: Dim, C: Dim, S: StorageMut<N, R, C>>(m: &mut Matrix<N, R, C, S>, row1: usize, row2: usize) ->
(Matrix<N, U1, C, SliceStorageMut<N, U1, C, U1, R>>, MatrixSliceMut<N, U1, C, S::RStride, S::CStride>)
{
    assert!(row1 != row2, "rows not disjoint");
    let row_shape = (U1, m.data.shape().1);

    unsafe {
        let col_start_ptr = m.as_mut_ptr();
        let data1 = SliceStorageMut::from_raw_parts(col_start_ptr, row_shape, (U1, m.data.shape().0));
        let row_slice1 = Matrix::from_data_statically_unchecked(data1);
        (row_slice1, m.row_mut(row2))
     }
 }

Just found columns_range_pair and rows_range_pair.

Amazing what you find in nalgebra when you dig in the source code!