Add a `dict.map_keys` function

[llakala]

I found myself wanting to print out a dictionary with the keys mapped to a string representation (not just through string.inspect) for easier readability. However, the dict module only provides dict.map_values. I wrote up a little function that would accomplish this behavior, based on the existing do_map_values function:

fn do_map_keys(
  func: fn(key) -> new_key,
  dict: dict.Dict(key, value),
) -> dict.Dict(new_key, value) {
  let fold_func = fn(dict, key, value) { dict.insert(dict, func(key), value) }
  dict.fold(dict, from: dict.new(), with: fold_func)
}

I think this would be nice to have in the stdlib. Providing a map_values without a map_keys function feels like an omission, and I think it's reasonable to expect its dual in the stdlib.

If this is decided to be within scope, I can make a PR.

[lpil]

Hello! Thanks you for the idea.

Given you want to build a string, wouldn't it be better to convert from the dict to a string rather than from a dict, to a second dict, and then to a string?

[llakala]

That doesn't really make as much sense for my case. Here's the code for reference, using map_keys as defined locally:

  dict
  |> dict.map_values(fn(_, positions) {
    positions |> list.sort(position.compare) |> list.map(position.to_string)
  })
  |> map_keys(fn(key) { key |> piece.to_string })
  |> string.inspect

If I just converted to a string directly, it would be really difficult to read for my tests, since I use internal values for the keys that can't really be parsed as a user. Mapping the values and keys first lets me get the dict ready for string inspection.

[lpil]

Sorry, I mean rather than turning into a dict and then using string.inspect you could build up whatever the best format is directly. The output of string.inspect is not stable (can change at any time) and doesn't communicate anything specific about what you're testing, so it's not the ideal choice for tests.

[NNBnh]

Hello, I'm also in a situation where the dict.map_keys function is very in need. I'm working on a package for gamedev call vec_dict (Functions to handle dictionary with vector as keys for Gleam):

// advance_dict.gleam

import gleam/dict.{type Dict}
import gleam/list

pub fn map_keys(
  in dict: Dict(a, value),
  with fun: fn(a, value) -> b,
) -> Dict(b, value) {
  dict
  |> dict.to_list()
  |> list.map(fn(pair) {
    let #(key, value) = pair
    #(fun(key, value), value)
  })
  |> dict.from_list()
}

// vec2_dict.gleam

import gleam/dict.{type Dict}
import vec/vec2.{type Vec2}

/// A dictionary with 2D generic vector as keys.
pub type Vec2Dict(key, value) =
  Dict(Vec2(key), value)

// vec2i_dict.gleam

import advance_dict
import vec/vec2i.{type Vec2i}
import vec_dict/vec2_dict.{type Vec2Dict}

/// A dictionary with 2D integer vector as keys.
pub type Vec2iDict(value) =
  Vec2Dict(Int, value)

/// Returns a new vec-dict containing the key offset by `vector`.
pub fn offset(in dict: Vec2iDict(value), by vector: Vec2i) -> Vec2iDict(value) {
  dict |> advance_dict.map_keys(fn(key, _value) { key |> vec2i.add(vector) })
}

/// Rotate a vec-dict by an angle (in 90 degree steps).
pub fn rotate(in dict: Vec2iDict(value), by angle: Int) -> Vec2iDict(value) {
  dict |> advance_dict.map_keys(fn(key, _value) { key |> vec2i.rotate(angle) })
}

The dict.map_keys function could be very useful for other use case when manipulating not just vec-dict. For example: I have a dict like this represent the list of card placing on a table by a bot (sorry, I write it in JSON but not Gleam for convenient):

{
  "0": "a-hearts",
  "1": "6-diamonds",
  "2": "k-clubs",
  "3": "10-spades",
  "4": "3-clubs"
}

Now I want it to become like this so that the player can place their own cards one by one between the existed cards:

{
  "0": "a-hearts",
  // This give the table space so that the player can inset a card here.
  "2": "6-diamonds",
  // And then here
  "4": "k-clubs",
  // And here
  "6": "10-spades",
  // ...
  "8": "3-clubs"
}

[NNBnh]

Also, there is an edge case for this function. Say if I map 2 or more keys to the same value, some entries will be omitted, this could be unintentionally. One way to resolve this is to add a third argument to the function, like handle_conflict_with handle_conflict_fun: fn(a, a) -> a.