Golang to Elixir code conversion

Your solution is perfectly viable with the exception if name == "" do statement, since elixir is dynamically typed. If you want to check for empty string, you have to ensure that the parameter is string, you can use a guard for this:

def hello(name, language) when is_binary(name) do
    name = if name == "" do
      "World"
    else
      name
    end
    greeting_prefix(language) <> name
  end

As for a different approach, you could do the same with:

defmodule Hello do
  @english_hello_prefix "Hello, "
  @spanish_hello_prefix "Hola, "
  @french_hello_prefix "Bonjour, "

  def greeting_prefix("french"), do: @french_hello_prefix
  def greeting_prefix("spanish"), do: @spanish_hello_prefix
  def greeitng_prefix(_unknown), do: @english_hello_prefix

  def hello(name, language) when byte_size(name) > 0, do: greeting_prefix(language) <> name
  def hello(name, language), do: greeting_prefix(language) <> "World"
end

None of the below are “rules”, but some thoughts:

• putting single-use constants in a module attribute generates identical bytecode to putting them at the point-of-use and only obscures the function where they are used (especially if the attributes are kept at the top of the file while the use site is many lines below). Here’s an alternative greeting_prefix:

def greeting_prefix(language) do
  case language do
    "french" -> "Bonjour, "
    "spanish" -> "Hola, "
     _ -> "Hello, "
  end
end

• another common style of writing a function with a single simple (no computation in the case ... do) case statement as the body is with pattern-matching like in @D4no0’s version

• IMO it can be clearer to keep the parts of a function at the same “level of detail”; in this case the name computation and the greeting_prefix computation are both used in hello but the name part has the control structure exposed. Consider making the function more symmetric:

def hello(name, language) do
  greeting_prefix(language) <> name_with_default(name)
end

defp name_with_default(""), do: "World"
defp name_with_default(name), do: name

• finally, if you find yourself regularly writing case statements against strings, consider making the possible values more explicit by converting to known atoms at a boundary. For instance, you might change the caller of hello to instead pass one of :english, :french, or :spanish and then match exhaustively:

def greeting_prefix(language) do
  case language do
    :french -> "Bonjour, "
    :spanish -> "Hola, "
    :english -> "Hello, "
  end
end