Should Motoko programming language introduce multi-line Text strings with string interpolation?

[krpeacock]

Benefits of this language feature:

1. Readability: Multi-line text strings allow developers to write longer strings without using concatenation or breaking the code into multiple lines, making the code more readable and easier to maintain.
2. Simplification: With string interpolation, developers can include variables or expressions directly in the string without the need to concatenate, making the code simpler and more concise.
3. Flexibility: Arbitrary in-line evaluation allows developers to include complex expressions directly in the string, making the code more flexible and powerful.

Proposed implementation:

The proposed implementation would use either a back tick ` or double single quotes '' to start the multi-line text string. Here's an example:

let name = "Alice";
let age = 25;
let str = `
  My name is ${name}.
  I am ${age} years old.
  In 5 years, I will be ${Nat.toText(age + 5)} years old.
`;

In the example above, we have used the back tick delimiter to create a multi-line string that includes string interpolation. The variables name and age are inserted directly into the string using the ${} syntax. We have also included an expression (age + 5) inside the string, which is evaluated and included in the final string.

This feature can be scaled up to include more complex expressions and even functions, making the code more powerful and flexible.

Overall, the addition of multi-line text strings with string interpolation would be a useful feature for Motoko programmers, allowing them to write more readable and maintainable code, simplify their code, and increase the flexibility of their programs.

Open Questions

Should this feature be rolled out in stages? We could imagine starting with only supporting already-declared variables of type Text.

In the future, we may want to have an equivalent of debug_show which would have more consistent behavior for transforming complex types into text strings, so they can be more dynamically inserted. This could be automatically evaluated on values interpolated into strings for convenience. This would allow this type of code:

let age = 25;
let myAge = `My age is ${age}`;

Without the need for manually transforming the Nat into Text.

[dfx-json]

Should this feature be rolled out in stages? We could imagine starting with only supporting already-declared variables of type Text.

In my opinion, there are many benefits to working on a feature like this incrementally (as opposed to waterfall). We should start small in scope, iterate on the design until it suits our needs, and go from there.

[crusso]

For the interpolation bit, we might also want to consider using the slightly more general mechanism of quotations and antiquotations, used for instance in SML/NJ and Moscow ML. It subsumes string interpolation and can be used to construct arbitrary data from fragments of strings and quoted values. It's a bit hard to find good references for this feature, but many theorem provers use it to splice computed values into contexts (parsed from) strings.

The description of the feature in SML/NJ (without any examples).
https://www.smlnj.org/doc/quote.html

An overview of implementation techniques (sketchy)

https://prism.ucalgary.ca/server/api/core/bitstreams/3c150ee9-1dce-4716-8fcc-e31e50e603e8/content

A formalization for SML.

https://smlfamily.github.io/successor-ml/OldSuccessorMLWiki/Quoting_and_anti-quoting.html

Stack overflow answer showing how to use this specifically for string interpolation.

https://stackoverflow.com/questions/70735887/how-to-write-multiline-strings-in-sml

[panch8]

i agree, huge benefits. But being cautious is good. But i also consider at least think adding at the beginning just boolean coersion in logical context or triggered by logical operators such as && || ! (i.e let var = ''; let str = ${ !var ? "hidden" : "show"} ;

[kentosugama]

See #3995