     in container: KeyedDecodingContainer<StringsDict.CodingKeys>,
     formatKey: String
   ) throws -> [PluralEntry.Variable] {
-    guard let variableKeyTuples = StringsDict.variableKeysFromFormatKey(formatKey) else { return [] }
-    let sortedVariableKeys = variableKeyTuples
+    guard let variableNameResults = StringsDict.variableNamesFromFormatKey(formatKey) else { return [] }
+    let sortedVariableNames = variableNameResults
       .sorted { lhs, rhs in
         // Sort by positional argument if present, otherwise by occurrence in the format key
         switch (lhs.positionalArgument, rhs.positionalArgument, lhs.range.lowerBound, rhs.range.lowerBound) {

  var translation: String? {
    var result = formatKey

    for intermediateResult in sequence(first: result, next: unfurlVariableKeysInFormatKey(_:)) {
      result = intermediateResult
    }

    return "Plural case 'other': \(result)"
  }

  /// Unfurls any variable keys in a formatKey to get a possible translation for the `other` case.
  ///
  /// This method should be used in a recursive context, in which the output will be used as the input for the
  /// next iteration.
  ///
  /// - Parameter formatKey: A format key containing variables.
  /// - Returns: The format key in which all its variable keys are replaced with the content of the `other` translation,
  ///  if the `formatKey` contained any variable keys, `nil` otherwise.
  private func unfurlVariableKeysInFormatKey(_ formatKey: String) -> String? {
    guard let firstRemainingVariableKey = StringsDict.variableKeysFromFormatKey(formatKey)?.first else {
      return nil
    }

    let (key, range, _) = firstRemainingVariableKey
    guard let variable = variables.first(where: { $0.key == key }) else { return nil }

    return formatKey.replacingCharacters(in: range, with: variable.rule.other)
  }
}

extension StringsDict.PluralEntry.VariableRule {
  var formatStrings: [String] {
    [zero, one, two, few, many, other].compactMap { $0 }
  }
}

// - MARK: Helpers

extension StringsDict {
  typealias VariableNameResult = (name: String, range: Range<String.Index>, positionalArgument: Int?)

  /// Parses variable names and their ranges from a `NSStringLocalizedFormatKey`.
  /// Every variable name that is contained within the format key is preceded
  /// by the %#@ characters or by the positional variants, e.g. %1$#@, and followed by the @ character.
  ///
  /// - Parameter formatKey: The formatKey from which the variable names should be parsed.
  /// - Returns: An array of discovered variable names, their range within the `formatKey` and the positional argument.
  // swiftlint:disable:next discouraged_optional_collection
  private static func variableNamesFromFormatKey(_ formatKey: String) -> [VariableNameResult]? {
    let pattern = #"(%(?>(\d)\$)?#@([\w\.\p{Pd}]+)@)"#
    guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return nil }
    let nsrange = NSRange(formatKey.startIndex..<formatKey.endIndex, in: formatKey)
