Add support for hash key of tuples

crates/compiler/derive/src/hash.rs

@@ -30,6 +30,7 @@ use crate::{synth_var, util::Env, DerivedBody};
 pub(crate) fn derive_hash(env: &mut Env<'_>, key: FlatHashKey, def_symbol: Symbol) -> DerivedBody {
     let (body_type, body) = match key {
         FlatHashKey::Record(fields) => hash_record(env, def_symbol, fields),
+        FlatHashKey::Tuple(_fields) => todo!(),
         FlatHashKey::TagUnion(tags) => {
             if tags.len() == 1 {
                 hash_newtype_tag_union(env, def_symbol, tags.into_iter().next().unwrap())

crates/compiler/derive_key/src/hash.rs

@@ -5,7 +5,7 @@ use roc_module::{
 use roc_types::subs::{Content, FlatType, GetSubsSlice, Subs, Variable};
 
 use crate::{
-    util::{check_derivable_ext_var, debug_name_record, debug_name_tag},
+    util::{check_derivable_ext_var, debug_name_record, debug_name_tag, debug_name_tuple},
     DeriveError,
 };
 
@@ -21,6 +21,7 @@ pub enum FlatHash {
 pub enum FlatHashKey {
     // Unfortunate that we must allocate here, c'est la vie
     Record(Vec<Lowercase>),
+    Tuple(u32),
     TagUnion(Vec<(TagName, u16)>),
 }
 
@@ -28,6 +29,7 @@ impl FlatHashKey {
     pub(crate) fn debug_name(&self) -> String {
         match self {
             FlatHashKey::Record(fields) => debug_name_record(fields),
+            FlatHashKey::Tuple(arity) => debug_name_tuple(*arity),
             FlatHashKey::TagUnion(tags) => debug_name_tag(tags),
         }
     }
@@ -65,8 +67,14 @@ impl FlatHash {
 
                     Ok(Key(FlatHashKey::Record(field_names)))
                 }
-                FlatType::Tuple(_elems, _ext) => {
-                    todo!();
+                FlatType::Tuple(elems, ext) => {
+                    let (elems_iter, ext) = elems.sorted_iterator_and_ext(subs, ext);
+
+                    check_derivable_ext_var(subs, ext, |ext| {
+                        matches!(ext, Content::Structure(FlatType::EmptyTuple))
+                    })?;
+
+                    Ok(Key(FlatHashKey::Tuple(elems_iter.count() as _)))
                 }
                 FlatType::TagUnion(tags, ext) | FlatType::RecursiveTagUnion(_, tags, ext) => {
                     // The recursion var doesn't matter, because the derived implementation will only

crates/compiler/derive_key/src/util.rs

@@ -43,6 +43,10 @@ pub(crate) fn debug_name_record(fields: &[Lowercase]) -> String {
     str
 }
 
+pub(crate) fn debug_name_tuple(arity: u32) -> String {
+    format!("(arity:{arity})")
+}
+
 pub(crate) fn debug_name_tag(tags: &[(TagName, u16)]) -> String {
     let mut str = String::from('[');
     tags.iter().enumerate().for_each(|(i, (tag, arity))| {