logo

Basic Elixir and Phoenix Concepts

Elixir

hd head

hd(array-name) #returns the first element or head

_

_whatever #tells Elixir that `whatever` can be null
tuple {}
map %{}

Pipe Operator

|>

passes output of earlier function into the next function due to the functional or flowing nature of Elixir. This requires the functional programmer to have more intelligence than an object-oriented programmer as to remember the long chain of cause and effect

puts the result in the last series

Pattern Matching Rules

= is a ‘match operator’ not an equals sign. This requires more intelligence from the programmer as to decide whether two sides match or not, instead of being equal to just one side like in object-oriented or procedural programming.

x = 'a'
'b' = x # error because left must be a letter/s or number such as 1 + 1 = 2
b = b # error because right side needs non-variable

Integer Separator

1123_456_789 --> 123456789

Booleans

Strict:

and
or
not

Non-strict:

&& 
|| 
!

Comparison

>
<
>=
<=

Non-Strict Comparison

!=
==

Strict Comparison

!==
===

String literals

\ escape character indicates a special string with certain abilities

"Donald\nTrump"

#{} interpolation inserts expression within the string

"Donald Trump #{'J' == 'r' == '.'}"

Atom literal

used as labels or tags

:text
:"<>" 
true  

Maps

Structs: Specialized Maps

Defining

defmodule ModuleName do
  defstruct [:key1, :key2]
end

Calling

%ModuleName{key1: value, key2: value}

module = %ModuleName{key1: value, key2: value}
module.key1

data type must match! (atoms vs strings)

Recursion

Iteration

Conditional Macros for the Lazy

-> if-then

case condition do
    true -> a
    false -> b
end 
case mega_function(input) do
    {:error, error_message} -> {:error, error_message}
    {:ok, mega_function_output} -> case mini_function(input) do  
        {:error, error_message} -> {:error, error_message}
        {:ok, input} -> %{key: mini_function_output}
    end          
end 

with <- if-then, if-then, if-then

case mega_function(input) do
    with {:ok, mini_function_output} <- mini_function(input)} do
        {:ok, %{key: mini_function_output} 
        # mega_function_ouput has mini_function_output inside of it
    end          
end 

Guard Clauses

Filters functions

def function_name(input) when condition1 do
end

def function_name(input) when condition2 do
end

Functions

enclosed in Modules

def function_name(argument_name) do

def function_name(argument_name\\ "default-value-if-no-argument-name-is-given") do

Anonymous Functions

Setting

function_name = fn(argument1, argument2, argument3..) -> argument1 + argument2 + argument3.. end

eg:

square = fn(x) -> x * x end
function_name = fn(a,b,c,d) -> (a,b,c,d)
function_name = &(&1 + &2 + &3 + &4)
function_name = &(ModuleName.another_function/4)

Calling

function_name.(4) #anonymous function
function_name(4) #named function

Capture Operator: Shortcut for those lazy to write code

&1 is the shortcut for the arguments in fn(x..) -> x..

&1 #represents or captures the first argument 
&2 #represents or captures the second argument

eg:

function_name = &(&1 * &2)
&(Module.function_name/1) #shortcut for the whole Module
var_too_lazy_to_type_module = &(LongNamedModule.long_named_function/100)

Erlang Functions

:timer
IO.puts "whatever"

Module

container for the functions

defmodule ModuleName1 do
  def function_name(argument1, argument2,..) do 
    ModuleName2.function_name()

Alias and Import: References to modules

alias Module # just identifies which Module to look into eventually

import Module # actually gets all the functions of Module

@constant = value # assigns a value as a constant at compile-time 

Plug: Manipulates data in conn structs

It’s a Module that has a ‘Conn’ Struct. It takes and returns that conn struct between modules.

It allows state management when combined with Agents and Genservers (like Live View). The state is held by the struct and then is passed between Modules. The ability to pass data turns Plugs into Elixir webservers

It has two types:

Assigns

assign(key: "#{data.attrib}")

Function Plug

This is a simple function that receives a conn struct, manipulates it, and outputs the modified conn struct

Defining non_piped and piped Function Plugs

defmodule App.ModuleName do
  import Plug.Conn

  def non_pipe(conn, options) do 
    assign(conn, :non_pipe, 123)
  end

  def piped(conn, _options) do
    conn
    |> put_resp_content_type("text/plain") 
    |> send_resp(200, "From a Piped Function Plug that outputted this data inside this conn struct")
  end

end 

Calling in Elixir

plug :non_piped

Calling in Phoenix View

<%= @conn.assigns[:non_piped] %>
<%= @non_piped %>

Module Plug

This is a large function, as a Module, that needs to be initialized with additional data such as state (i.e. initial state). This makes it more complicated than a function plug

Defining

defmodule App.Modulename do
  import Plug.Conn

  def init(options) do
    options
  end

  def call(conn, _options) do 
  end

end

Calling in Elixir

alias ModulePlugName
plug ModulePlugName, [option: "Blah"] when action is [:index]

Calling

Controller 

alias Appname.Plugname

plug

function_name.(1,2,3,4)

Function Plug: Adds a Conn to a Module Function

Calling

defmodule App.TotalController do
  import App.ModuleName
  plug :get_total
  ..
end 

Map

Defining

map = %{:atom => "string", "string" => "string"}
mapshortcut = %{atom: "string", atom2: "string"}

Calling

map.atom
map["string"]
map[:atom]

Examples:

map = %{ph -> manila, us -> wash}

OTP Processes and State Management

This allows functions to hold data independent of the function which is really held through the Genserver. This makes the OTP a real app.

Processes

Tasks: Start-Stops a Function or Module on a Process

Task.start(function_name)

Agents: Adds Lightweight State management on a Process

Only gets and updates single states. This makes it faster.

Genservers: Adds Heavy Duty State management on a Process

Gets, manipulates, and updates states by allowing “messages”.

Ecto

Handles external data such as databases and JSON APIs

Repo: communicates with external data source or database

Has common methods:

Phoenix uses Repo through:

Common methods

Repo.count()
Repo.update_all("tablename", set: [updated_at: Ecto.DateTime.utc])

Schema

Reusable data-model for moving data around. Schemas are a useful shortcut used in querying so you don’t have to specify all the attributes

Schema Associations

sets relationships between tables

Virtual Attributes

Disposable attributes that are not saved to the database. For example, an office address that is used to get a latitude and longitude to store in the database, without storing the office address

Embedded Schema

A schema that doesn’t use a datbase

Changeset

Allows manipulation of the data to match Schema so that it can be passed to the Repo

Defining

def changeset(schemaname, attrs) do
  schemaname
  |> cast(attrs, [:key1, :key2,..])
  |> validate_required([:key1])
  |> validate_inclusion(:name, ["John", "Jack"])
  |> validate_exclusion(:name, ["Jub Jub"])
  |> validate_length(:country, is: 2)
  |> validate_length(:password, min: 8, max: 32)
end

Calling

attrib_name = get_field(changeset, :attrib_name)

Schemaless Changeset

Defining

model = %{key1: :string, key2: string} 
attributes = %{key1: "value", key2: "value"}    
changeset = {%{}, model}
  |> cast(attributes, Map.keys(model))
  |> validate_required([:key1])
end

Ecto Queries (see other article )

Phoenix

Phoenix Ecto

allows changeset shortcuts into forms



Icon Icon