I think that operator

for string concatenation is an unfortunate decision, because:

String concatenation is noncommutative unlike addition operator
```
+
```
. This argument mentions the developers of Julia programming language:
https://docs.julialang.org/en/latest/manual/...:

In mathematics,
```
+
```
usually denotes a commutative operation, where the order of the operands does not matter. An example of this is matrix addition, where
```
A + B == B + A
```
for any matrices
```
A
```
and
```
B
```
that have the same shape.
And I suggest to make operator
```
+
```
strictly commutative and in presence of
```
F +(MyType, Int)
```
forbid
```
F +(Int, MyType)
```
. This will reduce a work of definition of additional/extra operators' overloadings, and at the same time this will increase the predictability of programs
[
{…
similarly operator
```
!=
```
must be generated automatically based on operator
```
==
```
as done in D, and explicit overloading of operator
```
!=
```
should be forbidden
}
]
.
In some languages (for example in PHP and Perl) "5"+5 yields 10.
Dart Puzzlers: Chapter 2:
Can you guess what the following statement prints?
```
System.out.println("2 + 2 = " + 2+2);
```
Translating this mini-puzzle into Dart, we get:
```
print('2 + 2 = ' + 2+2);
```
Both the Java and Dart versions print
```
2 + 2 = 22
```
, which may not be what you expected.
Or more vital example:
```
print("id=" + id+1)
```
Dart Puzzlers: Chapter 2:
```
...
    System.out.println("Animals are equal: "
                       + pig == dog);
...
```
It doesn't print
```
Animals are equal: true
```
. It doesn't print
```
Animals are equal: false
```
, either. It just prints
```
false
```
. Why? Because the
```
+
```
operator binds tighter than the
```
==
```
operator.
This [as in 3] problem is solved with a separate string concatenation operator, because its priority may be lower than of operator
```
==
```
.

For this [and/or some other] reasons operator

is not used for string concatenation in many languages (PHP, Perl, D, Lua, Julia, Visual Basic, Nim, Dart), but definitive designation for this operation is still not found [{…most appropriate designation [in my opinion] have chosen in languages D and Perl 6: tilde (

) symbol}], therefore I decided to go another way and reject a dedicated operator for string concatenation. To concat string literal and variable in 11l just place it next to each other without spaces:

print("id="id)
print("id="(id+1))

To concat two variables use this notation:

print(name""value)

or this:

print(name‘’value)

In the last case a raw string literal is used — raw strings should be enclosed in single quotation marks: characters

‘

and

’

.

Consecutive string literals [of one type (‘’ or "")] are not concatenated [unlike in languages C or Python], because it is error prone {…} — space between two string literals indicate that likely comma is missed here.
String literals are concatenated only with variables:

‘Value = ’value"\n"

, and with string literals of other type:

‘no-break’"\xA0"‘space’

. And in this case there should not be a space between string literal and a variable or string literal of other type.

Why is
+
bad for strings, but
*
is not?

Because

almost always has one of the operands as a string literal [

"s" * n

n * "s"

] and such an operation is easily noticeable.