Fix doc examples where we use array.as_slice

Author: kngwyu

src/array.rs

@@ -155,7 +155,7 @@ impl<T, D> PyArray<T, D> {
             | self.check_flag(npyffi::NPY_ARRAY_F_CONTIGUOUS)
     }
 
-    pub fn is_forran_contiguous(&self) -> bool {
+    pub fn is_fotran_contiguous(&self) -> bool {
         self.check_flag(npyffi::NPY_ARRAY_F_CONTIGUOUS)
     }
 
@@ -180,7 +180,7 @@ impl<T, D> PyArray<T, D> {
     /// }
     /// let gil = Python::acquire_gil();
     /// let array = return_py_array();
-    /// assert_eq!(array.as_ref(gil.python()).as_slice(), &[0, 0, 0, 0, 0]);
+    /// assert_eq!(array.as_ref(gil.python()).as_slice().unwrap(), &[0, 0, 0, 0, 0]);
     /// # }
     /// ```
     pub fn to_owned(&self) -> Py<Self> {
@@ -413,13 +413,24 @@ impl<T: TypeNum, D: Dimension> PyArray<T, D> {
     }
 
     /// Get the immutable view of the internal data of `PyArray`, as slice.
+    ///
+    /// Returns `ErrorKind::NotContiguous` if the internal array is not contiguous.
     /// # Example
     /// ```
     /// # extern crate pyo3; extern crate numpy; fn main() {
-    /// use numpy::PyArray;
+    /// use numpy::{PyArray, PyArray1};
+    /// use pyo3::types::IntoPyDict;
     /// let gil = pyo3::Python::acquire_gil();
-    /// let py_array = PyArray::arange(gil.python(), 0, 4, 1).reshape([2, 2]).unwrap();
-    /// assert_eq!(py_array.as_slice(), &[0, 1, 2, 3]);
+    /// let py = gil.python();
+    /// let py_array = PyArray::arange(py, 0, 4, 1).reshape([2, 2]).unwrap();
+    /// assert_eq!(py_array.as_slice().unwrap(), &[0, 1, 2, 3]);
+    /// let locals = [("np", numpy::get_array_module(py).unwrap())].into_py_dict(py);
+    /// let not_contiguous: &PyArray1<f32> = py
+    ///     .eval("np.zeros(10)[::2]", Some(locals), None)
+    ///     .unwrap()
+    ///     .downcast_ref()
+    ///     .unwrap();
+    /// assert!(not_contiguous.as_slice().is_err());
     /// # }
     /// ```
     pub fn as_slice(&self) -> Result<&[T], ErrorKind> {
@@ -654,7 +665,7 @@ impl<T: TypeNum> PyArray<T, Ix1> {
     /// let gil = pyo3::Python::acquire_gil();
     /// let array = [1, 2, 3, 4, 5];
     /// let pyarray = PyArray::from_slice(gil.python(), &array);
-    /// assert_eq!(pyarray.as_slice(), &[1, 2, 3, 4, 5]);
+    /// assert_eq!(pyarray.as_slice().unwrap(), &[1, 2, 3, 4, 5]);
     /// # }
     /// ```
     pub fn from_slice<'py>(py: Python<'py>, slice: &[T]) -> &'py Self {
@@ -675,7 +686,7 @@ impl<T: TypeNum> PyArray<T, Ix1> {
     /// let gil = pyo3::Python::acquire_gil();
     /// let vec = vec![1, 2, 3, 4, 5];
     /// let pyarray = PyArray::from_vec(gil.python(), vec);
-    /// assert_eq!(pyarray.as_slice(), &[1, 2, 3, 4, 5]);
+    /// assert_eq!(pyarray.as_slice().unwrap(), &[1, 2, 3, 4, 5]);
     /// # }
     /// ```
     pub fn from_vec<'py>(py: Python<'py>, vec: Vec<T>) -> &'py Self {
@@ -693,7 +704,7 @@ impl<T: TypeNum> PyArray<T, Ix1> {
     /// let gil = pyo3::Python::acquire_gil();
     /// let vec = vec![1, 2, 3, 4, 5];
     /// let pyarray = PyArray::from_iter(gil.python(), vec.iter().map(|&x| x));
-    /// assert_eq!(pyarray.as_slice(), &[1, 2, 3, 4, 5]);
+    /// assert_eq!(pyarray.as_slice().unwrap(), &[1, 2, 3, 4, 5]);
     /// # }
     /// ```
     pub fn from_exact_iter(py: Python, iter: impl ExactSizeIterator<Item = T>) -> &Self {
@@ -720,7 +731,7 @@ impl<T: TypeNum> PyArray<T, Ix1> {
     /// let gil = pyo3::Python::acquire_gil();
     /// let set: BTreeSet<u32> = [4, 3, 2, 5, 1].into_iter().cloned().collect();
     /// let pyarray = PyArray::from_iter(gil.python(), set);
-    /// assert_eq!(pyarray.as_slice(), &[1, 2, 3, 4, 5]);
+    /// assert_eq!(pyarray.as_slice().unwrap(), &[1, 2, 3, 4, 5]);
     /// # }
     /// ```
     pub fn from_iter(py: Python, iter: impl IntoIterator<Item = T>) -> &Self {
@@ -895,7 +906,7 @@ impl<T: TypeNum, D> PyArray<T, D> {
     /// let pyarray_f = PyArray::arange(gil.python(), 2.0, 5.0, 1.0);
     /// let pyarray_i = PyArray::<i64, _>::new(gil.python(), [3], false);
     /// assert!(pyarray_f.copy_to(pyarray_i).is_ok());
-    /// assert_eq!(pyarray_i.as_slice(), &[2, 3, 4]);
+    /// assert_eq!(pyarray_i.as_slice().unwrap(), &[2, 3, 4]);
     /// # }
     pub fn copy_to<U: TypeNum>(&self, other: &PyArray<U, D>) -> Result<(), ErrorKind> {
         let self_ptr = self.as_array_ptr();
@@ -916,7 +927,7 @@ impl<T: TypeNum, D> PyArray<T, D> {
     /// let gil = pyo3::Python::acquire_gil();
     /// let pyarray_f = PyArray::arange(gil.python(), 2.0, 5.0, 1.0);
     /// let pyarray_i = pyarray_f.cast::<i32>(false).unwrap();
-    /// assert_eq!(pyarray_i.as_slice(), &[2, 3, 4]);
+    /// assert_eq!(pyarray_i.as_slice().unwrap(), &[2, 3, 4]);
     /// # }
     pub fn cast<'py, U: TypeNum>(
         &'py self,
@@ -1003,9 +1014,9 @@ impl<T: TypeNum + AsPrimitive<f64>> PyArray<T, Ix1> {
     /// use numpy::PyArray;
     /// let gil = pyo3::Python::acquire_gil();
     /// let pyarray = PyArray::arange(gil.python(), 2.0, 4.0, 0.5);
-    /// assert_eq!(pyarray.as_slice(), &[2.0, 2.5, 3.0, 3.5]);
+    /// assert_eq!(pyarray.as_slice().unwrap(), &[2.0, 2.5, 3.0, 3.5]);
     /// let pyarray = PyArray::arange(gil.python(), -2, 4, 3);
-    /// assert_eq!(pyarray.as_slice(), &[-2, 1]);
+    /// assert_eq!(pyarray.as_slice().unwrap(), &[-2, 1]);
     /// # }
     pub fn arange<'py>(py: Python<'py>, start: T, stop: T, step: T) -> &'py Self {
         unsafe {

src/convert.rs

@@ -23,7 +23,7 @@ use npyffi::npy_intp;
 /// use numpy::{PyArray, IntoPyArray};
 /// let gil = pyo3::Python::acquire_gil();
 /// let py_array = vec![1, 2, 3].into_pyarray(gil.python());
-/// assert_eq!(py_array.as_slice(), &[1, 2, 3]);
+/// assert_eq!(py_array.as_slice().unwrap(), &[1, 2, 3]);
 /// assert!(py_array.resize(100).is_err()); // You can't resize owned-by-rust array.
 /// # }
 /// ```
@@ -75,7 +75,7 @@ where
 /// use numpy::{PyArray, ToPyArray};
 /// let gil = pyo3::Python::acquire_gil();
 /// let py_array = vec![1, 2, 3].to_pyarray(gil.python());
-/// assert_eq!(py_array.as_slice(), &[1, 2, 3]);
+/// assert_eq!(py_array.as_slice().unwrap(), &[1, 2, 3]);
 /// # }
 /// ```
 pub trait ToPyArray {

src/npyffi/array.rs

@@ -28,7 +28,7 @@ const CAPSULE_NAME: &str = "_ARRAY_API";
 /// unsafe {
 ///     PY_ARRAY_API.PyArray_Sort(array.as_array_ptr(), 0, NPY_SORTKIND::NPY_QUICKSORT);
 /// }
-/// assert_eq!(array.as_slice(), &[2, 3, 4])
+/// assert_eq!(array.as_slice().unwrap(), &[2, 3, 4])
 /// # }
 /// ```
 pub static PY_ARRAY_API: PyArrayAPI = PyArrayAPI {