hash labels in node values

Author: kaikalii

changelog.md

@@ -30,9 +30,6 @@ This version is not yet released. If you are reading this on the website, then t
 - Add the [`exponential ₑ`](https://uiua.org/docs/exponential) function, which computes the exponential function
 - Deprecate [`logarithm ₙ`](https://uiua.org/docs/logarithm) in favor of [`exponential ₑ`](https://uiua.org/docs/exponential)
 - Remove experimental `ln` in favor of [`exponential ₑ`](https://uiua.org/docs/exponential)
-- Remove the `ⁿ%:1` ("root" pattern) optimization
-  - It inverted incorrectly when used with [`under ⍜`](https://uiua.org/docs/under)
-  - Existing uses should be replaced with [`anti ⌝`](https://uiua.org/docs/anti)[`power ⁿ`](https://uiua.org/docs/power)
 - Add [`&seek`](https://uiua.org/docs/&seek) function for working with large files
 - Remove previously deprecated `signature` and `stringify` modifiers
 - Calling [`&tcpa`](https://uiua.org/docs/&tcpa) on a TLS listener created with [`&tlsl`](https://uiua.org/docs/&tlsl) now automatically tries conducting a TSL handshake
@@ -56,6 +53,9 @@ This version is not yet released. If you are reading this on the website, then t
 - Improve "Array would be too large" error messages
 - Change short form of the `--experimental` flag for `uiua eval` to use `-x` instead of `-e`
   - This is consistent with the corresponding flag for `uiua repl`
+- Remove the `ⁿ÷:1` ("root" pattern) optimization
+  - It inverted incorrectly when used with [`under ⍜`](https://uiua.org/docs/under)
+  - Existing uses should be replaced with [`anti ⌝`](https://uiua.org/docs/anti)[`power ⁿ`](https://uiua.org/docs/power)
 ### Pad
 - Add `primitives.json` to the pre-included files in the pad
 

src/algorithm/groups.rs

@@ -358,8 +358,7 @@ fn multi_partition_indices(markers: &Array<i64>) -> Vec<(i64, Vec<usize>)> {
                     continue;
                 }
                 if group.iter().any(|idx| {
-                    idx.iter()
-                        .zip(&curr)
+                    (idx.iter().zip(&curr))
                         .map(|(a, b)| a.abs_diff(*b))
                         .sum::<usize>()
                         == 1
@@ -369,9 +368,7 @@ fn multi_partition_indices(markers: &Array<i64>) -> Vec<(i64, Vec<usize>)> {
             }
             // Add the current index to the adjacent group, possibly merging groups
             match adjacent_groups.len() {
-                0 => {
-                    groups.push((marker, vec![curr.clone()]));
-                }
+                0 => groups.push((marker, vec![curr.clone()])),
                 1 => groups[adjacent_groups[0]].1.push(curr.clone()),
                 _ => {
                     let mut adjacent_groups = adjacent_groups.into_iter();

src/tree.rs

@@ -18,8 +18,8 @@ use serde::*;
 use crate::{
     check::SigCheckError,
     compile::invert::{InversionError, InversionResult},
-    Assembly, BindingKind, DynamicFunction, Function, ImplPrimitive, Primitive, Purity, Signature,
-    Value,
+    Assembly, BindingKind, DynamicFunction, Function, HashLabels, ImplPrimitive, Primitive, Purity,
+    Signature, Value,
 };
 
 node!(
@@ -1155,15 +1155,16 @@ macro_rules! node {
             #[allow(unused_variables)]
             fn hash<H: Hasher>(&self, state: &mut H) {
                 macro_rules! hash_field {
-                    (span) => {};
-                    ($nm:ident) => {Hash::hash($nm, state)};
+                    (span span) => {};
+                    (val $val:ident) => {Hash::hash(&HashLabels($val), state)};
+                    ($nm:ident $_nm:ident) => {Hash::hash($nm, state)};
                 }
                 match self {
                     $(
                         Self::$name $(($($tup_name),*))? $({$($field_name),*})? => {
                             discriminant(self).hash(state);
-                            $($(hash_field!($field_name);)*)?
-                            $($(hash_field!($tup_name);)*)?
+                            $($(hash_field!($field_name $field_name);)*)?
+                            $($(hash_field!($tup_name $tup_name);)*)?
                         }
                     )*
                 }

src/value.rs

@@ -2355,43 +2355,51 @@ impl Ord for Value {
 }
 
 impl Hash for Value {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        val_as_arr!(self, |arr| arr.hash(state))
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        val_as_arr!(self, |arr| arr.hash(hasher))
     }
 }
 
-/// A wrapper for values that hashes their labels in addition to the normal hashing
-///
-/// Works with both [`Value`] and `&Value`
-#[derive(Debug, Clone)]
-pub struct HashLabels<T = Value>(pub T);
+#[derive(Clone)]
+pub(crate) struct HashLabels<V = Value>(pub V);
 
-impl PartialEq for HashLabels {
+impl PartialEq for HashLabels<Value> {
     fn eq(&self, other: &Self) -> bool {
-        HashLabels(&self.0).eq(&HashLabels(&other.0))
+        HashLabels(&self.0) == HashLabels(&other.0)
     }
 }
-impl Eq for HashLabels {}
-impl Hash for HashLabels {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        HashLabels(&self.0).hash(state);
+impl Eq for HashLabels<Value> {}
+impl Hash for HashLabels<Value> {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        HashLabels(&self.0).hash(hasher)
     }
 }
 
 impl PartialEq for HashLabels<&Value> {
     fn eq(&self, other: &Self) -> bool {
-        self.0.eq(other.0) && self.0.meta.label == other.0.meta.label
+        self.0 == other.0 && self.0.meta.label == other.0.meta.label
     }
 }
 impl Eq for HashLabels<&Value> {}
 impl Hash for HashLabels<&Value> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.0.hash(state);
-        self.0.meta.label.hash(state);
-        if let HashLabels(Value::Box(arr)) = self {
-            for Boxed(val) in &arr.data {
-                HashLabels(val).hash(state);
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        self.0.meta.label.hash(hasher);
+        match self.0 {
+            Value::Box(arr) => {
+                if let Some(keys) = &arr.meta.map_keys {
+                    keys.hash(hasher);
+                }
+                Boxed::TYPE_ID.hash(hasher);
+                if let Some(scalar) = arr.as_scalar() {
+                    if let Some(value) = scalar.nested_value() {
+                        value.hash(hasher);
+                        return;
+                    }
+                }
+                arr.shape.hash(hasher);
+                arr.data.iter().for_each(|x| HashLabels(&x.0).hash(hasher));
             }
+            val => val_as_arr!(val, |arr| arr.hash(hasher)),
         }
     }
 }

todo.md

@@ -1,8 +1,6 @@
 # Uiua Todo
 
 # 0.17
-- Improve PR validation
-  - Check for clippy lints
 - LSP optimizations
   - Fix rename
   - Fix goto references