Arithmetic operations B @ A are now only implemented for owned storage B

Previously, operators like +, - etc, denoted by @ in general, were
implemented so that they allowed ArrayViewMut as the left hand side
operand. It would update the data in the view, and return the same view.

This can be confusing, and was suggested by @SuperFluffy to be removed.

We tentatively remove those implementations here.

To work around B @ A not being allowed for a mutable view `B`, you can
use B @= A instead, or the corresponding stable methods iadd, imul, etc.

Please see the Arithmetic Operations overview in the `ArrayBase` docs
for an easy to read overview.

Fixes #83

Author: bluss

examples/life.rs

@@ -40,17 +40,16 @@ fn iterate(z: &mut Board, scratch: &mut Board) {
     // compute number of neighbors
     let mut neigh = scratch.view_mut();
     neigh.assign_scalar(&0);
-    let neigh = neigh
-    + z.slice(s![0..-2, 0..-2])
-    + z.slice(s![0..-2, 1..-1])
-    + z.slice(s![0..-2, 2..  ])
+    neigh.iadd(&z.slice(s![0..-2, 0..-2]));
+    neigh.iadd(&z.slice(s![0..-2, 1..-1]));
+    neigh.iadd(&z.slice(s![0..-2, 2..  ]));
 
-    + z.slice(s![1..-1, 0..-2])
-    + z.slice(s![1..-1, 2..  ])
+    neigh.iadd(&z.slice(s![1..-1, 0..-2]));
+    neigh.iadd(&z.slice(s![1..-1, 2..  ]));
 
-    + z.slice(s![2..  , 0..-2])
-    + z.slice(s![2..  , 1..-1])
-    + z.slice(s![2..  , 2..  ]);
+    neigh.iadd(&z.slice(s![2..  , 0..-2]));
+    neigh.iadd(&z.slice(s![2..  , 1..-1]));
+    neigh.iadd(&z.slice(s![2..  , 2..  ]));
 
     // birth where n = 3 and z[i] = 0,
     // survive where n = 2 || n = 3 and z[i] = 1

src/lib.rs

@@ -296,15 +296,17 @@ pub type Ixs = isize;
 ///
 /// Since the trait implementations are hard to overview, here is a summary.
 ///
-/// Let `A` be an array or view of any kind. Let `B` be a mutable
-/// array (that is, either `OwnedArray`, `RcArray`, or `ArrayViewMut`)
+/// Let `A` be an array or view of any kind. Let `B` be an array
+/// with owned storage (either `OwnedArray` or `RcArray`).
+/// Let `C` be an array with mutable data (either `OwnedArray`, `RcArray`
+/// or `ArrayViewMut`).
 /// The following combinations of operands
 /// are supported for an arbitrary binary operator denoted by `@`.
 ///
 /// - `&A @ &A` which produces a new `OwnedArray`
 /// - `B @ A` which consumes `B`, updates it with the result, and returns it
 /// - `B @ &A` which consumes `B`, updates it with the result, and returns it
-/// - `B @= &A` which performs an arithmetic operation in place
+/// - `C @= &A` which performs an arithmetic operation in place
 ///   (requires `features = "assign_ops"`)
 ///
 /// The trait [`Scalar`](trait.Scalar.html) marks types that can be used in arithmetic
@@ -313,7 +315,7 @@ pub type Ixs = isize;
 ///
 /// - `&A @ K` or `K @ &A` which produces a new `OwnedArray`
 /// - `B @ K` or `K @ B` which consumes `B`, updates it with the result and returns it
-/// - `B @= K` which performs an arithmetic operation in place
+/// - `C @= K` which performs an arithmetic operation in place
 ///   (requires `features = "assign_ops"`)
 ///
 /// ## Broadcasting
@@ -2549,12 +2551,14 @@ macro_rules! impl_binary_op(
 /// between `self` and `rhs`,
 /// and return the result (based on `self`).
 ///
+/// `self` must be an `OwnedArray` or `RcArray`.
+///
 /// If their shapes disagree, `rhs` is broadcast to the shape of `self`.
 ///
 /// **Panics** if broadcasting isn’t possible.
 impl<A, S, S2, D, E> $trt<ArrayBase<S2, E>> for ArrayBase<S, D>
     where A: Clone + $trt<A, Output=A>,
-          S: DataMut<Elem=A>,
+          S: DataOwned<Elem=A> + DataMut,
           S2: Data<Elem=A>,
           D: Dimension,
           E: Dimension,
@@ -2616,9 +2620,11 @@ impl<'a, A, S, S2, D, E> $trt<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D>
 #[doc=$doc]
 /// between `self` and the scalar `x`,
 /// and return the result (based on `self`).
+///
+/// `self` must be an `OwnedArray` or `RcArray`.
 impl<A, S, D, B> $trt<B> for ArrayBase<S, D>
     where A: Clone + $trt<B, Output=A>,
-          S: DataMut<Elem=A>,
+          S: DataOwned<Elem=A> + DataMut,
           D: Dimension,
           B: Clone + Scalar,
 {