remove though-box behavior for reverse, transpose, and rotate

Author: kaikalii

changelog.md

@@ -14,6 +14,8 @@ This version is not yet released. If you are reading this on the website, then t
 - **Breaking Change** - [`under ⍜`](https://uiua.org/docs/under)[`shape △`](https://uiua.org/docs/shape) now tiles the original array to match the new shape instead of [`reshape ↯`](https://uiua.org/docs/reshape)ing
 - **Breaking Change** - [`dip ⊙`](https://uiua.org/docs/dip) and [`on ⟜`](https://uiua.org/docs/on) function packs no longer apply their modifier to the leftmost function
   - This change makes most usecases of these function packs cleaner, as `A⊙(B|C)` changes to `⊙(A|B|C)` and likewise for [`on ⟜`](https://uiua.org/docs/on)
+- **Breaking Change** - [`reverse ⇌`](https://uiua.org/docs/reverse), [`transpose ⍉`](https://uiua.org/docs/transpose), and [`rotate ↻`](https://uiua.org/docs/rotate) no longer work through boxes
+  - This caused consistency issues and was rarely used anyway
 - **Breaking Change** - The FFI function API has been changed considerably, read more in the documentation for [`&ffi`](https://uiua.org/docs/&ffi), [`&memcpy`](https://uiua.org/docs/&memcpy), and [`&memset`](https://uiua.org/docs/&memset)
 - Add [`parse ⋕`](https://uiua.org/docs/parse) subscripts to parse strings in different bases
 - Allow for private [modules](https://uiua.org/tutorial/modules#private-scoped-modules), [imports](https://uiua.org/tutorial/modules#private-imports), and [data definitions](https://uiua.org/tutorial/datadefs#visibility)

parser/src/defs.rs

@@ -602,9 +602,7 @@ primitive!(
     ///
     /// ex: ⇌1_2_3_9
     /// ex: ⇌[1_2 3_4 5_6]
-    /// [reverse] works through boxes.
-    /// ex: ⇌ □[1 2 3]
-    /// ex: ≡⇌ {1_2_3_4 5_6_7 8_9}
+    /// ex: ⇌"Hello!"
     (1, Reverse, MonadicArray, ("reverse", '⇌')),
     /// Make an array 1-dimensional
     ///
@@ -674,9 +672,6 @@ primitive!(
     ///
     /// ex: ⍉.[1_2 3_4 5_6]
     /// ex: ⍉.[[1_2 3_4] [5_6 7_8]]
-    /// [transpose] works through boxes.
-    /// ex: ⍉ □[1_2_3 4_5_6]
-    /// ex: ≡⍉ {[1_2 3_4] [1_2_3 4_5_6]}
     /// [un][transpose] transposes in the opposite direction.
     /// This is useful for arrays with rank `greater than``2`.
     /// ex: °⍉ .⊟.[1_2_3 4_5_6]
@@ -1184,10 +1179,6 @@ primitive!(
     ///   :   ↻ 2 [1 2 3 4 5]
     /// ex: ⬚0↻ 1_2 .↯4_5⇡20
     ///
-    /// [rotate] works through boxes.
-    /// ex: ↻1 □[1 2 3 4]
-    /// ex: ≡↻1 {1_2_3 4_5_6}
-    ///
     /// If the rotation amount is rank `2` or greater, multiple copies of the rotated array will be made, each rotated by a different row of the rotation amount.
     /// ex: ↻ [[1] [2] [4]] [0 0 0 0 0 0 1]
     ///   : ↻ ≡¤1_2_4       [0 0 0 0 0 0 1]

src/algorithm/dyadic/mod.rs

@@ -9,7 +9,7 @@ use std::{
     borrow::Cow,
     cmp::Ordering,
     hash::{DefaultHasher, Hash, Hasher},
-    iter::{once, repeat_n, repeat_with},
+    iter::{once, repeat_n},
     mem::{replace, swap, take},
 };
 
@@ -1084,15 +1084,6 @@ impl Value {
             Value::Byte(b) => b.rotate_depth(by_ints()?, depth, forward, env)?,
             Value::Complex(b) => b.rotate_depth(by_ints()?, depth, forward, env)?,
             Value::Char(b) => b.rotate_depth(by_ints()?, depth, forward, env)?,
-            Value::Box(b) if b.rank() == depth => {
-                let row_shape: Shape = self.shape.iter().skip(depth).copied().collect();
-                for (rot, Boxed(val)) in repeat_with(|| self.row_shaped_slices(row_shape.clone()))
-                    .flatten()
-                    .zip(b.data.as_mut_slice())
-                {
-                    rot.rotate_depth(val, 0, forward, env)?;
-                }
-            }
             Value::Box(a) => a.rotate_depth(by_ints()?, depth, forward, env)?,
         }
         rotated.meta.take_sorted_flags();

src/algorithm/monadic/mod.rs

@@ -1108,13 +1108,7 @@ impl Value {
         self.reverse_depth(0);
     }
     pub(crate) fn reverse_depth(&mut self, depth: usize) {
-        self.generic_mut_deep(
-            |a| a.reverse_depth(depth),
-            |a| a.reverse_depth(depth),
-            |a| a.reverse_depth(depth),
-            |a| a.reverse_depth(depth),
-            |a| a.reverse_depth(depth),
-        )
+        val_as_arr!(self, |arr| arr.reverse_depth(depth))
     }
 }
 
@@ -1169,13 +1163,7 @@ impl<T: ArrayValue> Array<T> {
 impl Value {
     /// Transpose the value
     pub fn transpose(&mut self) {
-        self.generic_mut_deep(
-            Array::transpose,
-            Array::transpose,
-            Array::transpose,
-            Array::transpose,
-            Array::transpose,
-        )
+        val_as_arr!(self, |arr| arr.transpose());
     }
     pub(crate) fn transpose_depth(&mut self, depth: usize, amnt: i32) {
         match self {

src/algorithm/zip.rs

@@ -440,13 +440,10 @@ pub fn each(ops: Ops, env: &mut Uiua) -> UiuaResult {
 
 pub(crate) fn each1(f: SigNode, mut xs: Value, env: &mut Uiua) -> UiuaResult {
     if let Some((f, ..)) = f_mon_fast_fn(&f.node, env) {
-        let maybe_through_boxes = matches!(&xs, Value::Box(..));
-        if !maybe_through_boxes {
-            let rank = xs.rank();
-            let val = f(xs, rank, env)?;
-            env.push(val);
-            return Ok(());
-        }
+        let rank = xs.rank();
+        let val = f(xs, rank, env)?;
+        env.push(val);
+        return Ok(());
     }
     let outputs = f.sig.outputs();
     let mut new_values = multi_output(outputs, Vec::with_capacity(xs.shape.elements()));
@@ -653,21 +650,15 @@ pub fn rows1(f: SigNode, mut xs: Value, depth: usize, inv: bool, env: &mut Uiua)
     if !inv {
         if let Some((f, mut d)) = f_mon_fast_fn(&f.node, env) {
             d += depth;
-            let maybe_through_boxes = matches!(&xs, Value::Box(arr) if arr.rank() <= d + 1);
-            if !maybe_through_boxes {
-                let val = f(xs, d + 1, env)?;
-                env.push(val);
-                return Ok(());
-            }
+            let val = f(xs, d + 1, env)?;
+            env.push(val);
+            return Ok(());
         } else if let Some((f, mut d)) = f_mon2_fast_fn(&f.node, env) {
             d += depth;
-            let maybe_through_boxes = matches!(&xs, Value::Box(arr) if arr.rank() <= d + 1);
-            if !maybe_through_boxes {
-                let (xs, ys) = f(xs, d + 1, env)?;
-                env.push(ys);
-                env.push(xs);
-                return Ok(());
-            }
+            let (xs, ys) = f(xs, d + 1, env)?;
+            env.push(ys);
+            env.push(xs);
+            return Ok(());
         }
     }
     let outputs = f.sig.outputs();

src/value.rs

@@ -443,28 +443,6 @@ impl Value {
     pub(crate) fn slice_rows(&self, start: usize, end: usize) -> Self {
         val_as_arr!(self, |arr| arr.slice_rows(start, end).into())
     }
-    pub(crate) fn generic_mut_deep<T>(
-        &mut self,
-        n: impl FnOnce(&mut Array<f64>) -> T,
-        b: impl FnOnce(&mut Array<u8>) -> T,
-        co: impl FnOnce(&mut Array<Complex>) -> T,
-        ch: impl FnOnce(&mut Array<char>) -> T,
-        f: impl FnOnce(&mut Array<Boxed>) -> T,
-    ) -> T {
-        match self {
-            Self::Num(array) => n(array),
-            Self::Byte(array) => b(array),
-            Self::Complex(array) => co(array),
-            Self::Char(array) => ch(array),
-            Self::Box(array) => {
-                if let Some(Boxed(value)) = array.as_scalar_mut() {
-                    value.generic_mut_deep(n, b, co, ch, f)
-                } else {
-                    f(array)
-                }
-            }
-        }
-    }
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn generic_bin_into<T, E>(
         self,

tests/box.ua

@@ -44,19 +44,3 @@
 
 ⍤⤙≍ 5 ◇∘ □5
 ⍤⤙≍ □5 °◇∘ 5
-
-⍤⤙≍ {{5_6 7_8} {1_2 3_4}} ⇌ {{1_2 3_4} {5_6 7_8}}
-⍤⤙≍ {{3_4 1_2} {7_8 5_6}} ≡⍜°□⇌ {{1_2 3_4} {5_6 7_8}}
-⍤⤙≍ {{3_4 1_2} {7_8 5_6}} ≡⇌ {{1_2 3_4} {5_6 7_8}}
-⍤⤙≍ {{3_4 1_2} {7_8 5_6}} ≡⍜°□⇌♭ {{1_2 3_4} {5_6 7_8}}
-⍤⤙≍ {{3_4 1_2} {7_8 5_6}} ≡⇌♭ {{1_2 3_4} {5_6 7_8}}
-⍤⤙≍ {{3_4 1_2} {7_8 5_6}} ≡⍜°□⇌ {{1_2 3_4} {5_6 7_8}}
-⍤⤙≍ {{3_4 1_2} {7_8 5_6}} ≡⇌ {{1_2 3_4} {5_6 7_8}}
-
-⍤⤙≍ {"olleh" "dlrow"} ≡⇌{"hello" "world"}
-⍤⤙≍ {"olleh" "dlrow"} ≡(⇌){"hello" "world"}
-⍤⤙≍ ¤{"olleh" "dlrow"} ≡₀⇌¤{"hello" "world"}
-⍤⤙≍ ¤{"olleh" "dlrow"} ≡₀(⇌)¤{"hello" "world"}
-
-⍤⤙≍ □[2 3 1] ↻1 □[1 2 3]
-⍤⤙≍ {2_3_1 5_6_4} ≡↻1 {1_2_3 4_5_6}

tests/dyadic.ua

@@ -62,8 +62,8 @@
 ⍤⤙≍ [] ↻1_1[]
 ⍤⤙≍ °△0_0 ↻1°△0_0
 ⍤⤙≍ ⊃≡↻⬚0≡↻ °⊏°△⊟.5
-⍤⤙≍ □[2 3 1] ↻1 □[1 2 3]
-⍤⤙≍ {↻1⇡4 ↻2⇡5} ≡↻ [1 2] {⇡4 ⇡5}
+⍤⤙≍ □[2 3 1] ⍚↻1 □[1 2 3]
+⍤⤙≍ {↻1⇡4 ↻2⇡5} ⍚↻ [1 2] {⇡4 ⇡5}
 ⍤⤙≍ ↯3_3 1 /+♭₃ ↻°⊡ ⬚0↯3_3 1
 ⍤⤙≍ ["abc" "bc " "c  "] ⬚@ ↻≡¤°⊏ "abc"
 ⍤⤙≍ ["abc" " ab" "  a"] ⬚@ ⌝↻≡¤°⊏ "abc"

tests/monadic.ua

@@ -45,8 +45,8 @@
 ⍤⤙≍ ⊃⍉°(⍉⍉⍉) ↯2_3_4_5⇡120
 ⍤⤙≍ ⊃°⍉(⍉⍉⍉) ↯2_3_4_5⇡120
 ⍤⤙≍ ⍉⍉⍉⍉ . ↯2_3_4_5⇡120
-⍤⤙≍ □[1_3 2_4] ⍉□[1_2 3_4]
-⍤⤙≍ {[1_3 2_4] [5_7 6_8]} ≡⍉{[1_2 3_4] [5_6 7_8]}
+⍤⤙≍ □[1_3 2_4] ⍚⍉□[1_2 3_4]
+⍤⤙≍ {[1_3 2_4] [5_7 6_8]} ⍚⍉{[1_2 3_4] [5_6 7_8]}
 ⍤⤙≍ ⊃⍜⍉⇌⍜(⍉⍉⍉)⇌ [[1 2 3] [4 5 6] [7 8 9]]
 
 # Subscripted length

todo.md

@@ -6,6 +6,7 @@
   - Fix rename
   - Fix goto references
 - Sided `join`
+- Sided `box`
 - `table` subscripts for rank selection
 - Mixed subscripts
   - `bracket`