Basic f-strings (intepolated strings)

[GreyCat]

Implements step 1 out of formatting strings proposal.

• Added basic f-string parsing in expression language (step 1 only, just interpolation, without any extra formatting specification)
• Added basic interpolated string (f-string) translation into target languages, mostly working off concatenation and existing other-types-to-string conversions. Supports only integers and strings now.
  • GoTranslator: given non-string nature, added custom implementation using fmt.Sprintf
  • CommonLiterals: split generation of string "body" (without quotes) and adding quotes to it
  • CommonMethods: param name cleanup

Both are supported by unit tests.

[generalmimon]

@GreyCat I also have a question - is there a way to get a literal { in the f-string? From what I see in the expression parsing code, it doesn't look like there is, but I may have missed something.

In Python, for example, you can escape a { by doubling it - I wonder if we can get this too?

>>> f"1 + 2 = {1 + 2} {{basic math}}"
'1 + 2 = 3 {basic math}'

[GreyCat]

@GreyCat I also have a question - is there a way to get a literal { in the f-string? From what I see in the expression parsing code, it doesn't look like there is, but I may have missed something.

In Python, for example, you can escape a { by doubling it - I wonder if we can get this too?

To be honest, I don't want to overcomplicate it, nor I see a lot of value in having this escaping behavior.

In Python itself, it looks pretty weird per se — e.g.:

• {} is a valid expression to specify empty dict.
• {foo} is a valid expression for one-element set containing whatever foo variable has
• {foo:x} is a valid expression for a dict containing one key-value pair; key is whatever foo variable has, and value is whatever x variable has

Therefore, if I want to include a set in f-string, I'm down to unpleasant surprise:

>>> foo = "bar"
>>> x = 42
>>> f"{{foo}}"
'{foo}'
>>> f"{{foo:x}}"
'{foo:x}'

It's possible to work around with extra spaces:

>>> f"{ {foo}}"
"{'bar'}" # as expected
>>> f"{ {foo} }"
"{'bar'}" # as expected
>>> f"{ {foo:x}}"
"{'bar': 42}"
>>> f"{ {foo:x} }"
"{'bar': 42}"

... and then you try some other combinations and it gets progressively weirder, e.g. this throws a very weird error:

>>> f"{{}:x}"
  File "<stdin>", line 1
    f"{{}:x}"
             ^
SyntaxError: f-string: single '}' is not allowed

while adding initial space makes it work as expected:

>>> f"{ {}:x}"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported format string passed to dict.__format__

So, my proposal is basically avoiding going into that rabbit hole, at least yet. If anybody wants to have literal { or } in our f-strings, just keep it simple and do f"1 + 2 = {1 + 2} " + "{basic math}"

[GreyCat]

@generalmimon If you'll have some time, can I ask you to take another look? It looks like I've accommodated all your feedback, implemented all the fixes, and rebased it off the latest master — so it looks reasonably good as a first step to merge in.

Meanwhile I'll start adding .kst tests for this and once this is good to go, I'll start stage 2, which will hopefully give us better formatting options. Then, finally, we can probably deprecate -web-ide-representation.

[GreyCat]

Interpreting thumbs up as all good — therefore merging. Thanks!