Category: elixir

Elixir – Modules ”; Previous Next In Elixir, we group several functions into modules. We have already used different modules in the previous chapters such as the String module, Bitwise module, Tuple module, etc. In order to create our own modules in Elixir, we use the defmodule macro. We use the def macro to define functions in that module − defmodule Math do def sum(a, b) do a + b end end In the following sections, our examples are going to get longer in size, and it can be tricky to type them all in the shell. We need to learn how to compile Elixir code and also how to run Elixir scripts. Compilation It is always convenient to write modules into files so they can be compiled and reused. Let us assume we have a file named math.ex with the following content − defmodule Math do def sum(a, b) do a + b end end We can compile the files using the command −elixirc : $ elixirc math.ex This will generate a file named Elixir.Math.beam containing the bytecode for the defined module. If we start iex again, our module definition will be available (provided that iex is started in the same directory the bytecode file is in). For example, IO.puts(Math.sum(1, 2)) The above program will generate the following result − 3 Scripted Mode In addition to the Elixir file extension .ex, Elixir also supports .exs files for scripting. Elixir treats both files exactly the same way, the only difference is in the objective. .ex files are meant to be compiled while .exs files are used for scripting. When executed, both extensions compile and load their modules into memory, although only .ex files write their bytecode to disk in the format of .beam files. For example, if we wanted to run the Math.sum in the same file, we can use the .exs in following way − Math.exs Live Demo defmodule Math do def sum(a, b) do a + b end end IO.puts(Math.sum(1, 2)) We can run it using the Elixir command − $ elixir math.exs The above program will generate the following result − 3 The file will be compiled in memory and executed, printing “3” as the result. No bytecode file will be created. Module Nesting Modules can be nested in Elixir. This feature of the language helps us organize our code in a better way. To create nested modules, we use the following syntax − defmodule Foo do #Foo module code here defmodule Bar do #Bar module code here end end The example given above will define two modules: Foo and Foo.Bar. The second can be accessed as Bar inside Foo as long as they are in the same lexical scope. If, later, the Bar module is moved outside the Foo module definition, it must be referenced by its full name (Foo.Bar) or an alias must be set using the alias directive discussed in the alias chapter. Note − In Elixir, there is no need to define the Foo module in order to define the Foo.Bar module, as the language translates all module names to atoms. You can define arbitrarilynested modules without defining any module in the chain. For example, you can define Foo.Bar.Baz without defining Foo or Foo.Bar. Print Page Previous Next Advertisements ”;

Elixir – Sigils ”; Previous Next In this chapter, we are going to explore sigils, the mechanisms provided by the language for working with textual representations. Sigils start with the tilde (~) character which is followed by a letter (which identifies the sigil) and then a delimiter; optionally, modifiers can be added after the final delimiter. Regex Regexes in Elixir are sigils. We have seen their use in the String chapter. Let us again take an example to see how we can use regex in Elixir. Live Demo # A regular expression that matches strings which contain “foo” or # “bar”: regex = ~r/foo|bar/ IO.puts(“foo” =~ regex) IO.puts(“baz” =~ regex) When the above program is run, it produces the following result − true false Sigils support 8 different delimiters − ~r/hello/ ~r|hello| ~r”hello” ~r”hello” ~r(hello) ~r[hello] ~r{hello} ~r<hello> The reason behind supporting different delimiters is that different delimiters can be more suited for different sigils. For example, using parentheses for regular expressions may be a confusing choice as they can get mixed with the parentheses inside the regex. However, parentheses can be handy for other sigils, as we will see in the next section. Elixir supports Perl compatible regexes and also support modifiers. You can read up more about the use of regexes here. Strings, Char lists and Word lists Other than regexes, Elixir has 3 more inbuilt sigils. Let us have a look at the sigils. Strings The ~s sigil is used to generate strings, like double quotes are. The ~s sigil is useful, for example, when a string contains both double and single quotes − new_string = ~s(this is a string with “double” quotes, not ”single” ones) IO.puts(new_string) This sigil generates strings. When the above program is run, it produces the following result − “this is a string with “double” quotes, not ”single” ones” Char Lists The ~c sigil is used to generate char lists − Live Demo new_char_list = ~c(this is a char list containing ”single quotes”) IO.puts(new_char_list) When the above program is run, it produces the following result − this is a char list containing ”single quotes” Word Lists The ~w sigil is used to generate lists of words (words are just regular strings). Inside the ~w sigil, words are separated by whitespace. Live Demo new_word_list = ~w(foo bar bat) IO.puts(new_word_list) When the above program is run, it produces the following result − foobarbat The ~w sigil also accepts the c, s and a modifiers (for char lists, strings and atoms, respectively), which specify the data type of the elements of the resulting list − new_atom_list = ~w(foo bar bat)a IO.puts(new_atom_list) When the above program is run, it produces the following result − [:foo, :bar, :bat] Interpolation and Escaping in Sigils Besides lowercase sigils, Elixir supports uppercase sigils to deal with escaping characters and interpolation. While both ~s and ~S will return strings, the former allows escape codes and interpolation while the latter does not. Let us consider an example to understand this − ~s(String with escape codes x26 #{“inter” <> “polation”}) # “String with escape codes & interpolation” ~S(String without escape codes x26 without #{interpolation}) # “String without escape codes \x26 without #{interpolation}” Custom Sigils We can easily create our own custom sigils. In this example, we will create a sigil to convert a string to uppercase. defmodule CustomSigil do def sigil_u(string, []), do: String.upcase(string) end import CustomSigil IO.puts(~u/tutorials point/) When we run the above code, it produces the following result − TUTORIALS POINT First we define a module called CustomSigil and within that module, we created a function called sigil_u. As there is no existing ~u sigil in the existing sigil space, we will use it. The _u indicates that we wish use u as the character after the tilde. The function definition must take two arguments, an input and a list. Print Page Previous Next Advertisements ”;

Elixir – Enumerables ”; Previous Next An enumerable is an object that may be enumerated. “Enumerated” means to count off the members of a set/collection/category one by one (usually in order, usually by name). Elixir provides the concept of enumerables and the Enum module to work with them. The functions in the Enum module are limited to, as the name says, enumerating values in data structures. Example of an enumerable data structure is a list, tuple, map, etc. The Enum module provides us with a little over 100 functions to deal with enums. We will discuss a few important functions in this chapter. All of these functions take an enumerable as the first element and a function as the second and work on them. The functions are described below. all? When we use all? function, the entire collection must evaluate to true otherwise false will be returned. For example, to check if all of the elements in the list are odd numbers, then. Live Demo res = Enum.all?([1, 2, 3, 4], fn(s) -> rem(s,2) == 1 end) IO.puts(res) When the above program is run, it produces the following result − false This is because not all elements of this list are odd. any? As the name suggests, this function returns true if any element of the collection evaluates to true. For example − Live Demo res = Enum.any?([1, 2, 3, 4], fn(s) -> rem(s,2) == 1 end) IO.puts(res) When the above program is run, it produces the following result − true chunk This function divides our collection into small chunks of the size provided as the second argument. For example − res = Enum.chunk([1, 2, 3, 4, 5, 6], 2) IO.puts(res) When the above program is run, it produces the following result − [[1, 2], [3, 4], [5, 6]] each It may be necessary to iterate over a collection without producing a new value, for this case we use the each function − Live Demo Enum.each([“Hello”, “Every”, “one”], fn(s) -> IO.puts(s) end) When the above program is run, it produces the following result − Hello Every one map To apply our function to each item and produce a new collection we use the map function. It is one of the most useful constructs in functional programming as it is quite expressive and short. Let us consider an example to understand this. We will double the values stored in a list and store it in a new list res − res = Enum.map([2, 5, 3, 6], fn(a) -> a*2 end) IO.puts(res) When the above program is run, it produces the following result − [4, 10, 6, 12] reduce The reduce function helps us reduce our enumerable to a single value. To do this, we supply an optional accumulator (5 in this example) to be passed into our function; if no accumulator is provided, the first value is used − Live Demo res = Enum.reduce([1, 2, 3, 4], 5, fn(x, accum) -> x + accum end) IO.puts(res) When the above program is run, it produces the following result − 15 The accumulator is the initial value passed to the fn. From the second call onwards the value returned from previous call is passed as accum. We can also use reduce without the accumulator − Live Demo res = Enum.reduce([1, 2, 3, 4], fn(x, accum) -> x + accum end) IO.puts(res) When the above program is run, it produces the following result − 10 uniq The uniq function removes duplicates from our collection and returns only the set of elements in the collection. For example − res = Enum.uniq([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]) IO.puts(res) When running above program, it produces the following result − [1, 2, 3, 4] Eager Evaluation All the functions in the Enum module are eager. Many functions expect an enumerable and return a list back. This means that when performing multiple operations with Enum, each operation is going to generate an intermediate list until we reach the result. Let us consider the following example to understand this − odd? = &(odd? = &(rem(&1, 2) != 0) res = 1..100_000 |> Enum.map(&(&1 * 3)) |> Enum.filter(odd?) |> Enum.sum IO.puts(res) When the above program is run, it produces the following result − 7500000000 The example above has a pipeline of operations. We start with a range and then multiply each element in the range by 3. This first operation will now create and return a list with 100_000 items. Then we keep all odd elements from the list, generating a new list, now with 50_000 items, and then we sum all entries. The |> symbol used in the snippet above is the pipe operator: it simply takes the output from the expression on its left side and passes it as the first argument to the function call on its right side. It’s similar to the Unix | operator. Its purpose is to highlight the flow of data being transformed by a series of functions. Without the pipe operator, the code looks complicated − Enum.sum(Enum.filter(Enum.map(1..100_000, &(&1 * 3)), odd?)) We have many other functions, however, only a few important ones have been described here. Print Page Previous Next Advertisements ”;

Elixir – File IO ”; Previous Next File IO is an integral part of any programming language as it allows the language to interact with the files on the file system. In this chapter, we will discuss two modules − Path and File. The Path Module The path module is a very small module that can be considered as a helper module for filesystem operations. The majority of the functions in the File module expect paths as arguments. Most commonly, those paths will be regular binaries. The Path module provides facilities for working with such paths. Using functions from the Path module as opposed to just manipulating binaries is preferred since the Path module takes care of different operating systems transparently. It is to be observed that Elixir will automatically convert slashes (/) into backslashes () on Windows when performing file operations. Let us consider the following example to further understand the Path module − Live Demo IO.puts(Path.join(“foo”, “bar”)) When the above program is run, it produces the following result − foo/bar There are a lot of methods that the path module provides. You can have a look at the different methods here. These methods are frequently used if you are performing many file manipulation operations. The File Module The file module contains functions that allow us to open files as IO devices. By default, files are opened in binary mode, which requires developers to use the specific IO.binread and IO.binwrite functions from the IO module. Let us create a file called newfile and write some data to it. {:ok, file} = File.read(“newfile”, [:write]) # Pattern matching to store returned stream IO.binwrite(file, “This will be written to the file”) If you go to open the file we just wrote into, content will be displayed in the following way − This will be written to the file Let us now understand how to use the file module. Opening a file To open a file, we can use any one of the following 2 functions − {:ok, file} = File.open(“newfile”) file = File.open!(“newfile”) Let us now understand the difference between the File.open function and the File.open!() function. The File.open function always returns a tuple. If file is successfully opened, it returns the first value in the tuple as :ok and the second value is literal of type io_device. If an error is caused, it will return a tuple with first value as :error and second value as the reason. The File.open!() function on the other hand will return a io_device if file is successfully opened else it will raise an error. NOTE: This is the pattern followed in all of the file module functions we are going to discuss. We can also specify the modes in which we want to open this file. To open a file as read only and in utf-8 encoding mode, we use the following code − file = File.open!(“newfile”, [:read, :utf8]) Writing to a File We have two ways to write to files. Let us see the first one using the write function from the File module. File.write(“newfile”, “Hello”) But this should not be used if you are making multiple writes to the same file. Every time this function is invoked, a file descriptor is opened and a new process is spawned to write to the file. If you are doing multiple writes in a loop, open the file via File.open and write to it using the methods in IO module. Let us consider an example to understand the same − #Open the file in read, write and utf8 modes. file = File.open!(“newfile_2”, [:read, :utf8, :write]) #Write to this “io_device” using standard IO functions IO.puts(file, “Random text”) You can use other IO module methods like IO.write and IO.binwrite to write to files opened as io_device. Reading from a File We have two ways to read from files. Let us see the first one using the read function from the File module. IO.puts(File.read(“newfile”)) When running this code, you should get a tuple with the first element as :ok and the second one as the contents of newfile We can also use the File.read! function to just get the contents of the files returned to us. Closing an Open File Whenever you open a file using the File.open function, after you are done using it, you should close it using the File.close function − File.close(file) Print Page Previous Next Advertisements ”;

Elixir – Pattern Matching ”; Previous Next Pattern matching is a technique which Elixir inherits form Erlang. It is a very powerful technique that allows us to extract simpler substructures from complicated data structures like lists, tuples, maps, etc. A match has 2 main parts, a left and a right side. The right side is a data structure of any kind. The left side attempts to match the data structure on the right side and bind any variables on the left to the respective substructure on the right. If a match is not found, the operator raises an error. The simplest match is a lone variable on the left and any data structure on the right. This variable will match anything. For example, Live Demo x = 12 x = “Hello” IO.puts(x) You can place variables inside a structure so that you can capture a substructure. For example, [var_1, _unused_var, var_2] = [{“First variable”}, 25, “Second variable” ] IO.puts(var_1) IO.puts(var_2) This will store the values, {“First variable”} in var_1 and “Second variable” in var_2. There is also a special _ variable(or variables prefixed with ”_”) that works exactly like other variables but tells elixir, “Make sure something is here, but I don”t care exactly what it is.”. In the previous example, _unused_var was one such variable. We can match more complicated patterns using this technique. For example if you want to unwrap and get a number in a tuple which is inside a list which itself is in a list, you can use the following command − Live Demo [_, [_, {a}]] = [“Random string”, [:an_atom, {24}]] IO.puts(a) The above program generates the following result − 24 This will bind a to 24. Other values are ignored as we are using ”_”. In pattern matching, if we use a variable on the right, its value is used. If you want to use the value of a variable on the left, you”ll need to use the pin operator. For example, if you have a variable “a” having value 25 and you want to match it with another variable “b” having value 25, then you need to enter − a = 25 b = 25 ^a = b The last line matches the current value of a, instead of assigning it, to the value of b. If we have a non-matching set of left and right hand side, the match operator raises an error. For example, if we try to match a tuple with a list or a list of size 2 with a list of size 3, an error will be displayed. Print Page Previous Next Advertisements ”;

Elixir Tutorial PDF Version Quick Guide Resources Job Search Discussion Elixir is a dynamic, functional language designed for building scalable and maintainable applications. It is built on top of Erlang. Elixir leverages the Erlang VM, known for running low-latency, distributed and fault-tolerant systems, while also being successfully used in web development and the embedded software domain. Audience This tutorial is created for software programmers who aim to learn the fundamentals of Elixir programming language from scratch. This tutorial will give you a basic foundation to start programming in Elixir programming language. Prerequisites Before proceeding with this tutorial, you should have a basic understanding of Computer Programming terminologies and exposure to any other programming language. Some familiarity with functional programming will help you in learning Elixir. Print Page Previous Next Advertisements ”;

Elixir – Basic Syntax ”; Previous Next We will start with the customary ”Hello World” program. To start the Elixir interactive shell, enter the following command. iex After the shell starts, use the IO.puts function to “put” the string on the console output. Enter the following in your Elixir shell − Live Demo IO.puts “Hello world” In this tutorial, we will use the Elixir script mode where we will keep the Elixir code in a file with the extension .ex. Let us now keep the above code in the test.ex file. In the succeeding step, we will execute it using elixirc− Live Demo IO.puts “Hello world” Let us now try to run the above program as follows − $elixirc test.ex The above program generates the following result − Hello World Here we are calling a function IO.puts to generate a string to our console as output. This function can also be called the way we do in C, C++, Java, etc., providing arguments in parentheses following the function name − IO.puts(“Hello world”) Comments Single line comments start with a ”#” symbol. There”s no multi-line comment, but you can stack multiple comments. For example − #This is a comment in Elixir Line Endings There are no required line endings like ”;” in Elixir. However, we can have multiple statements in the same line, using ”;”. For example, Live Demo IO.puts(“Hello”); IO.puts(“World!”) The above program generates the following result − Hello World! Identifiers Identifiers like variables, function names are used to identify a variable, function, etc. In Elixir, you can name your identifiers starting with a lower case alphabet with numbers, underscores and upper case letters thereafter. This naming convention is commonly known as snake_case. For example, following are some valid identifiers in Elixir − var1 variable_2 one_M0r3_variable Please note that variables can also be named with a leading underscore. A value that is not meant to be used must be assigned to _ or to a variable starting with underscore − _some_random_value = 42 Also elixir relies on underscores to make functions private to modules. If you name a function with a leading underscore in a module, and import that module, this function will not be imported. There are many more intricacies related to function naming in Elixir which we will discuss in coming chapters. Reserved Words Following words are reserved and cannot be used as variables, module or function names. after and catch do inbits inlist nil else end not or false fn in rescue true when xor __MODULE__ __FILE__ __DIR__ __ENV__ __CALLER__ Print Page Previous Next Advertisements ”;

Elixir – Operators ”; Previous Next An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. There are a LOT of operators provided by elixir. They are divided in the following categories − Arithmetic operators Comparison operators Boolean operators Misc operators Arithmetic Operators The following table shows all the arithmetic operators supported by Elixir language. Assume variable A holds 10 and variable B holds 20, then − Show Examples Operator Description Example + Adds 2 numbers. A + B will give 30 – Subtracts second number from first. A-B will give -10 * Multiplies two numbers. A*B will give 200 / Divides first number from second. This casts the numbers in floats and gives a float result A/B will give 0.5. div This function is used to get the quotient on division. div(10,20) will give 0 rem This function is used to get the remainder on division. rem(A, B) will give 10 Comparison Operators The comparison operators in Elixir are mostly common to those provided in most other languages. The following table sums up comparison operators in Elixir. Assume variable A holds 10 and variable B holds 20, then − Show Examples Operator Description Example == Checks if value on left is equal to value on right(Type casts values if they are not the same type). A == B will give false != Checks if value on left is not equal to value on right. A != B will give true === Checks if type of value on left equals type of value on right, if yes then check the same for value. A === B will give false !== Same as above but checks for inequality instead of equality. A !== B will give true > Checks if the value of left operand is greater than the value of right operand; if yes, then the condition becomes true. A > B will give false < Checks if the value of left operand is less than the value of right operand; if yes, then the condition becomes true. A < B will give true >= Checks if the value of left operand is greater than or equal to the value of right operand; if yes, then the condition becomes true. A >= B will give false <= Checks if the value of left operand is less than or equal to the value of right operand; if yes, then the condition becomes true. A <= B will give true Logical operators Elixir provides 6 logical operators: and, or, not, &&, || and !. The first three, and or not are strict Boolean operators, meaning that they expect their first argument to be a Boolean. Non Boolean argument will raise an error. While the next three, &&, || and ! are non strict, do not require us to have the first value strictly as a boolean. They work in the same way as their strict counterparts. Assume variable A holds true and variable B holds 20, then − Show Examples Operator Description Example and Checks if both values provided are truthy, if yes then returns the value of second variable. (Logical and). A and B will give 20 or Checks if either value provided is truthy. Returns whichever value is truthy. Else returns false. (Logical or). A or B will give true not Unary operator which inverts the value of given input. not A will give false && Non-strict and. Works same as and but does not expect first argument to be a Boolean. B && A will give 20 || Non-strict or. Works same as or but does not expect first argument to be a Boolean. B || A will give true ! Non-strict not. Works same as not but does not expect the argument to be a Boolean. !A will give false NOTE −and, or, && and || || are short circuit operators. This means that if the first argument of and is false, then it will not further check for the second one. And if the first argument of or is true, then it will not check for the second one. For example, false and raise(“An error”) #This won”t raise an error as raise function wont get executed because of short #circuiting nature of and operator Bitwise Operators Bitwise operators work on bits and perform bit by bit operation. Elixir provides bitwise modules as part of the package Bitwise, so in order to use these, you need to use the bitwise module. To use it, enter the following command in your shell − use Bitwise Assume A to be 5 and B to be 6 for the following examples − Show Examples Operator Description Example &&& Bitwise and operator copies a bit to result if it exists in both operands. A &&& B will give 4 ||| Bitwise or operator copies a bit to result if it exists in either operand. A ||| B will give 7 >>> Bitwise right shift operator shifts first operand bits to the right by the number specified in second operand. A >>> B will give 0 <<< Bitwise left shift operator shifts first operand bits to the left by the number specified in second operand. A <<< B will give 320 ^^^ Bitwise XOR operator copies a bit to result only if it is different on both operands. A ^^^ B will give 3 ~~~ Unary bitwise not inverts the bits on the given number. ~~~A will give -6 Misc Operators Other than the above operators, Elixir also provides a range of other operators like Concatenation Operator, Match Operator, Pin Operator, Pipe Operator, String Match Operator, Code Point Operator, Capture Operator, Ternary Operator that make it quite a powerful language. Show Examples Print Page Previous Next Advertisements ”;

Elixir – Environment ”; Previous Next In order to run Elixir, you need to set it up locally on your system. To install Elixir, you will first require Erlang. On some platforms, Elixir packages come with Erlang in them. Installing Elixir Let us now understand the installation of Elixir in different Operating Systems. Windows Setup To install Elixir on windows, download installer from https://elixir-lang.org/install.html#windows and simply click Next to proceed through all steps. You will have it on your local system. If you have any problems while installing it, you can check this page for more info. Mac Setup If you have Homebrew installed, make sure that it is the latest version. For updating, use the following command − brew update Now, install Elixir using the command given below − brew install elixir Ubuntu/Debian Setup The steps to install Elixir in an Ubuntu/Debian setup is as follows − Add Erlang Solutions repo − wget https://packages.erlang-solutions.com/erlang-solutions_1.0_all.deb && sudo dpkg -i erlang-solutions_1.0_all.deb sudo apt-get update Install the Erlang/OTP platform and all of its applications − sudo apt-get install esl-erlang Install Elixir − sudo apt-get install elixir Other Linux Distros If you have any other Linux distribution, please visit this page to set up elixir on your local system. Testing the Setup To test the Elixir setup on your system, open your terminal and enter iex in it. It will open the interactive elixir shell like the following − Erlang/OTP 19 [erts-8.0] [source-6dc93c1] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false] Interactive Elixir (1.3.1) – press Ctrl+C to exit (type h() ENTER for help) iex(1)> Elixir is now successfully set up on your system. Print Page Previous Next Advertisements ”;

Elixir – Overview ”; Previous Next Elixir is a dynamic, functional language designed for building scalable and maintainable applications. It leverages the Erlang VM, known for running low-latency, distributed and fault-tolerant systems, while also being successfully used in web development and the embedded software domain. Elixir is a functional, dynamic language built on top of Erlang and the Erlang VM. Erlang is a language that was originally written in 1986 by Ericsson to help solve telephony problems like distribution, fault-tolerance, and concurrency. Elixir, written by José Valim, extends Erlang and provides a friendlier syntax into the Erlang VM. It does this while keeping the performance of the same level as Erlang. Features of Elixir Let us now discuss a few important features of Elixir − Scalability − All Elixir code runs inside lightweight processes that are isolated and exchange information via messages. Fault Tolerance − Elixir provides supervisors which describe how to restart parts of your system when things go wrong, going back to a known initial state that is guaranteed to work. This ensures your application/platform is never down. Functional Programming − Functional programming promotes a coding style that helps developers write code that is short, fast, and maintainable. Build tools − Elixir ships with a set of development tools. Mix is one such tool that makes it easy to create projects, manage tasks, run tests, etc. It also has its own package manager − Hex. Erlang Compatibility − Elixir runs on the Erlang VM giving developers complete access to Erlang’s ecosystem. Print Page Previous Next Advertisements ”;