Elixir Cheatsheet

install Elixir

sudo dnf install elixir erlang erlang-doc

new elixir project

mix new myproj

generate binary

mix release

add dependencies

vi mix.exs

def deps do
[
{:toml, "~> 0.6"}]end

>> mix deps.get

compile a binary

>> MIX_ENV=prod mix release

Strings

concactenate string

iex> "hello " <> "there"
"hello there"

interpolation

iex> string = "world"
iex> "hello #{string}"
"hello world"

split string into List

String.split("welcome to the terror dome")["welcome", "to", "the", "terror", "dome"]

split string into tuple with by position

String.split_at("welcome to the terror dome", 4){"welc", "ome to the terror dome"}

String via sigil

IO.puts ~s(This is a string)IO.puts ~s(This is also a "string")

Variables

bind a variable to a number

x = 1
>> 1
x = 2
>> 2^x = 2>> 2
^x = 1
>> Match Error (tries to match original X value to 1, not rebind it to 1)

Anonymous var - for unneeded vars

calendar.local_time returns tuple {date, time}, dont need date

{_, time} = :calendar.local_time

Comparisons

value comparison

== != <= => < > && ||

strict comparison (check if variable type is same)

1 === 1.0false

Lists (Array)

Lists are immutable, any addition or modification of List results in a new mem allocation and new list (mem safe)

get length

length([ 1, 2, 3])
>> 3

concat 2 lists

[1,2,3] ++ [4,5,6]
>> [1,2,3,4,5,6][1,true,2,false,3,true] -- [true, false]
>> [1,2,3,true]

get head or tail of a list

list = [1,2,3]
hd(list)
>> 1
tl(list)
>> [2,3]

get information about a List

iex(1)> list = ["apple", 2, 3.5]

["apple", 2, 3.5]

iex(2)> i list

Term

["apple", 2, 3.5]

Data type

List

Reference modules

List

Implemented protocols

Collectable, Enumerable, IEx.Info, Inspect, List.Chars, String.Chars

get element from list

numbers = [2,3,4,5]
Enum.at(numbers, 2)
>> 4

check if variable is in list

4 in numbers
>> true

replace value

List.replace_at(numbers, 0, 9)
>> [9,3,4,5]

insert value

List.insert_at(numbers, 0, 7)
>> [7,9,3,4,5]

Tuples

Tuples like lists are immutable, creates new tuples in memory on any modification. Good for small fixed number of elements

Tuples are good for storing data and reading (read time is faster than list, writing/modifiying is slower)

tuple = { "Mary", 2, 5.0, false }
tuple_size(tuple)
>> 4

modify Tuple (stores in a new variable)

tuple = { "Mary", "Bob" }
put_elem(tuple, 1, "Frank)
>> { "Mary", "Frank"}
tuple
>> {"Mary", "Bob"}

get tuple value

IO.puts elem(tuple,1)
>> Bob

Maps (hashes)

map = %{:name => "Bob", :age => 23, :dept => "IT"}
or
map = %{name: "Bob", age: 25, dept: "IT"}IO.puts map[:name] >> bob
IO.puts map.name >> bob

update map (creates new map)

new_map = %{map | age: 26, dept: "Billing"}

Case

case {1,2,3} do
{4,5,6} -> "This wont match"
{1,x,3} -> "will bind x to 2"
_ -> "will match any value"
end

Conditionals

Functions

public and private funcs

defmodule TestPrivate do def double(a) ## public
do
sum(a, a)
end

defp sum(a, b) ## private via defp
do
a + b
end
end

import function

import IO
puts "hello"

instead of

IO.puts "hello"

alias a function

alias IO, as: myIO
myIO.puts("hello")

document module help, create a constant variable at runtime

defmodule Circle do

@moduledoc "does basic circle functions"

@pi 3.14

@doc "computes area of circle"
def area(radius)
do
radius * radius * @pi
end

@doc "computes circumference of circle"
def circumference(radius)
do
2 * radius * @pi
end
end

get doc for a function from iex

iex> h Circle

add Type to function, only accepts number as input and output should only be a number

@doc "computes area of circle"

@spec area(number) :: number
def area(radius)
do
radius * radius * @pi
end

default argument value

def func(a, b \\ 1, c, d \\ 2)
do
a + b + c + d # will provide b=1, d=2 if no vals passed
end

lambda functions

print_var = fn x -> IO.puts(x) end

Enum.each( [1,2,3], print_var)

Compiler

compile a binary

elixirc test.ex

xxxx

Atoms (Symbols)

named constants (value of an atom is its own name)

:my_atom
IO.puts :myatom
>> myatom

Atoms are efficiently compared for equality because they are internally represented by integers

It's important to note that atoms are not garbage collected and there's a limit to how many can be created (default is 1,048,576). Therefore, you should avoid creating atoms dynamically based on user input or arbitrary data.

Atoms in Elixir serve as lightweight, immutable values that are excellent for representing fixed concepts or states within your application. They provide a way to name things without the overhead of strings, making them ideal for many internal operations in Elixir programs.

Page updated

Google Sites

Report abuse