Category: elixir

Elixir – Macros ”; Previous Next Macros are one of the most advanced and powerful features of Elixir. As with all advanced features of any language, macros should be used sparingly. They make it possible to perform powerful code transformations in compilation time. We will now understand what macros are and how to use them in brief. Quote Before we start talking about macros, let us first look at Elixir internals. An Elixir program can be represented by its own data structures. The building block of an Elixir program is a tuple with three elements. For example, the function call sum(1, 2, 3) is represented internally as − {:sum, [], [1, 2, 3]} The first element is the function name, the second is a keyword list containing metadata and the third is the arguments list. You can get this as the output in iex shell if you write the following − quote do: sum(1, 2, 3) Operators are also represented as such tuples. Variables are also represented using such triplets, except that the last element is an atom, instead of a list. When quoting more complex expressions, we can see that the code is represented in such tuples, which are often nested inside each other in a structure resembling a tree. Many languages would call such representations an Abstract Syntax Tree (AST). Elixir calls these quoted expressions. Unquote Now that we can retrieve the internal structure of our code, how do we modify it? To inject new code or values, we use unquote. When we unquote an expression it will be evaluated and injected into the AST. Let us consider an example(in iex shell) to understand the concept − num = 25 quote do: sum(15, num) quote do: sum(15, unquote(num)) When the above program is run, it produces the following result − {:sum, [], [15, {:num, [], Elixir}]} {:sum, [], [15, 25]} In the example for the quote expression, it did not automatically replace num with 25. We need to unquote this variable if we want to modify the AST. Macros So now that we are familiar with quote and unquote, we can explore metaprogramming in Elixir using macros. In the simplest of terms macros are special functions designed to return a quoted expression that will be inserted into our application code. Imagine the macro being replaced with the quoted expression rather than called like a function. With macros we have everything necessary to extend Elixir and dynamically add code to our applications Let us implement unless as a macro. We will begin by defining the macro using the defmacro macro. Remember that our macro needs to return a quoted expression. defmodule OurMacro do defmacro unless(expr, do: block) do quote do if !unquote(expr), do: unquote(block) end end end require OurMacro OurMacro.unless true, do: IO.puts “True Expression” OurMacro.unless false, do: IO.puts “False expression” When the above program is run, it produces the following result − False expression What is happening here is our code is being replaced by the quoted code returned by the unless macro. We have unquoted the expression to evaluate it in current context and also unquoted the do block to execute it in its context. This example shows us metaprogramming using macros in elixir. Macros can be used in much more complex tasks but should be used sparingly. This is because metaprogramming in general is considered a bad practice and should be used only when necessary. Print Page Previous Next Advertisements ”;

Elixir – Libraries ”; Previous Next Elixir provides excellent interoperability with Erlang libraries. Let us discuss a few libraries in brief. The Binary Module The built-in Elixir String module handles binaries that are UTF-8 encoded. The binary module is useful when you are dealing with binary data that is not necessarily UTF-8 encoded. Let us consider an example to further understand the Binary module − # UTF-8 IO.puts(String.to_char_list(“Ø”)) # binary IO.puts(:binary.bin_to_list “Ø”) When the above program is run, it produces the following result − [216] [195, 152] The above example shows the difference; the String module returns UTF-8 codepoints, while :binary deals with raw data bytes. The Crypto Module The crypto module contains hashing functions, digital signatures, encryption and more. This module is not part of the Erlang standard library, but is included with the Erlang distribution. This means you must list :crypto in your project’s applications list whenever you use it. Let us see an example using the crypto module − Live Demo IO.puts(Base.encode16(:crypto.hash(:sha256, “Elixir”))) When the above program is run, it produces the following result − 3315715A7A3AD57428298676C5AE465DADA38D951BDFAC9348A8A31E9C7401CB The Digraph Module The digraph module contains functions for dealing with directed graphs built of vertices and edges. After constructing the graph, the algorithms in there will help finding, for instance, the shortest path between two vertices, or loops in the graph. Note that the functions in :digraph alter the graph structure indirectly as a side effect, while returning the added vertices or edges. Live Demo digraph = :digraph.new() coords = [{0.0, 0.0}, {1.0, 0.0}, {1.0, 1.0}] [v0, v1, v2] = (for c <- coords, do: :digraph.add_vertex(digraph, c)) :digraph.add_edge(digraph, v0, v1) :digraph.add_edge(digraph, v1, v2) for point <- :digraph.get_short_path(digraph, v0, v2) do {x, y} = point IO.puts(“#{x}, #{y}”) end When the above program is run, it produces the following result − 0.0, 0.0 1.0, 0.0 1.0, 1.0 The Math Module The math module contains common mathematical operations covering trigonometry, exponential and logarithmic functions. Let us consider the following example to understand how the Math module works − Live Demo # Value of pi IO.puts(:math.pi()) # Logarithm IO.puts(:math.log(7.694785265142018e23)) # Exponentiation IO.puts(:math.exp(55.0)) #… When the above program is run, it produces the following result − 3.141592653589793 55.0 7.694785265142018e23 The Queue Module The queue is a data structure that implements (double-ended) FIFO (first-in first-out) queues efficiently. The following example shows how a Queue module works − Live Demo q = :queue.new q = :queue.in(“A”, q) q = :queue.in(“B”, q) {{:value, val}, q} = :queue.out(q) IO.puts(val) {{:value, val}, q} = :queue.out(q) IO.puts(val) When the above program is run, it produces the following result − A B Print Page Previous Next Advertisements ”;

Elixir – Typespecs ”; Previous Next Elixir is a dynamically typed language, so all types in Elixir are inferred by the runtime. Nonetheless, Elixir comes with typespecs, which are a notation used for declaring custom data types and declaring typed function signatures (specifications). Function Specifications(specs) By default, Elixir provides some basic types, such as integer or pid, and also complex types: for example, the round function, which rounds a float to its nearest integer, takes a number as an argument (an integer or a float) and returns an integer. In the related documentation, the round typed signature is written as − round(number) :: integer The above description implies that the function on the left takes as argument what is specified in parenthesis and returns what is on the right of ::, i.e., Integer. Function specs are written with the @spec directive, placed right before the function definition. The round function can be written as − @spec round(number) :: integer def round(number), do: # Function implementation … Typespecs support complex types as well, for example, if you want to return a list of integers, then you can use [Integer] Custom Types While Elixir provides a lot of useful inbuilt types, it is convenient to define custom types when appropriate. This can be done when defining modules through the @type directive. Let us consider an example to understand the same − Live Demo defmodule FunnyCalculator do @type number_with_joke :: {number, String.t} @spec add(number, number) :: number_with_joke def add(x, y), do: {x + y, “You need a calculator to do that?”} @spec multiply(number, number) :: number_with_joke def multiply(x, y), do: {x * y, “It is like addition on steroids.”} end {result, comment} = FunnyCalculator.add(10, 20) IO.puts(result) IO.puts(comment) When the above program is run, it produces the following result − 30 You need a calculator to do that? NOTE − Custom types defined through @type are exported and available outside the module they are defined in. If you want to keep a custom type private, you can use the @typep directive instead of @type. Print Page Previous Next Advertisements ”;

Elixir – Streams ”; Previous Next Many functions expect an enumerable and return a list back. It means, while performing multiple operations with Enum, each operation is going to generate an intermediate list until we reach the result. Streams support lazy operations as opposed to eager operations by enums. In short, streams are lazy, composable enumerables. What this means is Streams do not perform an operation unless it is absolutely needed. Let us consider an example to understand this − Live Demo odd? = &(rem(&1, 2) != 0) res = 1..100_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?) |> Enum.sum IO.puts(res) When the above program is run, it produces the following result − 7500000000 In the example given above, 1..100_000 |> Stream.map(&(&1 * 3)) returns a data type, an actual stream, that represents the map computation over the range 1..100_000. It has not yet evaluated this representation. Instead of generating intermediate lists, streams build a series of computations that are invoked only when we pass the underlying stream to the Enum module. Streams are useful when working with large, possibly infinite, collections. Streams and enums have many functions in common. Streams mainly provide the same functions provided by the Enum module which generated Lists as their return values after performing computations on input enumerables. Some of them are listed in the following table − Sr.No. Function and its Description 1 chunk(enum, n, step, leftover \ nil) Streams the enumerable in chunks, containing n items each, where each new chunk starts step elements into the enumerable. 2 concat(enumerables) Creates a stream that enumerates each enumerable in an enumerable. 3 each(enum, fun) Executes the given function for each item. 4 filter(enum, fun) Creates a stream that filters elements according to the given function on enumeration. 5 map(enum, fun) Creates a stream that will apply the given function on enumeration. 6 drop(enum, n) Lazily drops the next n items from the enumerable. Print Page Previous Next Advertisements ”;

Elixir – Comprehensions ”; Previous Next List comprehensions are syntactic sugar for looping through enumerables in Elixir. In this chapter we will use comprehensions for iteration and generation. Basics When we looked at the Enum module in the enumerables chapter, we came across the map function. Enum.map(1..3, &(&1 * 2)) In this example, we will pass a function as the second argument. Each item in the range will be passed into the function, and then a new list will be returned containing the new values. Mapping, filtering, and transforming are very common actions in Elixir and so there is a slightly different way of achieving the same result as the previous example − for n <- 1..3, do: n * 2 When we run the above code, it produces the following result − [2, 4, 6] The second example is a comprehension, and as you can probably see, it is simply syntactic sugar for what you can also achieve if you use the Enum.map function. However, there are no real benefits to using a comprehension over a function from the Enum module in terms of performance. Comprehensions are not limited to lists but can be used with all enumerables. Filter You can think of filters as a sort of guard for comprehensions. When a filtered value returns false or nil it is excluded from the final list. Let us loop over a range and only worry about even numbers. We will use the is_even function from the Integer module to check if a value is even or not. import Integer IO.puts(for x <- 1..10, is_even(x), do: x) When the above code is run, it produces the following result − [2, 4, 6, 8, 10] We can also use multiple filters in the same comprehension. Add another filter that you want after the is_even filter separated by a comma. :into Option In the examples above, all the comprehensions returned lists as their result. However, the result of a comprehension can be inserted into different data structures by passing the :into option to the comprehension. For example, a bitstring generator can be used with the :into option in order to easily remove all spaces in a string − Live Demo IO.puts(for <<c <- ” hello world “>>, c != ?s, into: “”, do: <<c>>) When the above code is run, it produces the following result − helloworld The above code removes all spaces from the string using c != ?s filter and then using the :into option, it puts all the returned characters in a string. Print Page Previous Next Advertisements ”;

Elixir – Quick Guide ”; Previous Next Elixir – Overview 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. Elixir – Environment 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. Elixir – Basic Syntax 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__ Elixir – Data Types For using any language, you need to understand the basic data types the language supports. In this chapter, we will discuss 7 basic data types supported by the elixir language: integers, floats, Booleans, atoms, strings, lists and tuples. Numerical Types Elixir, like any other programming language, supports both integers and

Elixir – Behaviours ”; Previous Next Behaviors in Elixir (and Erlang) are a way to separate and abstract the generic part of a component (which becomes the behavior module) from the specific part (which becomes the callback module). Behaviors provide a way to − Define a set of functions that have to be implemented by a module. Ensure that a module implements all the functions in that set. If you have to, you can think of behaviors like interfaces in object oriented languages like Java: a set of function signatures that a module has to implement. Defining a Behaviour Let us consider an example to create our own behavior and then use this generic behavior to create a module. We will define a behavior that greets people hello and goodbye in different languages. defmodule GreetBehaviour do @callback say_hello(name :: string) :: nil @callback say_bye(name :: string) :: nil end The @callback directive is used to list the functions that adopting modules will need to define. It also specifies the no. of arguments, their type and their return values. Adopting a Behaviour We have successfully defined a behavior. Now we will adopt and implement it in multiple modules. Let us create two modules implementing this behavior in English and Spanish. Live Demo defmodule GreetBehaviour do @callback say_hello(name :: string) :: nil @callback say_bye(name :: string) :: nil end defmodule EnglishGreet do @behaviour GreetBehaviour def say_hello(name), do: IO.puts(“Hello ” name) def say_bye(name), do: IO.puts(“Goodbye, ” name) end defmodule SpanishGreet do @behaviour GreetBehaviour def say_hello(name), do: IO.puts(“Hola ” name) def say_bye(name), do: IO.puts(“Adios ” name) end EnglishGreet.say_hello(“Ayush”) EnglishGreet.say_bye(“Ayush”) SpanishGreet.say_hello(“Ayush”) SpanishGreet.say_bye(“Ayush”) When the above program is run, it produces the following result − Hello Ayush Goodbye, Ayush Hola Ayush Adios Ayush As you have already seen, we adopt a behaviour using the @behaviour directive in the module. We have to define all the functions implemented in the behaviour for all the child modules. This can roughly be considered equivalent to interfaces in OOP languages. Print Page Previous Next Advertisements ”;

Discuss Elixir ”; Previous Next 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. Print Page Previous Next Advertisements ”;

Elixir – Functions ”; Previous Next A function is a set of statements organized together to perform a specific task. Functions in programming work mostly like function in Math. You give functions some input, they generate output based on the input provided. There are 2 types of functions in Elixir − Anonymous function Functions defined using the fn..end construct are anonymous functions. These functions are sometimes also called as lambdas. They are used by assigning them to variable names. Named function Functions defined using the def keyword are named functions. These are native functions provided in Elixir. Anonymous Functions Just as the name implies, an anonymous function has no name. These are frequently passed to other functions. To define an anonymous function in Elixir, we need the fn and end keywords. Within these, we can define any number of parameters and function bodies separated by ->. For example, Live Demo sum = fn (a, b) -> a + b end IO.puts(sum.(1, 5)) When running above program, is run, it generates the following result − 6 Note that these functions are not called like the named functions. We have a ”.” between the function name and its arguments. Using the Capture Operator We can also define these functions using the capture operator. This is an easier method to create functions. We will now define the above sum function using the capture operator, Live Demo sum = &(&1 + &2) IO.puts(sum.(1, 2)) When the above program is run, it generates the following result − 3 In the shorthand version, our parameters are not named but are available to us as &1, &2, &3, and so on. Pattern Matching Functions Pattern matching is not only limited to variables and data structures. We can use pattern matching to make our functions polymorphic. For example, we will declare a function that can either take 1 or 2 inputs (within a tuple) and print them to the console, Live Demo handle_result = fn {var1} -> IO.puts(“#{var1} found in a tuple!”) {var_2, var_3} -> IO.puts(“#{var_2} and #{var_3} found!”) end handle_result.({“Hey people”}) handle_result.({“Hello”, “World”}) When the above program is run, it produces the following result − Hey people found in a tuple! Hello and World found! Named Functions We can define functions with names so we can easily refer to them later. Named functions are defined within a module using the def keyword. Named functions are always defined in a module. To call named functions, we need to reference them using their module name. The following is the syntax for named functions − def function_name(argument_1, argument_2) do #code to be executed when function is called end Let us now define our named function sum within the Math module. Live Demo defmodule Math do def sum(a, b) do a + b end end IO.puts(Math.sum(5, 6)) When running above program, it produces following result − 11 For 1-liner functions, there is a shorthand notation to define these functions, using do:. For example − Live Demo defmodule Math do def sum(a, b), do: a + b end IO.puts(Math.sum(5, 6)) When running above program, it produces following result − 11 Private Functions Elixir provides us the ability to define private functions that can be accessed from within the module in which they are defined. To define a private function, use defp instead of def. For example, defmodule Greeter do def hello(name), do: phrase <> name defp phrase, do: “Hello ” end Greeter.hello(“world”) When the above program is run, it produces the following result − Hello world But if we just try to explicitly call phrase function, using the Greeter.phrase() function, it will raise an error. Default arguments If we want a default value for an argument, we use the argument \ value syntax − defmodule Greeter do def hello(name, country \ “en”) do phrase(country) <> name end defp phrase(“en”), do: “Hello, ” defp phrase(“es”), do: “Hola, ” end Greeter.hello(“Ayush”, “en”) Greeter.hello(“Ayush”) Greeter.hello(“Ayush”, “es”) When the above program is run, it produces the following result − Hello, Ayush Hello, Ayush Hola, Ayush Print Page Previous Next Advertisements ”;

Elixir – Useful Resources ”; Previous Next The following resources contain additional information on Elixir. Please use them to get more in-depth knowledge on this topic. Useful Video Courses Master ELIXIR Programming from ZERO to HERO 36 Lectures 3 hours Pranjal Srivastava More Detail Full Stack Web Development – HTML, CSS, JavaScript, PHP, ELIXIR 55 Lectures 6 hours Pranjal Srivastava, Harshit Srivastava More Detail Python and Elixir Programming Bundle Course 81 Lectures 9.5 hours Pranjal Srivastava More Detail Elixir and Phoenix: Real World Functional Programming Course 44 Lectures 4 hours Mohammad Nauman More Detail Elixir Programming Course for Beginners 26 Lectures 2.5 hours Szabo Daniel Erno More Detail Print Page Previous Next Advertisements ”;