Please enable JavaScript.

Coggle requires JavaScript to display documents.

elixir (basic (type (atom / :atom (boolean / true / :true (and / or / not,…

- - - - integer / 1
      - float / 1.0
    - - atoms are not garbage collected
      - boolean / true / :true
        
        and / or / not
        
        && / || / !
      - nil / :nil
      - :"Elixir.String"
    - - anonymous function
        
        (fn x, y -> x + y end).(1, 2)
      - def / defp
        
        def name(params...) do body... end
        
        capturing
        
        &(&1 + 1) / fn x -> x + 1 end
        
        &List.flatten(&1, &2) / fn(list, tail) -> List.flatten(list, tail) end
        
        default arguments
        
        def join(a, b \\ nil, sep \\ " ")
    - - %{:a => 1, 2 => :b} / %{a: 1, b: 2}
      - map.a / map[:a] / map[2]
      - %{map | 2 => "two"} / %{map | a: 3}
      - struct
        
        structs are extensions built on top of maps that provide compile-time checks and default values
        
        defmodule User do defstruct name: "John", age: 27 end
        
        %User{} / %User{name: "Meg"}
    - - [1,2,3] / [1 | [2 | [3 | []]]]
      - a list of printable ASCII numbers will be printed as a char list
      - char list / 'hello'
        
        a list of code points
      - keyword list
        
        [{:a, 1}, {:b, 2}]
        
        [a: 1, b: 2] / list[:a]
        
        if(false, [{:do, true}, {:else, false}])
        
        if(false, [ do: true, else: false])
        
        if false, do: true, else: false
    - - a bunch of bits
      - binary / <<1,2,3>>
        
        a binary is a bitstring where the number of bits is divisible by 8
        
        string / "string"
        
        a string is a UTF-8 encoded binary
  - - - alias Foo.Bar, as: Bar
      - alias the module so it can be called as Bar instead of Foo.Bar
    - - require the module in order to use its macros
    - - import List, only: [duplicate: 2]
      - import Integer, only: :functions
      - import functions from Foo so they can be called without the Foo. prefix
    - - Invokes the custom code defined in Foo as an extension point
  - - - ~r/foo|bar/i
      - "foo" =~ ~r/foo|bar/i
      - sigil_r(<<"foo|bar">>, 'i')
  - - - raise "oops"
      - defmodule MyError do defexception message: "default message" end
      - try do raise "oops" rescue e in RuntimeError -> e end
      - we avoid using try/rescue because we don’t use errors for control flow
    - - try do throw(1) catch x -> x end
      - throw value and catch later
      - interfacing with libraries that do not provide a proper API
    - - a process can also die by explicitly sending an exit signal
      - spawn_link fn -> exit(1) end
      - try do exit "exiting" catch :exit, _ -> "hhh" end
      - once an exit signal is received, the supervision strategy kicks in and the supervised process is restarted.
    - - try do raise "oops" after IO.puts "cleanup" end
    - - try do 1 rescue _ -> 2 else _ -> 3 end
- - - - fit into a supervision tree
      - can be used to keep state, execute code asynchronously and so on
      - have a standard set of interface functions and include functionality for tracing and error reporting
      - abstracts the common client-server interaction
    - - GenServer.call is sync, handle_call must send a response back
        
        {:reply, reply, new_state}
      - GenServer.cast is async, handle_cast won't send a response back
        
        {:noreply, new_state}
      - prefer to use call/2 instead of cast/2 as it also provides back-pressure - you block until you get a reply
      - handle_info
    - - links are bi-directional
      - a monitor is uni-directional
      - use links when you want linked crashes, and monitors when you just want to be informed of crashes, exits, and so on.
      - avoid creating new processes directly, instead we delegate this responsibility to supervisors