Is there a smarter way to do something like this? Presumably, not creating new regexes each time would be a start. But what about the inefficiency of parsing through the

String

once for each pattern?

fun String.romanizeAccentedChars(): String {
    if (isBlank()) {
        return this
    }
    return this
        .replaceByRegex("[áàâ]", "a")
        .replaceByRegex("[äæ]", "ae")
        .replaceByRegex("[éèêëę]", "e")
        .replaceByRegex("[íîï]", "i")
        .replaceByRegex("[óōô]", "o")
        .replaceByRegex("[öø]", "oe")
        .replaceByRegex("[ūúùû]", "u")
        .replaceByRegex("[ü]", "ue")
        .replaceByRegex("[çć]", "c")
        .replaceByRegex("[ß]", "ss")
}

fun String.replaceByRegex(regexStr: String, replacement: String) =
    replace(regexStr.toRegex(), replacement)

why a regex, why not a simple loop with replacement?

Because that would mean a replacement operation for each character (compared to now which is one replacement operation for each replacement string). I thought better to group characters by replacement string.

how is replace implemented? I would assume with a string builder, so however that's implemented, you could replicate that and have a O(n) run, no? Otherwise it would be a O(nm) where m is the number of mappings?

This would reduce to one regex operation for strings with no accented characters:

private class ReplacementsSpec(val allCharsRegex: Regex, val replacementMap: Map<String, Regex>) {
    fun replace(str: String): String {
        if (!allCharsRegex.containsMatchIn(str)) {
            return str
        }
        return replacementMap.entries.fold(str) { acc, (replacement, regex) ->
            acc.replace(regex, replacement)
        }
    }

    companion object {
        operator fun invoke(vararg replacementPairs: Pair<String, String>): ReplacementsSpec {
            val rawMap = replacementPairs.toMap()
            val regexMap = rawMap.mapValues { (_, charsStr) ->
                "[${charsStr}]".toRegex()
            }
            val allCharsRegex = rawMap.values.joinToString(
                separator = "",
                prefix = "[",
                postfix = "]"
            ).toRegex()
            return ReplacementsSpec(allCharsRegex, regexMap)
        }
    }
}

private val ACCENTED_CHARS_REPLACEMENTS_SPEC by lazy {
    ReplacementsSpec( // replacement to source characters
        "a" to "áàâ",
        "ae" to "äæ",
        "c" to "çć",
        "e" to "éèêëę",
        "i" to "íîï",
        "o" to "óōô",
        "oe" to "öø",
        "ss" to "ß",
        "u" to "ūúùû",
        "ue" to "ü",
    )
}

fun String.romanizeAccentedChars(): String {
    return ACCENTED_CHARS_REPLACEMENTS_SPEC.replace(this)
}

Use java.text.Normalizer?

Thanks, though isn’t that just for removing accents? For example, I want “ö” -> “oe” not “o”