mut format: F)

-> fmt::Result

where F: FnMut(&A, &mut fmt::Formatter) -> fmt::Result,

D: Dimension,

S: Data<Elem=A>,

let ndim = view.dim.slice().len();

/* private nowadays

// None will be an empty iter.

let mut last_index = match view.dim.first_index() {

None => view.dim.clone(),

Some(ix) => ix,

};

for _ in 0..ndim {

try!(write!(f, "["));

}

let mut first = true;

// Simply use the indexed iterator, and take the index wraparounds

// as cues for when to add []'s and how many to add.

for (index, elt) in view.indexed_iter() {

let index = index.into_dimension();

let take_n = if ndim == 0 { 1 } else { ndim - 1 };

let mut update_index = false;

for (i, (a, b)) in index.slice()

.iter()

.take(take_n)

.zip(last_index.slice().iter())

.enumerate() {

if a != b {

// New row.

// # of ['s needed

let n = ndim - i - 1;

for _ in 0..n {

try!(write!(f, "]"));

}

try!(write!(f, ","));

if !f.alternate() {

try!(write!(f, "\n"));

}

for _ in 0..ndim - n {

try!(write!(f, " "));

}

for _ in 0..n {

try!(write!(f, "["));

}

first = true;

update_index = true;

break;

}

}

if !first {

try!(write!(f, ", "));

}

first = false;

try!(format(elt, f));

if update_index {

last_index = index;

}

}

for _ in 0..ndim {

try!(write!(f, "]"));

}

Ok(())

where S: Data<Elem=A>,

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

format_array(self, f, <_>::fmt)

}

where S: Data<Elem=A>,

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

// Add extra information for Debug

try!(format_array(self, f, <_>::fmt));

try!(write!(f, " shape={:?}, strides={:?}", self.shape(), self.strides()));

Ok(())

}

where S: Data<Elem=A>,

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

format_array(self, f, <_>::fmt)

}

where S: Data<Elem=A>,

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

format_array(self, f, <_>::fmt)

}

where S: Data<Elem=A>,

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

format_array(self, f, <_>::fmt)

}