Allow map entries to be replaced by index

Author: irh

CHANGELOG.md

@@ -17,6 +17,7 @@ The Koto project adheres to
 - `export` can be used with multi-assignment expressions.
   - E.g. expressions like `export a, b, c = foo()` are now allowed.
 - Maps now support `[]` indexing, returning the Nth entry as a tuple.
+  - Entries can also be replaced by index by assigning a key/value tuple.
 - Objects that implement `KotoObject::call` can now be used in operations that
   expect functions.
   - `KotoObject::is_callable` has been added to support this, and needs to be

crates/cli/docs/language_guide.md

@@ -643,6 +643,15 @@ print! m[1]
 check! ('oranges', 99)
 ```
 
+Entries can also be replaced by assigning a key/value tuple to the entry's index.
+
+```koto
+m = {apples: 42, oranges: 99, lemons: 63}
+m[1] = ('pears', 123)
+print! m
+check! {apples: 42, pears: 123, lemons: 63}
+```
+
 ### Shorthand Values
 
 Koto supports a shorthand notation when creating maps with inline syntax. 

crates/runtime/src/vm.rs

@@ -2243,18 +2243,44 @@ impl KotoVm {
                         if *index >= 0.0 && u_index < list_len {
                             list_data[u_index] = value.clone();
                         } else {
-                            return runtime_error!("Index '{index}' not in List");
+                            return runtime_error!("Invalid index ({index})");
                         }
                     }
                     Range(range) => {
                         for i in range.indices(list_len) {
                             list_data[i] = value.clone();
                         }
                     }
-                    unexpected => return unexpected_type("index", unexpected),
+                    unexpected => return unexpected_type("Number or Range", unexpected),
                 }
                 Ok(())
             }
+            Map(map) => match index_value {
+                Number(index) => {
+                    let mut map_data = map.data_mut();
+                    let map_len = map_data.len();
+                    let u_index = usize::from(index);
+                    if *index >= 0.0 && u_index < map_len {
+                        match value {
+                            Tuple(new_entry) if new_entry.len() == 2 => {
+                                let key = ValueKey::try_from(new_entry[0].clone())?;
+                                // There's no API on IndexMap for replacing an entry,
+                                // so use swap_remove_index to remove the old entry,
+                                // then insert the new entry at the end of the map,
+                                // followed by swap_indices to swap the new entry back into position.
+                                map_data.swap_remove_index(u_index);
+                                map_data.insert(key, new_entry[1].clone());
+                                map_data.swap_indices(u_index, map_len - 1);
+                                Ok(())
+                            }
+                            unexpected => unexpected_type("Tuple with 2 elements", unexpected),
+                        }
+                    } else {
+                        runtime_error!("Invalid index ({index})")
+                    }
+                }
+                unexpected => unexpected_type("Number", unexpected),
+            },
             Object(o) => o.try_borrow_mut()?.index_mut(index_value, value),
             unexpected => unexpected_type("a mutable indexable value", &unexpected),
         }