Add a function to replace matches with a callback

src/gleam/regexp.gleam

@@ -218,3 +218,21 @@ pub fn replace(
   in string: String,
   with substitute: String,
 ) -> String
+
+/// Creates a new `String` by replacing all substrings that match the regular
+/// expression with the result of applying the function to each match.
+///
+/// ## Examples
+///
+/// ```gleam
+/// let assert Ok(re) = regexp.from_string("\\w+")
+/// regexp.replace_map(re, "hello, joe!", fn(m) { string.capitalise(m.content) })
+/// // -> "Hello, Joe!"
+/// ```
+@external(erlang, "gleam_regexp_ffi", "replace_map")
+@external(javascript, "../gleam_regexp_ffi.mjs", "replace_map")
+pub fn replace_map(
+  each pattern: Regexp,
+  in string: String,
+  with substitute: fn(Match) -> String,
+) -> String

src/gleam_regexp_ffi.erl

@@ -1,6 +1,6 @@
 -module(gleam_regexp_ffi).
 
--export([compile/2, check/2, split/2, replace/3, scan/2]).
+-export([compile/2, check/2, split/2, replace/3, scan/2, replace_map/3]).
 
 compile(String, Options) ->
     {options, Caseless, Multiline} = Options,
@@ -44,3 +44,9 @@ scan(Regexp, String) ->
 replace(Regexp, Subject, Replacement) ->
     re:replace(Subject, Regexp, Replacement, [global, {return, binary}]).
 
+replace_map(Regexp, Subject, Replacement) ->
+    Replacement1 = fun(Content, Submatches) ->
+        Submatches1 = gleam@list:map(Submatches, fun gleam@string:to_option/1),
+        Replacement({match, Content, Submatches1})
+    end,
+    re:replace(Subject, Regexp, Replacement1, [global, {return, binary}]).

src/gleam_regexp_ffi.mjs

@@ -49,3 +49,23 @@ export function scan(regex, string) {
 export function replace(regex, original_string, replacement) {
   return original_string.replaceAll(regex, replacement);
 }
+
+export function replace_map(regex, original_string, replacement) {
+  let replace = (match, ...args) => {
+    const hasNamedGroups = typeof args.at(-1) === "object";
+    const groups = args.slice(0, hasNamedGroups ? -3 : -2);
+    const submatches = [];
+    for (let n = 0; n < groups.length; n++) {
+      if (groups[n]) {
+        submatches[n] = new Some(groups[n]);
+        continue;
+      }
+      if (submatches.length > 0) {
+        submatches[n] = new None();
+      }
+    }
+    let regexMatch = new RegexMatch(match, List.fromArray(submatches));
+    return replacement(regexMatch);
+  };
+  return original_string.replaceAll(regex, replace);
+}

test/gleam_regexp_test.gleam

@@ -1,5 +1,5 @@
 import gleam/option.{None, Some}
-import gleam/regexp.{Match, Options}
+import gleam/regexp.{type Match, Match, Options}
 import gleeunit
 import gleeunit/should
 
@@ -190,3 +190,31 @@ pub fn replace_3_test() {
   regexp.replace(re, "🐈🐈 are great!", "🐕")
   |> should.equal("🐕🐕 are great!")
 }
+
+pub fn replace_map_0_test() {
+  let replace = fn(match: Match) {
+    case match.content {
+      "1" -> "one"
+      "2" -> "two"
+      "3" -> "three"
+      n -> n
+    }
+  }
+  let assert Ok(re) = regexp.from_string("1|2|3")
+  regexp.replace_map(re, "1, 2, 3, 4", replace)
+  |> should.equal("one, two, three, 4")
+}
+
+pub fn replace_map_1_test() {
+  let replace = fn(match: Match) {
+    case match.submatches {
+      [Some("1")] -> "one"
+      [Some("2")] -> "two"
+      [Some("3")] -> "three"
+      _ -> match.content
+    }
+  }
+  let assert Ok(re) = regexp.from_string("'(1|2|3)'")
+  regexp.replace_map(re, "'1', '2', '3', '4'", replace)
+  |> should.equal("one, two, three, '4'")
+}