Add examples of eval order for compound assignment

Author: traviscross

src/expressions/operator-expr.md

@@ -906,6 +906,40 @@ r[expr.compound-assign.primitive-order]
 If both types are primitives and the expression is non-generic (i.e., directly uses concrete types), then the modifying operand will be evaluated first followed by the assigned operand.
 It will then set the value of the assigned operand's place to the value of performing the operation of the operator with the values of the assigned operand and modifying operand.
 
+```rust
+# use core::{num::Wrapping, ops::AddAssign};
+#
+fn f1(x: (u8,)) {
+    let mut order: Vec<u64> = vec![];
+    // The RHS is evaluated first as both operands are of primitive
+    // type.
+    { order.push(2); x }.0 += { order.push(1); x }.0;
+    assert_eq!((1..=2).into_iter().collect::<Vec<_>>(), order);
+}
+
+fn f2(x: (Wrapping<u8>,)) {
+    let mut order: Vec<u64> = vec![];
+    // The LHS is evaluated first as `Wrapping<_>` is not a primitive
+    // type.
+    { order.push(1); x }.0 += { order.push(2); (0u8,) }.0;
+    assert_eq!((1..=2).into_iter().collect::<Vec<_>>(), order);
+}
+
+fn f3<T: AddAssign<u8> + Copy>(x: (T,)) {
+    let mut order: Vec<u64> = vec![];
+    // The LHS is evaluated first as one of the operands is a generic
+    // parameter.
+    { order.push(1); x }.0 += { order.push(2); (0u8,) }.0;
+    assert_eq!((1..=2).into_iter().collect::<Vec<_>>(), order);
+}
+
+fn main() {
+    f1((0u8,));
+    f2((Wrapping(0u8),));
+    f3::<u8>((0u8,));
+}
+```
+
 > [!NOTE]
 > This is different than other expressions in that the right operand is evaluated before the left one.