Improved String.format method

[CaesiumFox]

Imagine we have theese variables

var characters = [
    {'name' : 'John', 'gender': 'm'},
    {'name' : 'Jane', 'gender': 'f'}
]
var beautiful = {'m': 'handsome', 'f': 'beautiful'}
var pronouns = {'m': 'He', 'f': 'She'}

And we need to print something like this (considering there could be more characters)

This is John. He is handsome.
This is Jane. She is beautiful.

Currently in GDScript it's possible to use if-else statements, or write something like this:

for character in characters:
    var result: String = (
        "This is {name}. {{gender}} is [{gender}]."
            .format(character)
            .format(pronouns)
            .format(beautiful, '[_]')
    )
    print(result)

or

for character in characters:
    var result: String = "This is {0}. {1} is {2}.".format([
        character.name,
        pronouns[character.gender],
        beautiful[character.gender]
    ])
    print(result)

It seems to work well. We can even make a similar script for even more comlex sentences.

However, when we decide to localize our project we will notice that the scripts we made for English won't work well with other languages, since they may have different grammatical aspects like gender, case and even animacy. It would be much convenient if the language grammar was implemented inside strings, so in order to build a complete phrase we would need to call the format method only once.

My suggestion is to make the format method accept expressions inside curly brackets. The example above could be written like this:

for character in characters:
    var result: String = (
        "This is {char.name}. {pron[char.gender]} is {adj[char.gender]}."
            .format({
                'char': character,
                'pron': pronouns,
                'adj': beautiful,
            })
    )
    print(result)

As you can see, here we called the method only once and passed the dictionaries without getting elements from them beforehand, while the grammar is implemented in the template string.

With this approach developers will be able to do more flexible translations. Here's one example:

var english = {
    fox = 'fox',
    hare = 'hare',
    slow = 'slow',
    fast = 'fast',
    template1 = 'A {2} {3} was caught by a {0} {1}.',
    template2 = 'A {0} {1} caught a {2} {3}.'
}
var russian = {
    fox = {
        'nom': 'лиса',
        'acc': 'лису',
        'ins': 'лисой',
        'gender': 'f'
    },
    hare = {
        'nom': 'заяц',
        'acc': 'зайца',
        'ins': 'зайцем',
        'gender': 'm'
    },
    slow = {
        'nom-m': 'медленный',
        'acc-m': 'медленного',
        'ins-m': 'медленным',
        'nom-f': 'медленная',
        'acc-f': 'медленную',
        'ins-f': 'медленной',
    },
    fast = {
        'nom-m': 'быстрый',
        'acc-m': 'быстрого',
        'ins-m': 'быстрым',
        'nom-f': 'быстрая',
        'acc-f': 'быструю',
        'ins-f': 'быстрой',
    },
    template1 = '{2["nom-"+3.gender]} {3.nom} ' +
        '{"был пойман" if 3.gender=="m" else "была поймана"} ' +
        '{0["ins-"+1.gender]} {1.ins}.',
    template2 = '{0["nom-"+1.gender]} {1.nom} ' +
        '{"поймал" if 1.gender=="m" else "поймала"} ' +
        '{2["acc-"+3.gender]} {3.acc}.'
}

for lang in [english, russian]:
    for zero in [lang.slow, lang.fast]:
        for one in [lang.fox, lang.hare]:
            for two in [lang.slow, lang.fast]:
                for three in [lang.fox, lang.hare]:
                    print(lang.template1.format([zero, one, two, three]))
                    print(lang.template2.format([zero, one, two, three]))

[dalexeev]

It seems to me that the String.format method should remain simple and should not parse complex rules like conditional formatting. Otherwise, it can lead to vulnerabilities similar to the one in Log4j.

If you need complex formatting, then you can implement the function you need, taking into account the requirements you need. For example, I implemented a function that selects a random phrase from those matching the passed attributes:

ITEM/APPLE/USAGE_TEXT
    en:
        good|%s ate an apple.
        neutral|%s ate an apple.
        evil|%s gobbled up an apple.
    ru:
        male,good|%s скушал яблоко.
        female,good|%s скушала яблоко.
        male,neutral|%s съел яблоко.
        female,neutral|%s съела яблоко.
        male,evil|%s сожрал яблоко.
        female,evil|%s сожрала яблоко.

[CaesiumFox]

If we consider that the current String.format method is a function that takes 3 arguments (template, values, placeholder), then we can say that it is a pure function that has no state, for the same arguments received it always returns the same result, and doesn't have side effects. If we keep it pure while adding new features, we will avoid vulnerabilities. Additionally we can restrict passing a function or lambda to the method.

[Scogur]

Mr. Avdeev, what you just said is one of the most insanely idiotic things I have ever heard. At no point in your rambling, incoherent response, were you even close to anything that could be considered a rational thought. Everyone in this room is now dumber for having listened to it. I award you thumbs down emoji, and may God have mercy on your soul.

[Mickeon]

After this breach of Godot's Code of Conduct through the means of a copypasta, it would be nice to hear your feedback about the discussion.

[akien-mga]

@Scogur Please edit your post to remove the insulting language, or you will be banned from the @godotengine GitHub.

You're welcome to disagree with the proposal, but not to be obnoxious when stating it.