Elixir basics
Download as ODP, PDF0 likes467 views
This document provides an overview of the Elixir programming language. It discusses Elixir's functional, concurrent, and fault-tolerant features. It also summarizes basic Elixir tools like IEx and Mix, concepts like pattern matching and immutability, and language constructs including types, operators, functions, lists, maps, strings, and control flow. The document aims to introduce fundamental Elixir basics.
![Elixir – Pattern Matching
● It’s a core part of elixir. The operator is =
iex> a = 3
3
iex> 3 = a
3
iex> 4 = a
** (MatchError) no match of right hand side value: 3
– Tuples and lists
{a,b,c} = {"1", "5", "6"}
[head|tail] = [1,2,3,4]
– Pin operator ^
● Match the value of the variable.
● It’s used in functions too.](https://image.slidesharecdn.com/elixir-basics-170210004736/85/Elixir-basics-6-320.jpg)
![Elixir – Basics 1
● Value Types
– Integer, Float, Atoms, Ranges, Regular Expresions
● System Types
– PIDs
● Collection Types
– Tuples {:name, "Ruben", :age, 36}
– Lists [1,2,3,4]
– Maps %{ "data" => 123 }
– Binaries <<91,93>>](https://image.slidesharecdn.com/elixir-basics-170210004736/85/Elixir-basics-8-320.jpg)
![Elixir – List and Recursion
● How to define a List
[], [1,2,3]
● Patter matching
[a,b,c] = [1,2,3]
● Sample
– Sum numbers of a list
● Tail Recursion
– Sum numbers of a list](https://image.slidesharecdn.com/elixir-basics-170210004736/85/Elixir-basics-15-320.jpg)
![Elixir – Maps, Keyword Lists, and
Structs
● What is:
– Keyword list (list of tuples – key needs to be an atom)
[name: "Ruben", age: 36]
kw = [{:name, "Ruben"},{ :age, 36}]
● Kw[:name]
– Map
● map = %{ "name" => "Ruben" }
● map["name"]
– Structs (Define map structure)
defmodule User do
defstruct [ name: "unknown"]
end
● %User{ username => "test" }
● %User{}](https://image.slidesharecdn.com/elixir-basics-170210004736/85/Elixir-basics-16-320.jpg)
![Elixir – Processing Collections
● Enum
– Module to process collections
– Iex>h Enum
● Comprehensions (a way to iterate over an
Enumerable)
– for var <- Enum, do: code
– for x <- [1,2,3], do: IO.puts(x)](https://image.slidesharecdn.com/elixir-basics-170210004736/85/Elixir-basics-17-320.jpg)
Elixir basics
- 2. Agenda ● About Elixir ● Tools ( iex and mix) ● Concepts (Pattern Matching, Immutability) ● Basics ( types, operators, functions, lists and recursion, maps, collections, strings, control flow)
- 3. About Elixir ● Functional, concurrent, general purpose programming language. ● Build on top of Erlang ● Runs over Erlangs virtual Machine (BEAM)
- 4. About Elixir - Features ● Scalabiliy – Creates light weight processes (code runs inside processes) ● Fault tolerance – Supervisors (detects when a process dies and creates a new one) ● Build on top of Erlang – Supports erlang calls ● Runs over Erlang’s virtual Machine (BEAM) – Can use erlang libraries: e.g. :math
- 5. Basic Tools ● iex (Interactive elixir shell) – Commands: pwd() ls(), c, h, i ● mix (helper to build, run, compile, manage dependencies). – mix new project: To create a the default structure – iex -s mix: To compile and load your project – mix get.deps: To get dependencies – mix hex: .... To publish your code – mix test: To run the test suite
- 6. Elixir – Pattern Matching ● It’s a core part of elixir. The operator is = iex> a = 3 3 iex> 3 = a 3 iex> 4 = a ** (MatchError) no match of right hand side value: 3 – Tuples and lists {a,b,c} = {"1", "5", "6"} [head|tail] = [1,2,3,4] – Pin operator ^ ● Match the value of the variable. ● It’s used in functions too.
- 7. Elixir – Immutability ● Immutable data is known data ● Sample a = 10 something(a) print a ● Benefits: – You don’t need to worry that any code might mutate your data.
- 8. Elixir – Basics 1 ● Value Types – Integer, Float, Atoms, Ranges, Regular Expresions ● System Types – PIDs ● Collection Types – Tuples {:name, "Ruben", :age, 36} – Lists [1,2,3,4] – Maps %{ "data" => 123 } – Binaries <<91,93>>
- 9. Elixir – Basics 2 ● Operators – Comparison ● ===, !==, ==, !=, >, >=, <, <= – Booelan ● or , and, not (Receive only booleans) true || false ● ||, &&, ! ( Any value != false or nill is true) – Arithmetic ● +, -, *, /, div, rem – Join ● binary <> binary ● list1 ++ list2, list1 -- list2 – In ● a in enum (check if a exists on enum array)
- 10. Elixir – Basics 3 ● Pipe operator |> – It’s used to pass the result of an expression as the first parameter of another expression e.g: Count the number of words in a String iex> Enum.count(String.split("This is a String")) iex> "This is a String" |> String.split |> Enum.count – On a file "This is a String" |> String.split |>Enum.count
- 11. Elixir – Anonymous Functions ● What is anonymous funciton Are basic types and are created using the fn keyword: ● fn parameter-list -> body parameter-list -> body end ● How to define sum = fn(x,y) -> x + y end ● How to use sum.(1,3) # => 4
- 12. Elixir – Anonymous Functions File: exist.txt ---------- Hello world handle_open = fn {:ok, file} -> "Read data: #{IO.read(file, :line)}" {:error, error} -> "Error: #{:file.format_error(error)}" end handle_open.(File.open("exists.ex")) "Read data: "hello world"n" iex> handle_open.(File.open("not_exists.ex")) "Error: no such file or directory"
- 13. Elixir – Modules and Named Functions ● Organize code defmodule Name do def print_name(name) do IO.puts "Hello #{name}" end end ● Iex(1)> Name.print_name("Ruben") hello Ruben :ok
- 14. Elixir – Modules and Named Functions ● guards defmodule Name do def greeting(name,age) when age < 2 do IO.puts "Gaga #{name}" end def greeting(name,age) when age <5 do IO.puts "Hi #{name}" end def greeting(name,age) do IO.puts "Hello #{name}" end end ● Iex(1)> Name.print_name("Ruben",1) Gaga Ruben :ok
- 15. Elixir – List and Recursion ● How to define a List [], [1,2,3] ● Patter matching [a,b,c] = [1,2,3] ● Sample – Sum numbers of a list ● Tail Recursion – Sum numbers of a list
- 16. Elixir – Maps, Keyword Lists, and Structs ● What is: – Keyword list (list of tuples – key needs to be an atom) [name: "Ruben", age: 36] kw = [{:name, "Ruben"},{ :age, 36}] ● Kw[:name] – Map ● map = %{ "name" => "Ruben" } ● map["name"] – Structs (Define map structure) defmodule User do defstruct [ name: "unknown"] end ● %User{ username => "test" } ● %User{}
- 17. Elixir – Processing Collections ● Enum – Module to process collections – Iex>h Enum ● Comprehensions (a way to iterate over an Enumerable) – for var <- Enum, do: code – for x <- [1,2,3], do: IO.puts(x)
- 18. Elixir – Strings ● "String" – A String in Elixir is a UTF-8 encoded binary. – Use String module to manipulate strings. iex> String.capitalize("ruben") – It’s represented as binary list iex> i "Ruben" – Contatenation with <> iex> i ( "Ruben" <> " Dario" )
- 19. Elixir – Control Flow ● If (cond) do body end ● If (cond) do body1 else body2 end ● Case x = 10 case x do 0 -> "This clause won't match" _ -> "This clause would match any value (x = #{x})" end #=> "This clause would match any value (x = 10)" ● Cond cond do 1 + 1 == 1 -> "This will never match" 2 * 2 != 4 -> "Nor this" true -> "This will" end #=> "This will"
- 20. References ● NY: Manning Publications. ● Thomas, D. (2016). Programming Elixir 1.3: functional, concurrent, pragmatic, fun. Releigh, NC: Pragmatic Bookshelf.