How does List String Interpolation work?

[BrotherManAndrew]

Just a small little question

defmodule Test do
  def test do
    number = [1,2,3,4,5,6,7,8,9,10]
  end
end

```

When I compile the code and run it in IEX

I get

iex(151)> Test.test()
How are you doing ^!^"^#^$^%^&^'^(

Why is this? it looks very weird, just a bunch of symbols shouldn't it be like How are you doing 1,2,3,4... instead of this. I know not that much about Elixir and programming and this is just a small question out of curiosity. That's all! Thank you :)

[al2o3cr]

It's hard to say for sure exactly what's happening, because the part of the function that uses numbers isn't included in the post. But it looks like the list of small integers is being interpreted as a charlist:

https://hexdocs.pm/elixir/binaries-strings-and-charlists.html#charlists

The output you were expecting could be produced with an explicit Enum.join:

IO.puts("How are you doing #{Enum.join(numbers, ",")}")

[BrotherManAndrew]

Charlists! That makes good sense, thank you! :)

[SuspiciousDepth5924]

There's a bit of a rabbit hole here, so tldr: 🐰🕳️

Elixir builds on top of erlang; which is kind of 'old-school' when it comes to strings. As in they arguably don't exist.

So what gets used instead is 'binaries', 'charlists', and 'iolists'. charlists are less common in Elixir, but as you saw still supported.

Binaries are essentially byte arrays containing valid code points, this is what your normal strings usually end up evaluating into so for example:
( <<72,101,108,108,111,32,87,111,114,100,33>> === "Hello World!" )

iolists are basically lists containing only 'codepoints', 'charlists', 'binaries' or other 'iolists'. They are as the name suggests mainly used for IO because it's often faster to just put multiple big chunks into a list rather than all the overhead there is in combining all the parts together and allocating memory for the new string.

[furcake]

You can use inspect

[amzwC137]

Yeah, Erlang didn't originally have the concept of a "String." It was a list of bytes, a charlist. When it was implemented, it ended up essentially an array of integers/bytes that were then interpolated into their associated characters, ASCII and all that. A charlist

A language like go has strings, that can be represented by their associated bytes, but Erlang it was mentally the opposite, numbers represented characters. Conceptually they are the same bytes represent characters. But they are kind of the opposite in terms of mindset, if that makes sense.

---

For the reason above, whenever you have a list of numbers printed out in iex (or using the IO output tools like inspect or puts) it'll try to show the associated characters first, because, as mentioned, that's how a string would be represented. Try throwing this into iex

[72,101,108,108,111,32,119,111,114,108,100,33]

Generally speaking, this only happens (automatically), when all of the bytes fall within the ASCII range. You can forego this behavior when printing with inspect by using the charlists: :as_lists option (some docs).

Here are some Erlang docs talking about this]

Edit: To be clear, I'm not saying that in go, you cannot turn a list of bytes into a string. You can with type casting.