elixir-development

Files (1)

• SKILL.md

SKILL.md (first lines)

# Elixir Development

Production patterns for Elixir/OTP programming, covering Mix projects, GenServer, Supervisors,
pattern matching, testing with ExUnit, and Phoenix basics.

## When to Use This Skill

- Starting or structuring an Elixir project
- Building concurrent systems with OTP
- Implementing GenServers and Supervisors
- Writing pattern-matching-driven code
- Testing with ExUnit
- Working with Phoenix web framework
- Querying databases with Ecto

## Core Concepts

### 1. Project Layout (Mix)

```
myapp/
├── lib/
│   ├── myapp/
│   │   ├── application.ex     # OTP Application (supervisor tree root)
│   │   ├── accounts/
│   │   │   ├── user.ex        # Ecto schema
│   │   │   └── accounts.ex    # Context module (business logic)
│   │   ├── workers/
│   │   │   └── email_worker.ex
│   │   └── repo.ex            # Ecto Repo
│   └── myapp.ex               # Public API
├── test/
│   ├── myapp/
│   │   └── accounts_test.exs
│   ├── support/
│   │   └── fixtures.ex
│   └── test_helper.exs
├── config/
│   ├── config.exs
│   ├── dev.exs
│   ├── test.exs
│   └── runtime.exs
├── mix.exs
├── mix.lock
└── README.md
```

### 2. Key Principles

| Principle        | Elixir Idiom                                       |
|------------------|----------------------------------------------------|
| Immutability     | All data is immutable; transform, don't mutate     |
| Pattern matching | Destructure and branch in function heads           |
| Pipe operator    | Chain transformations with `                       |>`                      |
| Let it crash     | Supervisors restart failed processes automatically |
| Processes        | Lightweight, isolated; communicate via messages    |

## Quick Start

```bash
# Create a new project
mix new myapp --sup   # --sup includes Application supervisor

# Create a Phoenix project
mix phx.new myapp

# Get dependencies
mix deps.get

# Run tests
mix test
mix test --cover

# Interactive shell
iex -S mix

# Format code
mix format
```

## Patterns

### Pattern 1: Pattern Matching and Guards

```elixir
defmodule MyApp.Parser do
  # Multi-clause functions — pattern match in function heads
  def parse(%{"type" => "user", "data" => data}), do: parse_user(data)
  def parse(%{"type" => "order", "data" => data}), do: parse_order(data)
  def parse(%{"type" => type}), do: {:error, "Unknown type: #{type}"}
  def parse(_), do: {:error, "Invalid payload"}

  # Guards for additional constraints
  def process_age(age) when is_integer(age) and age >= 0 and age <= 150 do
    cond do
      age < 18 -> :minor
      age < 65 -> :adult
      true -> :senior
    end
  end

  def process_age(_), do: {:error, :invalid_age}

  # Pin operator to match against existing values
  def find_by_name(users, target_name) do
    Enum.find(users, fn %{name: ^target_name} -> true; _ -> false end)
  end

  # With clause for complex matching pipelines
  def create_user(params) do
    with {:ok, name} <- validate_name(params["name"]),
         {:ok, email} <- validate_email(params["email"]),
         {:ok, user} <- Repo.insert(%User{name: name, email: email}) do
      {:ok, user}
    else
      {:error, reason} -> {:error, reason}
    end
  end
end

From dallay/agents-skills, MIT.

More from dallay/agents-skills