Elixir Programming Language

When implementing a GenServer, select the appropriate callback based on the nature of the request:

For a quick reference, you can use the GenServer cheat sheet.

Structs in Elixir are implemented as compile-time maps. Maps with up to 32 keys are represented internally as 'flat maps' (two tuples: one for keys, one for values). This representation is highly optimized because:

1. Updating a flat map allows the key tuple to be shared, reducing memory usage.
2. Multiple instances of the same struct in a module can share the same key tuple at compile-time.

Once a struct reaches 32 or more fields, the Erlang VM switches to a 'hash map' representation, which is more complex and does not benefit from these key-sharing optimizations. To keep structs under the 32-field limit, consider:

• Nesting optional fields into a single :metadata or :options field.
• Nesting related structs within other fields.
• Grouping frequently co-accessed fields into a tuple.

When using multi-clause functions, extracting many variables in the function signature for both pattern matching/guards AND for use in the function body can become confusing. It becomes hard to distinguish which variables are required for the clause logic and which are just being passed through.

Refactoring Strategy: Extract only the variables required for pattern matching or guards in the signature. Use the assignment operator (=) to extract the rest of the data (like the whole struct) and then perform specific extractions inside the function body.

def drive(%User{age: age} = user) when age >= 18 do
  %User{name: name} = user
  "#{name} can drive"
end

def drive(%User{age: age} = user) when age < 18 do
  %User{name: name} = user
  "#{name} cannot drive"
end

Module attributes provide module-specific storage. They are written using the @ operator.

• Writing: @foo "value"
• Reading: @foo

@version "1.0.0"
@version

Aliases (e.g., Foo.Bar.Baz) are represented as an __aliases__ call. Each segment of the alias is passed as an argument, and all arguments (except potentially the first) are guaranteed to be atoms.

quote do
  Foo.Bar.Baz
end
#=> {:__aliases__, [], [:Foo, :Bar, :Baz]}

Elixir uses best-effort type inference to deduce types at compile time without requiring manual annotations.

Inference Scope:

• Elixir aims to infer types across dependencies (Standard Library and your project's dependencies).
• Calls to modules within the same project are assumed to be dynamic().
• Once types are inferred, the entire project is type-checked.

Trade-offs of Inference:

• Speed: Inference is more computationally intensive than simple type checking.
• Expressiveness: Inferred types are a subset of what can be explicitly type-checked.
• Incremental Compilation: Changes in a dependency can trigger a chain of re-computations.
• Cascading Errors: Conflicting assumptions can lead to complex error messages.

Note: Type inference is not a guarantee of correctness; it is designed to find bugs where all possible type combinations would fail.

When deciding between an Agent and a GenServer for state management:

• Agents: A simplified subset of GenServers. They are useful for storing small amounts of state in a straightforward manner.
• GenServers: The fundamental building block for concurrent, fault-tolerant systems in Elixir. They provide a robust framework for managing state and coordinating complex interactions between processes.

Rule of thumb: Many developers skip Agents entirely and use GenServers directly to avoid the limitations of the Agent abstraction, though Agents remain perfectly valid for simple state storage.

Elixir provides two primary entry points for configuration, depending on when the values are needed:

1. config/config.exs (Compile-time): Read during the build process, before dependencies are loaded or modules are compiled. Use this to control how dependencies are compiled. Access these values using Application.compile_env/2.
2. config/runtime.exs (Runtime): Read after the application and dependencies are compiled. Use this for values that change based on the deployment environment, such as reading system environment variables via System.get_env/1. Access these values using Application.fetch_env!/2.

In Elixir, you can define a function with multiple clauses to handle different input patterns elegantly. A common pattern is to define a 'function head' (a clause without a body) to document the expected arguments or define default arguments, followed by specific implementation clauses that match specific data shapes.

This is an effective way to implement command dispatchers or pattern-matching logic without using if/else or case blocks.

# Function head to document arguments
def run(command, socket)

# Specific implementation clauses
def run({:create, bucket}, socket) do
  KV.create_bucket(bucket)
  :gen_tcp.send(socket, "OK\r\n")
  :ok
end

def run({:get, bucket, key}, socket) do
  # ... implementation
end