Simple Elixir Functions

I’ve been playing around with Elixir , which is a pretty cool language - specifically, I’m reading Programming Elixir 1.6 which is free for anyone with a .edu email address from The Pragmatic Bookshelf.

reverse/1

I enjoy functional programming, so of course the first two functions I made were list operations. First up is reverse(list) (written as reverse/1 , meaning it takes one argument), which reverses a list.

# reverse/1
#   Reverse the given list.
def reverse([]), do: []
def reverse(list) do
    reverse(tl list) ++ [hd list]
end

The first def line here says that if you pass reverse/1 an empty list, the result is an empty list; that’s the base case.

The second def defines the recursive case, in which reverse/1 takes the tail of the list ( tl list ), reverses it, and appends the first element ( hd list ).

palindrome/1

Another classic FP function is palindrome(list) , evaluating to true if the given list is a palindrome (like [1, 2, 3, 2, 1] ).

This function takes advantage of the _ special variable to say that any list with exactly one element is automatically a palindrome, as a second base case.

It also uses the |> pipe operator to turn the pruning operation, which turns [1, 2, 3, 2, 1] into [2, 3, 2] for recursion, from a nested function call List.delete_at(tl(list), -1) into the somewhat more readable tl(list) |> List.delete_at(-1) .

I also went out of my way to use reverse/1 here, just to say that I did. It’s definitely not the most efficient way to implement this algorithm.

# palindrome/1
#   Return true if the given list is palindromic
#   or false otherwise.
def palindrome([]), do: true
def palindrome([_]), do: true
def palindrome(list) do
    (tl(list) == tl(reverse list)) and palindrome(tl(list) |> List.delete_at(-1))
end

There’s not much point to this post other than to say - Elixir is fun, and a pretty language!