Я считаю, что оператор

для конкатенации строк — неудачное решение, так как:

Он некоммутативен в отличие от операции сложения, обозначаемой символом
```
+
```
. Этот аргумент приводят, в частности, разработчики языка программирования Julia:
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.
И я предлагаю сделать оператор
```
+
```
строго коммутативным и при наличии
```
F +(MyType, Int)
```
запретить перегрузку
```
F +(Int, MyType)
```
. Это немного уменьшит работу программисту по заданию дополнительных перегрузок операторов, и одновременно повысит предсказуемость программ
[
{…
аналогично перегрузку оператора
```
!=
```
следует автоматически генерировать на основе перегрузки оператора
```
==
```
как сделано в D и тоже запретить
}
]
.
В некоторых языках (например в PHP и Perl) сложение "5"+5 даёт 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.
я вспомнил, что удобно иметь возможность конкатенации строкового литерала и числа без явного преобразования числа к строке, и у меня родился такой [более жизненный, чем 2+2] пример:
```
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.
Эту проблему также [как и в пункте 3] решает отдельный оператор для конкатенации строк, так как приоритет этого оператора можно сделать ниже, чем у оператора сравнения
```
==
```
.

По этим [и/или каким-то ещё] причинам от

для конкатенации строк отказались во многих языках (PHP, Perl, D, Lua, Julia, Visual Basic, Nim, Dart), вот только однозначного обозначения для этой операции, к сожалению, до сих пор так и не определили [{…наиболее удачным можно считать принятое в языках D и Perl 6 обозначение — символ тильда (

)}], поэтому я решил попробовать пойти другим путём и вообще отказаться от оператора конкатенации строк. Для конкатенации строкового литерала и переменной в 11l достаточно просто расположить их рядом без пробелов:

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

Для конкатенации двух переменных используется такая форма записи:

print(name""value)

или такая:

print(name‘’value)

В последнем случае используются "сырые" строки — их необходимо заключать в одиночные парные кавычки — символы

‘

’

, и их использование предпочтительно в 11l.

Подряд идущие же строки [одного типа (‘’ или "")] не склеиваются в одну {…}, за исключением склеивания переменных:

‘Значение = ’value"\n"

, а также разнородных строк:

‘неразрывный’"\xA0"‘пробел’

— при этом между строковым литералом и переменной (или строковым литералом другого типа) не должно быть разделителей.

Почему
+
для строк — плохо, а
*
— нет?

Потому что у

практически всегда один из операндов является строковым литералом [

"s" * n

n * "s"

] и такую операцию сразу заметно.