为什么Elm使用'++'运算符来连接字符串？

Question

I am learning Elm and I find a lot of things that are attractive about it, such as its elegance and simplicity. However, one aspect that I find puzzling is its use of "++" to concatenate strings. For example:

> "hello" ++ " world"
"hello world"

Addition works the way you would expect it.

> 2 + 3 + 9
14

The majority of high level languages such as C#/Java/JavaScript/Python use a single plus "+" in concatenating strings in the analogous way multiple numbers would be summed. It seems so much more intuitive, as there is a certain consistency in concatenating strings like summing numbers.

Does anyone know the logic behind the design decision to use a ++ instead of + in this context?

Answer 1

Elm allows you to define polymorphic functions.

Parametric polymorphism is when a function can be applied to elements of any types:

f : (a, b) -> (b, a)
f (x, y) = (y, x)

Ad-hoc polymorphism is when a function can be applied to elements of some types:

g : appendable -> appendable -> appendable -> appendable
g x y z = x ++ y ++ z

h : number -> number -> number
h x y = (x + 2) * y

The type variables number and appendable are special because they represent a subset of all Elm types. List and String are appendable types while Float and Int are number types.

It could theoretically be possible to instead define a hasPlus type variable which would include List , String , Float and Int , but then when defining a polymorphic function you would need to be aware that it is possible that x + y is different than y + x and that would be quite a burden if you are actually thinking about numbers...

Answer 2

This may be to avoid overloading an operator.

It can be useful to statically infer types or even improve readability when variables are used, as it is then clear what is being done (string concatenation if ++ or arithmetics if + ).

In languages that are not strongly typed (I do not know if this is the case in Elm), using the same notation can make it impossible to know what is being done on variables before actually running the program, which makes it slower.

XQuery uses || instead of + too, some languages even use different notations for decimals, like +. in CAML.

Answer 3

Concatenation and addition are completely different operations with different properties. For example, addition is commutative (on integers, floats are different beasts), while concatenation most definitely is not. The arbitrary decision to re-use the operators by some languages is the strongest connection between them you can find.

And even if the overloading made sense, you would hit the static nature of the language – what should the type of such operator be?

Currently the operator works on magic type number :

(+) : number -> number -> number

While you could have a new magic type numberorstring and the + function would be polymorphic with two different semantics, this would only be introducing even more magic into the language.

Answer 4

According to the docs , the ++ operator is used for appending lists:

-- alias for appending lists and two lists
append xs ys = xs ++ ys
xs = [1,2,3]
ys = [4,5,6]

-- All of the following expressions are equivalent:
a1 = append xs ys
a2 = xs ++ ys

b2 = (++) xs ys

c1 = (append xs) ys
c2 = ((++) xs) ys

Prior to version 0.9, strings were represented as a Haskell-inspired list of characters. Version 0.9 introduced a new string library (see the announcement here), so it looks like the ++ operator persisted despite strings no longer being represented as a list.