I come from the land of PHP and JavaScript, with very little Ruby experience. I have seen quite a few posts around the interwebs introducing Elixir from a Rubyist's perspective but I haven't really seen any from a perspective I can relate to. The syntax of Elixir is kind of foreign to most people outside of Ruby-land, so I hope to help push people a little bit over the initial hump with some examples using PHP and JavaScript (ES2015) along with the Elixir examples.
\nMy goal with this post is to help introduce the syntax as well as a shallow introduction to immutability and how we use recursion instead of loops.
\nIf you have Elixir installed, you can paste or type examples into IEx (interactive elixir). Start IEx shell by just typing iex into your terminal.
So, we have to admit that the Elixir syntax is very Ruby-like although the concepts and semantics are largely inherited from Erlang.\nHowever, Elixir introduces a lot of great new things of it's own, as well as cherry-picking some nice concepts from other functional languages.
\nPlease read the elixir guide on basic types for more detailed info, this is a good place to start.
\nThese common types you should already be used to:
\ntrue, false13.14"Hello World" - always using double quotes.[1, 2, 3]- This is a singly linked list. Like an array in PHP or JavaScript, but not.And maybe some you aren't used to:
\n:foo - A constant whose value is its name. In some other languages it might be called a symbol. Later, you will see it's quite useful for pattern-matching.{1, "two", :three} - An ordered group of related values (any values).Please read the elixir guides on keyword lists & maps, and structs for more detailed info.
\n[one: 1, two: 2, three: 3] - This is similar to an associative array in PHP, or a plain object in JavaScript (except it is ordered). It is basically just syntax sugar on top of lists of two-tuples of {:key, value}.%{name: "Joe", email: "joe@example.com"} - This is also similar to an associative array in PHP (except it is unordered) or a plain JavaScript object.%Person{name: "Joe", email: "joe@example.com"} - It's a map but with some compile-time guarantees and predefined properties.In Elixir, functions (named functions) are always defined in modules. Modules are basically just however you decide that you want to group your functions. You should do this in a way that has meaning to you and makes sense in the context of your project. Defining a function is similar to any other language.
\nYou define and use a function as follows: (I'm encapsulating the PHP and JavaScript versions in a class and object, to better compare with the Elixir module syntax)
\nclass StrHelper\n{\n public static function uppity($str = "default")\n {\n return strtoupper($str);\n }\n}\n\nStrHelper::uppity("foo"); // "FOO"\nlet strHelper = {\n uppity(str = "default") {\n return str.toUpperCase()\n }\n}\n\nstrHelper.uppity("foo") // "FOO"\ndefmodule StrHelper do\n def uppity(str \\\\ "default") do\n String.upcase(str)\n end\nend\n\nStrHelper.uppity("foo") # "FOO"\nAnonymous functions are first class values and can be passed as arguments or returned from other functions.
\nHere is how you define and call an anonymous function:
\n$uppity = function($bar) {\n return strtoupper($bar);\n}\n\n$uppity("bar"); // "BAR"\nlet uppity = function(bar) {\n return bar.toUpperCase()\n}\n\nuppity("bar") // "BAR"\nuppity = fn bar ->\n String.upcase(bar)\nend\n\nuppity.("bar") # "BAR"\n# Notice the dot is required here.\nWhy do we need a dot for anonymous functions?
\n\n\nThe main reason is that Elixir is a lisp-2 language - this means that variables and functions “occupy” different name spaces, so calling a function in the functions namespace and calling a function in the variables namespace has to work differently. Most languages are lisp-1 (which means that variables and functions are in the same namespace). Some other lisp-2 languages are Ruby, Common Lisp and Perl.
\n\n
\n\nFrom a practical view variables and function names have basically the same syntax so you need to differentiate between when you want the function name and when you want the value of the variable.
\n– rvirding
\n
There is a "capture operator" in Elixir which can be used to either capture an existing named function to turn it into an anonymous function that can be passed as an argument,\nor to define a new anonymous function.
\nIn PHP they are called "arrow functions."
\n$uppity = fn($bar) => strtoupper($bar);\n\n$uppity("bar"); // "BAR"\nThey are also called arrow functions in JavaScript.
\nlet uppity = (bar) => bar.toUpperCase()\n\nuppity("bar") // "BAR"\nuppity = &(String.upcase(&1))\n\nuppity.("bar") # "BAR"\nSince the number of arguments of the anonymous function match the number of arguments of the named function we are using, we can also write it as:
\nuppity = &String.upcase/1\n\nuppity.("bar") # "BAR"\nParentheses are optional in Elixir for function (and macro) calls. These are all the same thing:
\nfn s -> String.upcase(s) end\n&(String.upcase(&1))\n&String.upcase(&1)\n&String.upcase/1\nIn Elixir, functions are not referred to only by their name, but also their arity. This just means they are defined by their name and the number of arguments they take.
\nFor example String.upcase takes one argument, so it is referenced as String.upcase/1. Also, Enum.map takes two arguments, so it is referenced as Enum.map/2.
Putting that together, here is an example of capturing the exisiting function String.upcase/1, for use in Enum.map/2, which takes an anonymous function as it's second argument.
str = "Bananas"\nstr_list = String.graphemes(str)\n#=> ["B", "a", "n", "a", "n", "a", "s"]\n\nEnum.map(str_list, &String.upcase/1)\n#=> ["B", "A", "N", "A", "N", "A","S"]\n\n# Which is really the eqiuvalent of\nEnum.map(str_list, fn c -> String.upcase(c) end)\n#=> ["B", "A", "N", "A", "N", "A","S"]\nYou may have noticed that there is no return statement, because Elixir has implicit returns.\nThis means that the result of the last statement is what is returned.
so:
\ndefmodule Foo do\n def baz?(str) do\n if String.equivalent?(str, "baz") do\n "It's baz!"\n else\n "It's NOT baz!"\n end\n end\nend\nFoo.baz?("baz") # "It's baz!"\nFoo.baz?("bar") # "It's NOT baz!"\nPassing "baz" above means the last statement executed is "It's baz!".
Also, notice the function name baz? includes a ? character. This is a common convention in Elixir where a function that returns a boolean will include a ? in the name, as opposed to other languages where it would be common to name it something like is_baz.
There is a lot to say about pattern matching, because it's kind of a big deal in Elixir. However, I'm going to keep it shallow.
\nThe last example could be re-written as:
\ndefmodule Foo do\n def baz?("baz") do\n "It's baz!"\n end\n\n def baz?(str) do\n "It's NOT baz!"\n end\nend\nFoo.baz?("baz") # "It's baz!"\nFoo.baz?("bar") # "It's NOT baz!"\nYou can define the same function multiple times, and Elixir will execute the first one whose argument pattern matches. So, in the example above, the first function will only ever match when "baz" is passed, and the second one will match any other argument.
a = 1\nThis looks like typical assignment as done in other languages, but in Elixir it is actually matching the pattern of the left-hand side and right-hand side and doing the assignments based on that. Here is an example that might help clarify what this means. Pay attention to how the left-hand and right-hand side match, and how assignment is done based off of that:
\n{a, b, c} = {1, 2, 3}\n#=> a = 1, b = 2, c = 3\n\n{i, j, 3} = {1, 2, 3}\n#=> i = 1, j = 2\n\n{x, y, 9} = {1, 2, 3}\n#=> ** (MatchError) no match of right hand side value: {1, 2, 3}\nSome more examples, note that assignment can only be done if the variable you want to assign is on the left:
\nx = 1\n#=> 1\n\n1 = x\n#=> 1\n\n2 = x\n#=> ** (MatchError) no match of right hand side value: 1\n\n2 = z\n#=> ** (CompileError) undefined function z/0 \n# (there is no such import)\n\nz = 2\n#=> 2\nIf you are not familiar with linked lists this section might be slightly confusing, but let's give it a chance. Don't worry if it doesn't sink in right away.
\nA list is a singly linked-list with a tail and a head, [head | tail], where head is a single item, and tail is the rest of the list. e.g. Writing [1, 2, 3] is the same as [1 | [2, 3]] is the same as\n[1 | [2 | [3 | []]]]. A list is basically a recursive structure and the final tail is an empty list [].
So, you can both build lists this way or pattern-match to destructure.
\nx = [1, 2, 3]\n\n# Lets assign the head to `a` and the tail to `b`.\n[a | b] = x\n#=> a = 1\n#=> b = [2, 3]\n\n# Next, walking through the list.\n[c | d] = b\n#=> c = 2\n#=> d = [3]\n\n# Again, and the final tail is an empty list.\n[e | f] = d\n#=> e = 3\n#=> f = []\n\n# Now that `f` is an empty list, what do you think\n# will happen if we try to get a head and tail?\n[g | h] = f\n#=> ** (MatchError) no match of right hand side value: []\n\n# Elixir doesn't care if you do the following. It just returns the\n# result `[]`, since it matches.\n[] = f\n#=> []\n\n# There is no head or tail in an empty list, which is why\n# matching on an empty list would be your recursive "base case"\n# when using a list.\nElixir doesn't have loops, so iterating collections is done with recursion.
\nIn a recursive function, we will call the same function recursively until a condition is met.
\ndefmodule Math do\n @doc """\n If you call the function with no arguments, we'll start\n automatically from `0`.\n\n This function would be referred to as `Math.count_to_ten/0` and\n executed as `Math.count_to_ten()`.\n """\n def count_to_ten do\n count_to_ten(0)\n end\n\n @doc """\n You can specify which number to start from.\n\n We can add a `guard` on the function to make sure that the\n starting number is less than or equal to `10`. This is the\n `when` part. It is called a guard.\n\n This function would be referred to as `Math.count_to_ten/1`.\n """\n def count_to_ten(10), do: IO.puts(10)\n\n def count_to_ten(from) when from < 10 do\n IO.puts(from)\n count_to_ten(from + 1)\n end\nend\nMath.count_to_ten(8)\n#=> 8\n#=> 9\n#=> 10\nNote the multiple definitions of the same function, again. The first one that matches will be called.
\nYou will see another (probably) new-to-you concept here. We can define a function without the do/end if we use , do:. This is good for short, single line functions.
Okay, but what happens if you want to count from a number greater than ten?
\nMath.count_to_ten(13)\n\n** (FunctionClauseError) no function clause matching\n in Math.count_to_ten/1\n\n The following arguments were given to Math.count_to_ten/1:\n\n # 1\n 13\nLet's try and add the possibility of counting down to ten.
\ndefmodule Math do\n @doc """\n If you call the function with no arguments, we'll start\n automatically from `0`. This function would be referred\n to as `Math.count_to_ten/0`.\n """\n def count_to_ten do\n count_to_ten(0)\n end\n\n @doc """\n You can specify which number to start from.\n\n We can add a `guard` on the function to make sure that the\n starting number is less than or equal to `10`. This is the\n `when` part. It is called a guard.\n\n This function would be referred to as `Math.count_to_ten/1`.\n """\n def count_to_ten(10), do: IO.puts(10)\n\n def count_to_ten(from) when from < 10 do\n IO.puts(from)\n count_to_ten(from + 1)\n end\n\n # We're adding this function that matches the case when `from`\n # is greater than `10`.\n def count_to_ten(from) when from > 10 do\n IO.puts(from)\n count_to_ten(from - 1)\n end\nend\nMath.count_to_ten(8)\n#=> 8\n#=> 9\n#=> 10\n\nMath.count_to_ten(12)\n#=> 12\n#=> 11\n#=> 10\nSince we were using guards we just needed to add another function that matched that requirement.
\nSince you've seen how we can match on head and tail in a list, let's try recursion with a list. Below, we will call the list recursively until the tail is empty, and then when sum/2 is called again,\nthe base case sum([], total) will match first, and we will return the total.
defmodule Math do\n @doc """\n We will accept a list of numbers and start the recursion by\n calling `sum/2` with the initial total `0`.\n """\n def sum(numbers) when is_list(numbers) do\n sum(numbers, 0)\n end\n\n # These are private functions, used to walk through the list\n # until we match the "base case" with the empty list.\n defp sum([], total), do: total\n\n defp sum([n | rest], total) do\n sum(rest, total + n)\n end\nend\nMath.sum([1, 2, 3, 4, 5])\n#=> 15\nLuckily, we have functions that should cover at least all of your basic needs in modules like Enum, and List.
You should be familiar with a lot of the functions, especially the most common ones like map, filter, and reduce from your other languages. They are common in languages like PHP and JavaScript.
The most notable thing about these functions is that none of them will mutate the original collection. (Actually, no functions in elixir will, ever.)
\nUsing a built-in map function to apply an anonymous function to each item in a collection:
\nlet items = ["foo", "bar", "baz"]\n\nitems.map((item) => {\n return item.toUpperCase()\n})\n\n// ["FOO", "BAR", "BAZ"]\n$items = ["foo", "bar", "baz"];\n\narray_map(function($item) {\n return strtoupper($item);\n}, $items);\n\n// ["FOO", "BAR", "BAZ"]\nitems = ["foo", "bar", "baz"]\n\nEnum.map(items, fn item ->\n String.upcase(item)\nend)\n\n# ["FOO", "BAR", "BAZ"]\nOkay, now let's combine some of what you've seen and add some more, and let's do a FizzBuzz in Elixir.
\ndefmodule FizzBuzz do\n @moduledoc """\n The classic. FizzBuzz!\n """\n\n @doc """\n Performs the classic FizzBuzz problem.\n\n ## Example\n\n iex> FizzBuzz.fizz_buzz(15)\n ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz",\n "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"]\n\n """\n @spec fizz_buzz(pos_integer()) :: [String.t()]\n def fizz_buzz(up_to) do\n Enum.map(1..up_to, &do_fizz_buzz/1)\n end\n\n defp do_fizz_buzz(n) do\n case {rem(n, 3), rem(n, 5)} do\n {0, 0} -> "FizzBuzz"\n {0, _} -> "Fizz"\n {_, 0} -> "Buzz"\n {_, _} -> to_string(n)\n end\n end\nend\nFizzBuzz.fizz_buzz(15)\n\n# Returns\n["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz",\n "11", "Fizz", "13", "14", "FizzBuzz"]\n@moduledoc is documentation for the module. You use markdown syntax and these will format nicely in docs and in IEx help functions.@doc is for documenting functions. Like @moduledoc you use markdown syntax. You can also use doctests when testing your modules and the example code will automatically be tested and asserted against the example results.""" is for multiline strings.@spec. These are optional and define the types the function expects and returns and is used solely for documentation and static analysis tools (usually including LSP).1 to up_to. A range is defined like 1..3 and this covers the integers 1 to 3, inclusive. There is additional notation for steps, so ranges can be pretty cool, and they are also more memory efficient than a list of integers.&do_fizz_buzz/1 is using the capture operator for anonymous function short-hand. It is equivalent tofn n ->\n do_fizz_buzz(n)\nend\ncase statement which is similar to a switch statement in other languages, but on steroids because of pattern-matching._ are how you tell Elixir that the variable is unused. So, because it's a variable it will match any value and assign the value to that variable for the scope that it's in, but the _ also tells Elixir that the variable is unused and will be discarded.Comprehensions might have a similar feel to for loops (or for..in, or foreach) but they are not quite the same thing. Due to recursion and scope, for example, you can not iterate on a counter variable like you might be used to in non-functional languages.
\nitems = ["foo", "bar", "baz"]\n\ni = 0\n\nfor item <- items do\n i = i + 1\n {i, item}\nend\n\n# Returns\n[\n {1, "foo"},\n {1, "bar"},\n {1, "baz"}\n]\n\n# Notice `i` is not increasing?\nA comprehension takes one (or more) generators (e.g. item <- items), conditionals (e.g. item != "foo"), and will return a list of the results of each execution.
Here are a couple of examples to get an idea of how they can work:
\nfor x <- 0..10 do\n x\nend\n\n# Returns\n[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\nfor x <- 0..10, rem(x, 2) == 0 do\n x\nend\n\n# Returns\n[0, 2, 4, 6, 8, 10]\nfor x <- 0..10, y <- 1..3, rem(x, 2) == 1 do\n {x, y}\nend\n\n# Returns\n[\n {1, 1},\n {1, 2},\n {1, 3},\n {3, 1},\n {3, 2},\n {3, 3},\n {5, 1},\n {5, 2},\n {5, 3},\n {7, 1},\n {7, 2},\n {7, 3},\n {9, 1},\n {9, 2},\n {9, 3}\n]\nThere are other options you can use with comprehensions, and interesting ways to use them in other ways (like with binaries).
\nI won't really go further into this subject, since this is just an intro post. You will usually use functions, but there are\nsome cases where comprehensions are the most clear and concise way, so don't underestimate them either.
\nPipes |> might look odd at first, but they are actually very simple and very awesome.
All that you really need to know is that they take the result of one function and pass it as the first argument into the next function. If you are familiar with unix, then you should understand the idea of a pipe operator, it's the same idea.
\nFor example, you could refactor this:
\nString.upcase("foo")\ninto:
\n"foo" |> String.upcase()\n(don't actually do this for a single function)
\nThe real beauty comes from the fact that you can chain pipes as much as you want. This gets rid of temporary variables and also improves readability significantly.
\nHere is another example refactor where I will add some chained pipes. Let's take this:
\ndef add_space_and_upcase(str) do\n split = String.codepoints(str)\n spaced = Enum.join(split, " ")\n String.upcase(spaced)\nend\n\nadd_space_and_upcase("foobar") # "F O O B A R"\nand make it much better:
\ndef add_space_and_upcase(str) do\n str\n |> String.codepoints()\n |> Enum.join(" ")\n |> String.upcase()\nend\n\nadd_space_and_upcase("foobar") # "F O O B A R"\nI think it's clear to see how great this is.
\nElixir clearly has some really great things going on, and we're not even scratching the surface here, as I've mentioned nothing about processes or OTP.
\nI hope however, that this has helped you to at least not have a mini-wtf-heartattack when you look at some elixir code and gets you interested to learn more and try it out.
\nIf you think I should include anything else, or have any critiques, please feel free to comment below.
", "url": "https://winchester.dev/posts/intro-to-elixir-for-non-ruby-programmers", "title": "Intro to Elixir for non Ruby programmers", "summary": "An introduction to Elixir from a PHP and JavaScript perspective.", "date_modified": "2017-05-08T00:00:00.000Z", "author": { "name": "Ryan Winchester" } } ] }