Killer Elixir-Tips
Last updated
Last updated
Elixir Tips and Tricks from the Experience of Development. Each part consists of 10 Unique Tips and Tricks with a clear explanation with live examples and outputs. These tips will speed up your development and save you time in typing code as well.
You can read specific parts with following links...
All Photos by Form on Unsplash
Checkout some cherry picked tips from the all Parts
Copy the content into a file and save the file as .iex.exs
in your ~
home directory and see the magic. You can also download the file HERE
Each x
sigil calls its respective sigil_x
definition
Defining Custom Sigils
usage
Load the module into iex
Define Custom Error
Usage
Define a Protocol
A Protocol is a way to dispatch to a particular implementation of a function based on the type of the parameter. The macros defprotocol
and defimpl
are used to define Protocols and Protocol implementations respectively for different types in the following example.
Usage
Load the code into iex
and execute
There is no ternary operator like true ? "yes" : "no"
. So, the following is suggested.
When using pipelines, sometimes we break the pipeline for or
operation. For example:
Indeed, ||
is only a shortcut for Kernel.||
. We can use Kernel.||
in the pipeline instead to avoid breaking the pipeline.
The code above will be:
This above tip is from qhwa
Code grouping stands for something great. It shows you how your code is grouped when you write multiple lines of code in single line with out using braces. It will be more clear with the following example.
If you want to see how this line of code is grouped into, you can check in the following format..
So, by using the quote
and Macro.to_string
you can see how our code was grouped into.
This tip came out in discussion with the creator of Ecto MichalMuskala in the Elixir forum.
These replaces the nested complicated conditions. These are my best friends in the situations dealing with more complex comparisons. Trust me you gonna love this.
The ||
operator always returns the first expression which is true. Elixir doesn’t care about the remaining expressions, and won’t evaluate them after a match has been found.
||
Here if you observe the first expression is false next nil
is also false in elixir next :blackode
which evaluates to true and its value is returned immediately with out evaluating the :elixir
and :jose
. Similarly if all the statements evaluates to false
the last expression is returned.
&&
This &&
returns the second expression if the first expression is true
or else it returns the first expression with out evaluating the second expression. In the above examples the last one is the situation where we encounter to use the &&
operator.
I have self experience with this. When I was a novice in elixir, I just compared "5" > 4
unknowingly by an accident and to my surprise it returned with true
.
In Elixir every term can compare with every other term. So one has to be careful in comparisons.
Order of Comparison
number < atom < reference < fun < port < pid < tuple < map < list < bitstring (binary)
When I see this first time, I said to my self “Elixir is Crazy”. This tip really saves time and it resembles your smartness. In Elixir every operator is a macro. So, we can use them as lambda functions.
This is my recent discovery. I always encounter a situation like converting "$34.56"
which is a string and I suppose do arithmetic operations. I usually do something like this before binary pattern matching..
Tip Approach
This tip makes my day easy. I recently used this is in one of my projects.
Before I let you to use this tip, I just want to remind you that :atoms are not garbage collected. Atom keys are great! If you have a defined atoms, you are in no danger. What you should not do is converting user supplied input into atoms without sanitizing them first because it can lead to out of memory. You should also be cautious if you create dynamic atoms in your code.
But, you can use the .
to retrieve the data from the keys as map.key
unlike the usual notation like map["key"]
. That really saves on typing. But, I don’t encourage this because, as programmers we should really care about memory.
Be sure that when you try to retrieve a key with .
form which is not present in the map, it will raise a key error instead of returning the nil
unlike the map["key"]
which returns nil
if key
is not present in a map
.
Elixir >=1.4.0
has ANSI color printing option to console. You can have great fun with colors. You can also provide background colors.
The red prints in red color, green in green color, yellow in yellow color and normal in white. Have fun with colors…
For more details on color printing check Printex module which I created for fun in Elixir.
We cannot make use of the functions as guard clauses in elixir. It means, when
cannot accept custom defined functions. Consider the following lines of code…
Here we defined a module Hello
and a function hello
that takes two parameters of name
and age
. So, based on age I am trying IO.puts
accordingly. If you do so you will get an error saying….
This is because when cannot accept functions as guards. We need to convert them to macros
Lets do that…
In the above lines of code, we wrapped all our guards inside a module MyGuards
and make sure the module is top of the module Hello
so, the macros first gets compiled. Now compile and execute you will see the following output..
Starting on Elixir v1.6, you can use defguard/1.
The defguard
is also a macro. You can also create private guards with defguardp
. Hope, you got the point here.
Consider the following example.
NOTE: The defguard
and defguardp
should reside inside the module like other macros. It raises a compile time error, if some thing that don't fit in the guard clause section when
.
Suppose, you want to check the given number is either three
or five
, you can define the guard as following.
Usage
You can also use them inside your code logic as they results boolean
value.
Check the following execution screen shot.
Sometimes, we have to make sure that certain module is loaded before making a call to the function. We are supposed to ensure the module is loaded.
Similarly we are having ensure_compile
to check whether the module is compiled or not…
Elixir provides a special syntax which is usually used for module names. What is called a module name is an uppercase ASCII letter followed by any number of lowercase or uppercase ASCII letters, numbers, or underscores.
This identifier is equivalent to an atom prefixed by Elixir.
So in the defmodule Blackode
example Blackode
is equivalent to :"Elixir.Blackode"
When we use String.to_atom "Blackode"
it converts it into :Blackode
But actually we need something like “Blackode” to Blackode. To do that we need to use Module.concat
In Command line applications whatever you pass they convert it into binary. So, again you suppose to do some casting operations …
We all know that =
does the pattern match for left and right side. We cannot do [a, b, c] = [1, 2, 3, 4]
this raise a MatchError
We can use destructure/2
to do the job.
If the left side is having more entries than in right side, it assigns the nil
value for remaining entries..
We can decorate our output with inspect
and label
option. The string of label
is added at the beginning of the data we are inspecting.
If you closely observe this it again returns the inspected data. So, we can use them as intermediate results in |>
pipe operations like following……
You will see the following output
We can pass the anonymous functions in two ways. One is directly using &
like following..
This is the most weirdest approach. How ever, we can use the reference of the anonymous function by giving its name.
The above style is much better than previous . You can also use fn
to define anonymous functions.
Or use Kernel.then/2
function since 1.12.0
We can use ?
operator to retrieve character integer codepoints.
The following two tips are mostly useful for beginners…
We can perform the subtraction over lists for removing the elements in list.
We can also perform same operations on char lists too..
If the element to subtract is not present in the list then it simply returns the list.
You can run multiple tasks by separating them with coma ,
How ever you can also create aliases in your mix project in a file called mix.exs
.
The project definition looks like the following way when you create one using a mix
tool.
You are also allowed to add some extra fields…
Here you have to add the aliases
field.
Don’t forget to add ,
at the end when you add this in the middle of list
.
The aliases()
should return the key-value
list.
So, whenever you run the mix ecto.setup
the three tasks ecto.create
, ecto.migrate
and ecto.seed
will run one after the other.
You can also add them directly as following unlike I did with private function.
Elixir stores the documentation inside the bytecode
in a memory. You access the documentation with the help of Code.get_docs/2
function . This means, the documentation accessed when it is required, but not when it is loaded in the virtual machine like iex
Suppose you defined a module in memory like ones you defined in IEx, cannot have their documentation accessed as they do not have their bytecode written to disk.
Let us check this…
Create a module with name test.ex
with the following code. You can copy and paste it.
Now stay in the directory where your file exists and run the command
Now you can access the function definitions but not the documentation.
That means the code is compiled but documentation is not stored in the memory. So, you cannot access the docs. Lets check that…
You will see the output as nil
when you are trying to access the docs of the module you have created so far. This is because, the bytecode
is not available in disk. In simple way beam
file is not present. Lets do that...
Press Ctrl+C
twice so you will come out of the shell and this time you run the command as
After running the command, you will see a file with name Elixir.Test.beam
. Now the bytecode
for the module Test
is available in memory. Now you can access the documentation as follows...
The output is tuple with two elements. The first element is the line number of the documentation it starts and second element is the actual documentation in the binary form.
You can read more about this function here
The hack is name of a function should be an atom instead of binary.
You know that when the list contains all the numbers as ASCII values, it will list out those values instead of the original numbers. Lets check that…
The code point of a
is 97
and b
is 98
hence it is listing out them as char_list
. However you can tell the IO.inspect
to list them as list itself with option char_lists: :as_list
.
Open iex
and type h Inspect.Opts
, you will see that Elixir does this kind of thing with other values as well, specifically structs and binaries.
This macro gives the current environment information. You can get the information like current filename
line
function
and others…
You can create the pid manually in Elixir with pid
function. This comes with two flavors.
def pid(string)
Creates the pid from the string.
def pid(a, b, c)
Creates a PID with 3 non negative integers passed as arguments to the function.
Why do you create the pids manually?
Suppose, you are writing a library and you want to test one of your functions for the type pid
, then you can create one and test with it.
You cannot create the pid like assigning pid = #PID<0.21.32>
because #
is considered as comment here.
When you do like above, iex shell just wait for more input as #PID<0.21.32>
is treated as comment.
Now you enter another data to complete the expression. The entered value is the value of the pid. Lets check that…
The String.replace
function will replace the given the pattern with replacing pattern. By default, it replaces all the occurrences of the pattern. Lets check that…
The String.replace str, "@", "#"
is same as String.replace str, "@", "#", global: true
But, if you want to replace only the first occurrence of the pattern, you need to pass the option global: false
. So, it replaces only the first occurrence of @
. Lets check that…
Here only first @
is replaced with #
.
You can check the memory usage (in bytes) with :erlang.memory
However, you can pass option like :erlang.memory :atom
to get the memory usage of atoms.
We all know that a proper list is a combination of head
and tail
like [head | tail]
. We can use the same principle for picking out the elements in the list like the following way…
We all know that the get_in function is used to extract the key which is deeper inside the map by providing the list with keys like a following way…
But, if there is a list of maps [maps]
where you have to extract first_name
of the each map, generally we go for enum
. We can also achieve this by using the get_in
and Access.all()
Note: If the key is not present in map, then it returns nil Warning: When you use the get_in
along with Access.all()
, as the first value in the list of keys like above, the users datatype should be list. If you pass the map, it returns the error.
In the above lines of code returns the nil
for key which is not in the map
.
In the above lines of code returns the error for passing map .
However, you can change the position of the Access.all() in the list. But the before key should return the list. Check the following lines of code.
Deep Dive
We can also use the Access.all() with functions like update_in, get_and_update_in, etc.. For instance, given a user with a list of books, here is how to deeply traverse the map and convert all book names to uppercase:
Here, user is not a list unlike in the previous examples where we passed the users as a list. But, we changed the position of Access.all()
and inside the list of keys [:books, Access.all(), :name]
, the value of the key :books
should return the list, other wise it raises an error.
We achieve the data comprehension through for x <- [1, 2, 3], do: x + 1
. But we can also add the comprehension along with filter.
General Usage
With filters
Here I am using two lists of numbers and cross product over the lists and filtering out the product which is a odd number.
Comprehension with binary is little different. You supposed to wrap inside <<>>
Lets check that…
Did you observe that x <- b_string
is just changed something like << x <- b_string >>
to make the sense.
Here we are taking the elixir comprehension to the next level. We read the input from the keyboard and convert that to upcase and after that it should wait for another entry.
Basically IO.stream(:stdio, :line)
will the read a line input from the keyboard.
We can also alias multiple modules in one line:
By default the functions with _ are not imported. However, you can do that by importing them with :only
explicitly.
This is a common trick in elixir
. You have to concatenate the null byte <<0>>
to a string that you want to see its inner binary representation like in the following way…
See this in action here...
This is much like adding a not null constraint to the structs. When you try to define the struct with the absence of that key in the struct, it should raise an exception. Lets do that…
You have to use @enforce_keys [<keys>]
while defining the struct…
Warning Keep in mind @enforce_keys
is a simple compile-time guarantee to aid developers when building structs. It is not enforced on updates and it does not provide any sort of value-validation. The above warning is from the ORIGINAL DOCUMENTATION
Elixir provides function_exported?/3
to achieve this…
We all know how to split a string with String.split/2 function
. But you can also pass a pattern to match that over and over and splitting the string whenever it matches the pattern.
If you observe the above string, it comprises of two blank spaces , one exclamation mark !
, two minus — symbols -
and a asterisk *
symbol. Now we are going to split that string with all of those.
The pattern is generated at run time. You can still validate with :binary.compiled
You can find the distance between the two strings using String.jaro_distance/2
. This gives a float value in the range 0..1
Taking the 0
for no close and 1
is for exact closeness.
For the FUN, you can find your closeness with your name and your partner or lover in case if aren’t married. Hey… ! I am just kidding…. It is just an algorithm which is predefined where our love is undefined. Cheers …….. :)
Elixir provides @on_load
which accepts atom
as function name in the same module or a tuple
with function_name and its arity like {function_name, 0}
.
This is about multiple guards in the same clause and writing or
conditions with out using or
We all know that or
is used as a conjunction for two conditions resulting true if either one of them is true. Many of us writing the or conditions in the guard as following way…
You can also do this in bit more clear format as the following way…
See also Elixir Style Guide
Macro.to_string |> IO.puts
In general, when you pass the quote expression to Macro.to_string
, it returns the actual code in a string format and we all knew this.
The weird thing is, it gives the output in a single line along with characters inside the string.
Check it down
To print the new lines, you pipe the string output from Macro.to_string
to IO.puts
like in the following code snippet. It gives the clean output by printing in new line.
Check this in live
Finding the loaded files
Code.loaded_files
In elixir, we are having a definition loaded_files
in the module Code
used to find the loaded files.
Let’s see this.
Run the command iex
inside your terminal and call the function Code.loaded_files
.
It gives an empty list []
as output because we haven’t loaded any files so far.
File Loading
Let’s create a file hello.ex
with a single function definition hello
which just prints a string “Welcome to the world” for the demo purpose.
Save the file after editing.
Now, make sure you are in the same directory of where the file exists and run the command
It opens the Elixir interactive shell by loading the hello.ex
file as well.
Now, you can see the loaded file by calling Code.loaded_files
. It outputs the path to the file.
That is one way of loading files. You can also load them on-fly in iex session
Dynamic loading on-fly
Code.load_file/1
Unlike loading files with iex hello.ex
, you can load them on-fly in iex
session with the help of Code.load_file "path/to/file"
.
Let us assume that we have a file hello.ex
in our current directory and open iex
session from the same directory.
Let's check this in action
@deprecated
You might be noticed the warnings of using deprecated functions in a library along with some useful hint text. Today, we build this from scratch.
Suppose, you have written a library and want to update the name of one function in your next build release and if the user tried to access the old function then you have to warn him of using deprecated function instead of updated one.
To see this in action, you need to create new mix project.
Let’s do that.
Next change the directory to the project created.
Now, edit the file lib/hello.ex
in the project with the following code
This file comprises of two modules Hello
and Printee
. The Printee
module comprises of two functions print/0
and show/0
. Here purposely, print/0
is considered as a deprecated function used inside the Hello
module.
The mix compiler automatically looks for calls to deprecated modules and emit warnings during compilation.
So, when you compile the project mix compile
, it gives a warning saying
“print/0 is deprecated use show/0”
like in the following screenshot.
Deprecated Function Warning
Check the live coding
Module.create/3
As we all know defmodule
is used to create a module. In similar, Module.create/3
is also used to create a module.
The only difference in defining a module with Module.create/3
is the definition inside the module is quoted expression.
However, we can use the help of quote
to create a quoted expression.
We have to pass three parameters to Moduel.create
.
The first one is name of the module. The second one is module definition in quoted expression. The third one is location. The location is given in keyword list
like [file: String.t, line: Integer ]
or else you can just take the help of Macro.Env.location(__ENV__)
which returns the same.
location of loc
The above line of code gives the context of the module definition and collected in module_definition
. We can use this module_defintion
to pass as second parameter to Module.create/3
function.
module definition context
Let’s put all together and see the magic
Creating another module Foo
with same module function
Check out the live execution
binding
This is used in debugging purpose inside the function.
It is also very common to use IO.inspect/2
with binding()
, which returns all variable names and their values:
When fun/2
is invoked with :laughing
, "time"
it prints:
You can also give context to the binding
If the given context is nil *(by default it is), *the binding for the current context is returned.
Check out the live execution
We can convert any integer to charlist using Integer.char_list
. It can be used in two ways either passing the base the base value or not passing.
Let’s try with base and with out base.
without base
with base
Try your own names as well and find your value with base
Code formatting is easy now with the help of mix task mix format
. It will take care of all you care about cleaning and refactoring as well. It can assure a clean code base or simply universal code base which maintains some useful standards. This really saves a lot of time.
To know more about the codebase formatting, check out my recent article on
[Code Formatter The Big Feature in Elixir
1.6](https://medium.com/blackode/code-formatter-the-big-feature-in-elixir-v1-6-0-f6572061a4ba)
which explains all about using mix format
task and its configuration in detail with screen shots of vivid examples.
I know, you might be thinking why some one would do that. I too had the same feeling until I met with a requirement in one of my previous projects where I was asked to replace address1
with address
and some other keys as well. It is a huge one. I have to do change many keys as well.
I’m here with a simple map
to keep it understandable. But, the technique is same.
The thing to remember is; be smart and stay long;
The above map comprises of two weird keys address1 and mobile1 where we do workout on to take over them.
What’s the magic here❓
Nothing , just pattern_matching, the boon for functional programmers. The magic lies inside Map.new and the anonymous function where we used our magic band to see the actual logic.
As we know, Enum.filter
will do the job based on the evaluation of a condition. But still, we can use the pattern to filter things.
Let me make you clear with the following example.
I have a list of users where their names are mapped to their preferred programming language.
Like above, the user_names are mapped with their languages. Now, our job is to filter the users of elixir language.
Just let me know which one you do prefer after checking out the following…
OR, using match? for pattern based
Checkout the screenshots of evaluation
I took the simpler lines of code to give a demo of using match? but, it’s usages are limit less. Just think about the pattern and match over it. Think out of the box guys. But don’t blow up your mind and don’t blame me for that.
Warning: ⚠️
Make sure of your pattern as the first parameter to the match? otherwise, you have to pay for the compiler. Just kidding 😃
As we know elixir is free language, where you can build anything you need. But, be careful It is just to show you something is achievable.
It is a LEFT and RIGHT Pipe
We usually end up with some sort of results in the format {:ok, result} . This can be found anywhere in your project sooner or later.
If you pipe it to the function obviously you will end up with an unknown expectation. I am talking about run-time errors. Our |> is not smart enough to check it for whether is a direct result or {:ok, result} .
Let’s build it for the GOD sake but not for your client.
⚠️ Don’t use this ever and don’t do write macros until you write new framework.
This Bangpipe I mean <|> is defined to do the task. Before sending the result to the function in right, it is performing the pattern matching over the result to identify what kinda result it is. I hope you understood what actually the result I am talking about. The Secret behind Elixir Operator Re-Definitions : + to - *Just for Fun*
We can also do re definitions on elixir operators. Check above URL.
How to use ❓
Just import Bangpipe the left-right pipe will be loaded. Copy and paste to experience it in live and fast into iex
“Good programmers write the code & great programmers steal the code” This tip is copied from the Elixir Lightening Talk
*Bangpipe <|> execution*
Let’s create a brief story here.
The moment when GOD’S against you, your manager will come and give you a vast legacy project code and asked you to find out all the places where a particular function is called. In a sentence, the callers of a particular function.
What will you do? I don’t think it is a smart way of surfing in each and every file. I don’t. So, you don’t.
Prints all callers of the given CALLEE, which can be one of: Module, Module.function, or Module.function/arity.
mix xref callers Poison.decode
You can add function arity to be more specific, in this case mix xref callers Poison.decode/1 .
BOOM ! Now, you can surprise the manager with results before he reaches his cabin. Be fast and smart.
I solely experienced this when my co-worker I better say co-programmer asked for help regarding the situation but there's no manager in my case.
Explore more about xref
I have a collection of hotel_bookings and I need to group them based on their booking status.
To keep this simple, I am just using some false random collection.
Let’s group the things.
This is well and good but I need only name in the list instead of map. I mean some thing like %{fail: ["Hari", "Manoj"], ...}
We just need to tell the group_by what to return in return of grouping
We can limit the keys to print while we inspect structs using @derive
attribute.
Don’t believe, check it down
Let’s consider we have a requirement to modify a map and need to merge the modified map with some other map. API developers always face this situation like modifying the response according to the client.
Consider the following two maps user and location
Now, we have a requirement to modify the keys for location map from latitude
to lat
and longitude
to long
. After map modification, the modified map has to merge into user map.
Just to convey the idea, I am using a map with fewer number of key-value pairs.
Before, I was doing Enum.map/2
followed by Enum.into/2
followed by Map.merge/2
Don’t Do
We can simply achieve this using alone Enum.into/3
Do
You can also check online schedulers like
You can type in your terminal not iex print the number of processing units available using the command nproc
We can know queue length of a process using Process.info/2
Let’s check that
Above lines will send two messages to the current process. As we did not write any receive block here, they keep waiting inside mailbox queue.
Now we will check the messages queue length of the current process self
Now we handle one message using receive block and will check the queue length once again.
Did you see that, we have only one message in queue as we handled :hello
message.
Again, we handle the left over message :hi
and this time the length will be 0
Of course it will be as there are no more messages to handle.
https://asciinema.org/a/271142?source=post_page-----7155532befd7----------------------
We always try to execute the project module functions in iex
interactive shell to check its behavior.
Sometimes, our module names will be lengthy to type. Of course, we can type alias
in iex
but it vanishes every time you restart the iex
shell and you have to type the aliases once again.
Create .iex.exs
file in the project root directory and add all aliases to the file.
Whenever you start iex
shell, it looks for .iex.exs
file in the current working folder . So, it creates all the aliases in the .iex.exs
file.
If file isn’t exist in the current directory, then it looks in your home directory i.e ~/.iex.exs
.
Replace N
with any integer value then it prints timing information for the N slowest tests.
It automatically adds--trace
and--preload-modules
It is simply implementing Inspect protocol for our custom type.
We can re design the inspect output for any specific type by implementing the Inspect protocol and overriding inspect function.
It is highly useful for custom structs where we can define what we need to see whenever we inspect our struct.
It is trivial that we need a temporary directory to write certain files and to delete later based on our code logic.
In elixir, we can get the path based on the operating system the app is running using System.tmp_dir/0
which returns a writable temporary directory.
We can customize the path with different environment variables like in the following;
It returns the directory set to TMP environment variable if available
It returns the directory set to TMPDIR environment variable if available
If three environment variables are set, then it searches for directories in the following order
If none of them was found then it returns default directories based on the operating system like C:\TMP
on Windows or /tmp
on Unix
In case the default directories are not found then it returns PWD i.e present working directory as a last piece of cake.
Though you exported Environmental variables, it still gives default values if those exported directories are not available.
Check out our Medium Publication
If you wish to join our telegram channel, here it is
Contribute to Part-9
creating a new branch Part-9
and make a pull request with atleast 3 Unique tips.
Thanks goes to these wonderful people (emoji key):
This project follows the all-contributors specification. Contributions of any kind welcome!