How to improve this code?

No, there is not.

Enum.map(list, &your_defp_fun(&1, shift))

At least when I understand you correctly.

Don’t take the abscense of the control flow label too strict. those labels are relatively new and they haven’t been applied thoroughly yet. This is a problem common to most tracks.

Have you considered using a Range and charliterals? eg. char in ?a..?z.

But in general I think it looks quite good already.

@Fl4m3Ph03n1x, I think this is a good case for binary pattern matching.

defmodule Caesar do
  defguard is_lower?(char) when char in ?a..?z
  defguard is_upper?(char) when char in ?A..?Z

  @spec rotate(text :: String.t() | integer, shift :: integer) :: String.t()
  def rotate(<< char :: integer-size(8), rest :: binary >>, shift)  do
    << rotate(char, shift) :: integer-size(8), rotate(rest, shift) :: binary >>
  end

  def rotate("", _shift), do: ""

  def rotate(char, shift) when is_lower?(char), do: ?a + rem( char - ?G + shift, 26 )
  def rotate(char, shift) when is_upper?(char), do: ?A + rem( char - ?' + shift, 26 )
  def rotate(char, _shift), do: char
end

Thanks for the feedback everyone!

@NobbZ yah, thanks for pointing out about the labels. It was making me feel really worthless not being able to do an exercise that was supposed to be super simple and have no conditionals. Turns all the solutions use some advanced feature, so it’s good to know that I should have a bigger level in Elixir before attempting Exercism. Now I understand why @peerreynders suggested me to read the book first and then do the exercises !

@kip Your solution is probably awesome, but I am too young to appreciate it. This happens because I am still learning the basics of Elixir and I have no idea what guards are, let along all the <<>> thing going on. Along with that binary strings are still a somewhat vague concept. I mean, for one of the 1st exercises in Exercism I would expect something simpler.
I will likely return to this later and try to appreciate it for it’s full glory

Turns all the solutions use some advanced feature…

Kip’s is amazing with the binary pattern matching, which goes into the string itself like it has superpowers. Here’s my more pedestrian beginner’s attempt, with run-of-the-mill guards and very basic pattern matching – no advanced features. Everything here is in the first parts of the Getting Started guide on elixir-lang.org. It does seem easy to read.

defmodule RotationalCipher do
  def rotate(text, shift) do
    text
    |> to_charlist()
    |> Enum.map(&handle(&1, shift))
    |> to_string()
  end

  def handle(char, shift) when char in ?a..?z, do: spin(char, shift, ?z)
  def handle(char, shift) when char in ?A..?Z, do: spin(char, shift, ?Z)
  def handle(char, _shift), do: char

  def spin(char, shift, z) when char + shift > z, do: char + shift - 26
  def spin(char, shift, _z), do: char + shift
end

Everything you’d think of as conditional logic has been moved to the function headers, using guards in this case. Of course you could write a more traditionally conditional version:

defmodule RotationalCipher2 do
  def rotate(text, shift) do
    text
    |> to_charlist()
    |> Enum.map(&handle(&1, shift))
    |> to_string()
  end

  def handle(char, shift) do
    cond do
      char in ?a..?z -> spin(char, shift, ?z)
      char in ?A..?Z -> spin(char, shift, ?Z)
      true -> char
    end
  end

  def spin(char, shift, z) do
     if(char + shift > z, do: char + shift - 26, else: char + shift)
  end
end

I find the first version more direct.

By the way, AstonJ in this forum has been recommending Dave Thomas’ Elixir for Programmers video course. I tried it and have found it an excellent addition to books because you (or at least I) get a sense of workflow and state of mind along with a great introduction to OTP.

Completely agree with the comment about Dave Thomas’s video course. I also think that Lance Halvorsen’s book, should be on the reading list of anyone wanting to deploy a basic understanding of Elixir to the construction of larger applications.

Getting back to to the topic, this version was inspired by the treatment of comprehensions on bitstrings in the Dave Thomas book (p108 in my 2016 1.3 edition):

defmodule Caesar do

@spec rotate(text :: String.t(), shift :: integer) :: String.t()

def rotate(text, shift), do: List.to_string(for <<ch <- text>>, do: caesar_code(ch, shift))

defp caesar_code(ch, shift) when ch in ?a..?z, do: rotate_code(ch, shift, ?z)

defp caesar_code(ch, shift) when ch in ?A..?Z, do: rotate_code(ch, shift, ?Z)

defp caesar_code(ch, _shift), do: ch

defp rotate_code(ch, shift, z), do: if ch + shift > z, do: ch + shift - 26, else: ch + shift

end

It’s not as elegant as kip’s solution, but it is easy to follow.