Pondering Elixir pipes

gistfile1.ex

# A very common pattern in Elixir is to define a method that pipes the first 
# argument through a series of transformations, for example here is some actual 
# Elixir code I just wrote.

@spec encode(String.t) :: String.t
def encode(plaintext) do
  plaintext 
  |> encipher 
  |> chunk
end

defp encipher(plaintext) do
  plaintext
  |> String.to_char_list 
  |> Enum.map(&encoder/1)
  |> Enum.filter( &(&1) )
end

defp chunk(ciphertext) do
  ciphertext
  |> Enum.chunk(5, 5, [])
  |> Enum.join(" ")      
end

# Repeating the argument variable seems redundant.
#
# What if a pipe operator had no lefthand value and was the first line of a 
# method, it would automatically take the first argument of that method?
#
# This would allow the above to be rewritten as:

@spec encode(String.t) :: String.t
def encode(plaintext) do
  |> encipher 
  |> chunk
end

defp encipher(plaintext) do
  |> String.to_char_list 
  |> Enum.map(&encoder/1)
  |> Enum.filter( &(&1) )
end

defp chunk(ciphertext) do
  |> Enum.chunk(5, 5, [])
  |> Enum.join(" ")      
end

# To me this actually seems more clear to read, since the method signature is
# directly above it's obvious what data you are operating on.  It puts the focus
# even more clearly on the data transformation provided by the method.
#
# Is there a reason this can't work / shouldn't work this way?