Elixir untuk Technical Leader — Bab 3 dari 10

Functions, Modules, Pipe

Cara kerja "mesin" di balik LabaBersih — dari departemen (module) sampai jalur produksi (pipe).

Overview — Apa yang Akan Kamu Pelajari

Kalau Bab 2 tentang data (bahan baku), bab ini tentang mesin yang mengolah data. Di Elixir, mesin itu terdiri dari:

Setelah bab ini, kamu bisa baca SEMUA function di codebase LabaBersih dan paham strukturnya.

1. Module — Departemen di Organisasi

Module = tempat function tinggal. Di LabaBersih, setiap module = 1 domain bisnis:

defmodule Lababersih.Orders do
  # Semua function terkait pesanan tinggal di sini:
  # - create_order
  # - ship_order
  # - list_orders
  # - delete_order
end

Cara manggil function dari module lain:

# Panggil function dari module lain pakai NamaModule.nama_function()
Lababersih.Accounting.create_journal_entry(attrs)
Lababersih.Inventory.consume_lots(product_id, qty)

# Setelah di-alias (shortcut), cukup:
Accounting.create_journal_entry(attrs)
Inventory.consume_lots(product_id, qty)

Struktur File = Struktur Module

Ada aturan 1:1 — setiap file = 1 module:

2. def vs defp — Pintu Depan vs Dapur

Ada 2 jenis function di Elixir:

defmodule Lababersih.Orders do

  # PUBLIC — bisa dipanggil dari LiveView, test, module lain
  def ship_order(order_id, actor_email) do
    order = get_order!(order_id)
    do_ship_order(order, actor_email)  # panggil function private
  end

  # PRIVATE — cuma bisa dipanggil dari dalam module ini
  defp do_ship_order(order, actor_email) do
    # 1. potong stok
    # 2. generate jurnal
    # 3. update status
    # 4. audit trail
  end

end

3. Naming Convention — Nama = Niat

Di LabaBersih, nama function HARUS menjelaskan apa yang dilakukan. Ini bukan sekedar convention — ini kontrak bisnis:

Tanda ! dan ? di Nama Function

# ! = bahaya (raise/crash kalau gagal)
get_order!(id)        # → %Order{} atau CRASH (Ecto.NoResultsError)

# ? = return boolean
String.contains?("hello", "ell")   # → true
Enum.empty?([])                    # → true
Enum.any?(items, &(&1.qty > 0))   # → true/false

4. Pipe Operator |> — Jalur Produksi

Ini fitur Elixir yang paling sering bikin orang jatuh cinta. Pipe = ambil hasil kiri, lempar jadi parameter pertama fungsi kanan.

Tanpa pipe (nested, susah dibaca):

# Baca dari DALAM ke LUAR — pusing:
Repo.preload(Repo.all(offset(limit(where(Order, [o], o.org_id == ^org_id), 20), page * 20)), :items)

Dengan pipe (linear, kayak baca koran):

# Baca dari ATAS ke BAWAH — jelas:
Order
|> where([o], o.org_id == ^org_id)
|> limit(20)
|> offset(page * 20)
|> Repo.all()
|> Repo.preload(:items)

Cara pipe bekerja secara teknis:

# x |> f(a, b)  adalah  f(x, a, b)
# Hasil kiri MASUK jadi parameter PERTAMA fungsi kanan

"  hello  "
|> String.trim()           # String.trim("  hello  ") → "hello"
|> String.upcase()         # String.upcase("hello") → "HELLO"
|> String.replace("L", "R") # String.replace("HELLO", "L", "R") → "HERRO"

Pipe di code LabaBersih yang nyata:

# Di Orders context — list orders dengan filter + pagination
def list_orders(org_id, opts \\ []) do
  Order
  |> where([o], o.org_id == ^org_id)
  |> maybe_filter_status(opts[:status])
  |> maybe_filter_platform(opts[:platform])
  |> order_by([o], [desc: o.inserted_at])
  |> limit(^per_page)
  |> offset(^offset)
  |> Repo.all()
  |> Repo.preload(:items)
end

5. Anonymous Functions — Function Tanpa Nama

Kadang kamu butuh function kecil yang cuma dipakai sekali — gak perlu nama. Ini disebut anonymous function atau lambda.

# Anonymous function — bentuk panjang:
Enum.map(items, fn item -> item.sku end)
# → ["FRB01", "RTN01", "ORG01"]

# Shorthand — pakai & dan &1:
Enum.map(items, &(&1.sku))
# → ["FRB01", "RTN01", "ORG01"]
# &1 = parameter pertama (item)

Cara bacanya:

Contoh nyata di LabaBersih:

# Ambil semua SKU dari order items:
skus = Enum.map(order.items, &(&1.sku))
# → ["FRB01", "RTN01"]

# Hitung total harga semua items:
total = Enum.reduce(order.items, 0, fn item, acc ->
  acc + item.qty * item.price
end)

# Filter cuma items yang qty > 0:
valid_items = Enum.filter(items, fn item -> item.qty > 0 end)

# Shorthand yang sama:
valid_items = Enum.filter(items, &(&1.qty > 0))

6. Enum — Swiss Army Knife untuk List

Enum adalah module bawaan Elixir yang berisi function untuk mengolah list. Ini yang paling sering muncul di codebase LabaBersih.

Top 8 Enum yang paling sering dipakai:

Contoh lengkap — mengolah data order items:

items = [
  %{sku: "FRB01", qty: 3, price: 45_000},
  %{sku: "RTN01", qty: 2, price: 60_000},
  %{sku: "SAM01", qty: 0, price: 30_000}
]

# Ambil semua SKU:
Enum.map(items, &(&1.sku))
# → ["FRB01", "RTN01", "SAM01"]

# Filter cuma yang qty > 0:
Enum.filter(items, &(&1.qty > 0))
# → [%{sku: "FRB01", ...}, %{sku: "RTN01", ...}]

# Hitung total value (qty × price per item, lalu sum):
items
|> Enum.filter(&(&1.qty > 0))
|> Enum.map(fn i -> i.qty * i.price end)
|> Enum.sum()
# → 255_000 (3×45000 + 2×60000)

# Cek ada item tanpa product_id (SKU unknown)?
Enum.any?(items, &(&1.product_id == nil))
# → true/false

7. Guards — "Syarat Tambahan" di Function

Guard = syarat ekstra setelah parameter, pakai keyword when:

# Function hanya jalan kalau qty positif:
def reserve_stock(product_id, qty) when qty > 0 do
  # proses reservasi...
end

# Function untuk qty = 0 atau negatif → error:
def reserve_stock(_product_id, qty) when qty <= 0 do
  {:error, :invalid_quantity}
end

Contoh lain di LabaBersih:

# Cek tipe data:
def format_money(amount) when is_number(amount) do
  # format angka jadi "Rp 200.000"
end

# Cek apakah list:
def bulk_create(items) when is_list(items) do
  # proses batch...
end

# Guard umum yang sering muncul:
# when is_binary(x)     — x adalah string
# when is_integer(x)    — x adalah angka bulat
# when is_list(x)       — x adalah list
# when is_nil(x)        — x adalah nil
# when x > 0            — x positif
# when x in [:a, :b]    — x salah satu dari list

8. Default Arguments \\

Backslash-backslash \\ = nilai default kalau parameter gak diisi:

# opts punya default [] (list kosong)
def list_orders(org_id, opts \\ []) do
  # opts bisa berisi: status, platform, page, per_page
end

# Bisa dipanggil tanpa opts:
list_orders("org-123")
# → opts = []

# Atau dengan opts:
list_orders("org-123", status: "dikirim", page: 2)
# → opts = [status: "dikirim", page: 2]

Pattern ini SANGAT sering di LabaBersih — hampir semua list_* function pakai opts \\ [] supaya filter opsional.

9. alias, import, use — Shortcut dan Setup

3 kata kunci ini sering muncul di awal module. Fungsinya:

alias — Shortcut nama module

# Tanpa alias (panjang):
Lababersih.Orders.Order
Lababersih.Accounting.Accounting

# Dengan alias (pendek):
alias Lababersih.Orders.Order
alias Lababersih.Accounting

# Sekarang cukup tulis:
Order        # = Lababersih.Orders.Order
Accounting   # = Lababersih.Accounting

import — Bawa function ke scope

# Tanpa import:
Ecto.Query.where(Order, ...)
Ecto.Query.limit(query, 20)

# Dengan import:
import Ecto.Query

# Sekarang bisa langsung:
where(Order, ...)
limit(query, 20)

use — "Setup" dari module lain

# use = "pakai template/setup dari module ini"
defmodule Lababersih.Orders.Order do
  use Ecto.Schema      # setup untuk jadi database schema
  import Ecto.Changeset # bawa fungsi validasi

  # sekarang bisa pakai schema, field, cast, validate_required, dll
end

10. @moduledoc dan @doc — Dokumentasi Otomatis

Elixir punya sistem dokumentasi built-in. Tulis sekali → langsung jadi halaman docs:

defmodule Lababersih.Orders do
  @moduledoc """
  Context untuk manajemen pesanan.

  Semua operasi terkait order: create, ship, delete, list.
  Dependency: Inventory (stok), Accounting (jurnal), Sales (toko).
  """

  @doc """
  Kirim pesanan — atomic 5 step.

  1. Validasi status = dikemas
  2. Potong stok (FEFO lot consumption)
  3. Generate jurnal penjualan + HPP
  4. Update status → dikirim
  5. Audit trail

  Returns `{:ok, result}` atau `{:error, reason}`.
  """
  def ship_order(order_id, actor_email) do
    # ...
  end
end

11. @module_attribute — Konstanta Compile-Time

@nama di level module = konstanta yang di-set saat compile:

defmodule Lababersih.Orders.Order do
  # Konstanta — gak bisa berubah saat runtime
  @order_statuses ~w(dibuat diproses selesai dibatalkan)
  @fulfillment_statuses ~w(unfulfilled picking packed shipped in_transit
    delivered rts_detected hold_requested retrying returned)
  @payment_statuses ~w(unpaid settled refunded)

  # Dipakai untuk validasi:
  def changeset(order, attrs) do
    order
    |> cast(attrs, [:order_status, :fulfillment_status])
    |> validate_inclusion(:order_status, @order_statuses)
    |> validate_inclusion(:fulfillment_status, @fulfillment_statuses)
  end
end

Yang sering muncul di LabaBersih:

Baca Code Asli LabaBersih

Sekarang coba baca function nyata. Dengan semua yang kamu pelajari di bab ini, kamu harusnya bisa paham 90%:

defmodule Lababersih.Inventory do
  @moduledoc "Context untuk produk, stok, FEFO lots, warehouse."

  alias Lababersih.Repo
  alias Lababersih.Inventory.Product
  import Ecto.Query

  @doc "List produk per organisasi dengan filter opsional."
  def list_products(org_id, opts \\ []) do
    Product
    |> where([p], p.org_id == ^org_id)
    |> maybe_search(opts[:search])
    |> order_by([p], asc: p.name)
    |> Repo.all()
  end

  defp maybe_search(query, nil), do: query
  defp maybe_search(query, search) do
    search_term = "%#{search}%"
    where(query, [p], ilike(p.name, ^search_term) or ilike(p.sku, ^search_term))
  end
end

Cara bacanya baris per baris:

1. defmodule Lababersih.Inventory do — module "Departemen Gudang"
2. @moduledoc "..." — deskripsi module
3. alias + import — shortcut dan tools yang dibutuhkan
4. def list_products(org_id, opts \\ []) — function PUBLIC, terima org_id (wajib) dan opts (opsional)
5. Pipe: Product |> where... |> maybe_search... |> order_by... |> Repo.all() — assembly line query
6. defp maybe_search(query, nil) — PRIVATE function, kalau search = nil, kembalikan query apa adanya
7. defp maybe_search(query, search) — PRIVATE function, kalau search ada isinya, tambahkan filter ILIKE

Cheat Sheet Enum

Checklist Review — Pertanyaan Bab 3

Red Flags — Yang Harus Kamu Tanyakan

Ringkasan Bab 3