Choosing where newlines are in a multi-line string literal - rust

Question

If I create the following multi-line string literal:
let lit = "A -> B
C -> D
E -> F";
It prints out like this:
A -> B
C -> D
E -> F
No surprise. However, if I try this:
let lit = "A -> B\
C -> D\
E -> F";
I get:
A -> BC -> DE -> F
What I'm trying to get is this:
A -> B
C -> D
E -> F
But this is the best thing I've come up with:
let lit = "A -> B\n\
C -> D\n\
E -> F";
Or maybe this:
let lit = vec!["A -> B", "C -> D", "E -> F"].connect("\n");
Both of those feel a little clunky, though not terrible. Just wondering if there's any cleaner way?

Answer 1

Indoc is a procedural macro that does what you want. It stands for "indented document." It provides a macro called indoc!() that takes a multiline string literal and un-indents it so the leftmost non-space character is in the first column.
let lit = indoc! {"
A -> B
C -> D
E -> F"
};
The result is "A -> B\nC -> D\nE -> F" as you asked for.
Whitespace is preserved relative to the leftmost non-space character in the document, so the following preserves 2 spaces before "C":
let lit = indoc! {"
A -> B
C -> D
E -> F"
};
The result is "A -> B\n C -> D\nE -> F".

Answer 2

I see three other possible solutions:
1) Get rid of the spaces:
let lit = "A -> B
C -> D
E -> F";
This way, you lose the neat display in your code. You could get that back like this:
2) Get rid of the spaces, shift everything down a line, and escape the return.
let lit = "\
A -> B
C -> D
E -> F";
I would explain what that "\" is doing in a comment, though, because it isn't obvious otherwise.
3) Combine these two solutions:
let lit =
"A -> B
C -> D
E -> F";
You can test this at Ideone.

Answer 3

Mostly as an exercise, I mimicked Python's join syntax with the following:
trait CanJoin {
fn join(&self, in_strings: Vec<&str>) -> String;
}
impl CanJoin for str {
fn join(&self, in_strings: Vec<&str>) -> String {
in_strings.connect(self)
}
}
fn main() {
let vector = vec!["A -> B", "B -> C", "C -> D"];
let joined = "\n".join(vector);
}
Or as a macro:
macro_rules! join_lines {
($($x:tt)*) => {
{
vec![$($x)*].connect("\n")
}
}
}
let joined = join_lines!("A -> B", "B -> C", "C -> D");