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.
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
def line here says that if you pass
reverse/1 an empty list, the result
is an empty list; that’s the base case.
def defines the recursive case, in which
reverse/1 takes the tail of the
tl list), reverses it, and appends the first element (
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!