Golang to Elixir code conversion

I’m trying to translate following Go code into Elixir. I’ve also included my own attempt.

package main

import "fmt"

const spanish = "Spanish"
const french = "French"
const englishHelloPrefix = "Hello, "
const spanishHelloPrefix = "Hola, "
const frenchHelloPrefix = "Bonjour, "

// Hello returns a personalised greeting in a given language.
func Hello(name string, language string) string {
	if name == "" {
		name = "World"
	}

	return greetingPrefix(language) + name
}

func greetingPrefix(language string) (prefix string) {
	switch language {
	case french:
		prefix = frenchHelloPrefix
	case spanish:
		prefix = spanishHelloPrefix
	default:
		prefix = englishHelloPrefix
	}
	return
}

func main() {
	fmt.Println(Hello("world", ""))
}

Below I have my attempt at converting it to Elixir. I just want to make sure it’s the “Elixir way” of doing things. What would you all have done differently?

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

  # Returns a personalised greeting in a given language.
  def hello(name, language) do
    name = if name == "" do
      "World"
    else
      name
    end
    greeting_prefix(language) <> name
  end

  def greeting_prefix(language) do
    case language do
      "french" -> @french_hello_prefix
      "spanish" -> @spanish_hello_prefix
      _ -> @english_hello_prefix
    end
  end
end

IO.puts Hello.hello("world", "")

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
4 Likes

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
4 Likes