String interpolation with pipe

Looks totally OK, it’s relatively new though; there was no such syntax three years ago

This version looks ok IMO:

"test"
|> then(&"shmest #{&1}")

You actually kind of may pipe a variable into the string interpolation if it’s wrapped into the anonymous function call, like "test" |> (&"shmest #{&1}").()

Looks ugly though.

That makes sense now, thanks!

Didn’t know about quote until now. Seems super useful, thanks!

That explains the ArgumentError:

iex(84)> x = "a"
"a"
iex(85)> quote do: "bb#{x}"
{:<<>>, [],
 [
   "bb",
   {:::, [],
    [
      {{:., [], [Kernel, :to_string]}, [], [{:x, [], Elixir}]},
      {:binary, [], Elixir}
    ]}
 ]}
iex(86)> quote do: x|> "bb#{}"
{:|>, [context: Elixir, import: Kernel],
 [
   {:x, [], Elixir},
   {:<<>>, [],
    [
      "bb",
      {:::, [],
       [
         {{:., [], [Kernel, :to_string]}, [], [{:__block__, [], []}]},
         {:binary, [], Elixir}
       ]}
    ]}
 ]}

Basically #{} expects an argument to be passed in, but we are not passing anything to #{} when we do x |> "bb#{}". But "bb#{x}" does.

Right, so "234#{five}" is actually <<"234", five::binary>>, which is invoking Kernel.SpecialForms.<<>>. Piping something into that prepends the value at the front of that binary, if it is a legal parameter to <<>>.

So in the end "1" |> "234#{five}" expands to <<"1", "234", five::binary>> which happens to be legal. I don’t think it’s intentional.

Underneath, it’s

iex> quote do: "aa" |> "bb#{}" 
{:|>, [context: Elixir, import: Kernel],
 [
   "aa",
   {:<<>>, [],
    [
      "bb",
      {:::, [],
       [
         {{:., [], [Kernel, :to_string]}, [], [{:__block__, [], []}]},
         {:binary, [], Elixir}
       ]}
    ]}
 ]}

ah, yeah…
I wonder if it’s actually a bug now…
doesn’t seem to be an intended behavior, then…

iex(72)> "a" |> "This is: , and #{last}"
"aThis is: , and b"

It does not mean it’s piping a string into a string either…

iex> "aa" |> "bb"
** (ArgumentError) cannot pipe "aa" into "bb", can only pipe into local calls foo(), remote calls Foo.bar() or anonymous functions calls foo.()
    (elixir) lib/macro.ex:156: Macro.pipe/3
    (stdlib) lists.erl:1263: :lists.foldl/3
    (elixir) expanding macro: Kernel.|>/2
    iex:35: (file)
iex> "aa" |> "bb#{}"
"aabb"

It turns out a |> "#{}" doesn’t mean we are actually interpolating a into the position of #{}

iex(71)> "a" |> "This is: #{}, and #{last}"
"aThis is: , and b"
iex(72)> "a" |> "This is: , and #{last}"
"aThis is: , and b"