Summarising Position On String

[amitu]

I was under wrong impression that to allow arbitrary syntax inside string formatting, e.g. string format expression itself containing string with formatting recursively, we will need to keep track of double quote depth (how deep are we in double quotes / format recursion). So we will need [] where we have explicit count up and count down. Same symbol for both open and close does not let us keep track of depth.

But I was wrong because to go from string to expression, we have to use ${} or {} expression, and we can just keep track of the curlies for counting depth (number of open { brackets till now tells us how deep in recursion we are).

So now we do not have any strong reason to prefer " quoted string vs $[] strings.

There is one minor difference still, we want our strings to "indoc strings" by default:

use indoc::indoc;

fn main() {
    let testing = indoc! {"
        def hello():
            print('Hello, world!')

        hello()
    "};
    let expected = "def hello():\n    print('Hello, world!')\n\nhello()\n";
    assert_eq!(testing, expected);
}

And we want another way to represent a string which leaves spaces intact. With indoc it is done by leaving normal space preserving string to "", and making the "idocification" explicit by the indoc{} macro.

We want it to be default. We can say our "" will indocify, and r"" for space preserving version. But in Rust r"" prefix is used for a totally different purpose, which I do not wnat to "appropriate".

So I feel $[], the indocifying version, vs $$[], the space preserving version is the way to go. rationale: it looks better to me.

[Arpita-Jaiswal]

So the example looks like this:

-- ftd.text: {
    let a = $[
         Hello ${name}!
         
         This is your page. 
    ]

   a
}

What if we have to declare a list of string:

-- ftd.text: {
    let names = [$[Bob], $[Alice]]           ;; [$$[Bob], $$[Alice]] This will also work
    let result = $[]                                      ;; $$[] This will also work
    for name in names {
        result = result + $$[ ] + name
    }
    result
}

This doesn't look so good. What if we start using $" for the indocifying version vs " for the space preserving version.
The first example will look like:

-- ftd.text: {
    let a = $"
         Hello ${name}!
         
         This is your page. 
    "

   a
}

And second example will become:

-- ftd.text: {
    let names = ["Bob", "Alice"]
    let result = ""
    for name in names {
        result = result + " " + name
    }
    result
}

I think this looks better, especially for list of string example.

We can also use $"<string>"$ for the indocifying version.

-- ftd.text: {
    let a = $"
         Hello ${name}!
         
         This is your page. 
    "$

   a
}

But considering table which will be introduced in 0.5 the syntax looks like this:

-- ftd.table my-table:

[A] [B] [C]
[1] [S] [M]
[2] [N] [O]

This is neat. [] reassembles like cell. With " it looks like

-- ftd.table my-table:

"A" "B" "C"
"1" "S" "M"
"2" "N" "O"

This is okay. But not so great as above.

[amitu]

We can also use $"<string>"$ for the indocifying version.

Let's go with this. "" and $""$ as you described.

Not sure what can we do about table. If there is single word we can omit the quoting.

[amitu]

@Arpita-Jaiswal: this is quite brilliant: