Elixir untuk Technical Leader — Bab 2 dari 10

Tipe Data & Pattern Matching

Setelah bab ini, kamu bisa baca 90% code Elixir. Serius.

Overview — 7 Hal yang Perlu Kamu Kenal

Elixir cuma punya sedikit tipe data. Ini keunggulan — lebih sedikit yang perlu diingat.

Mari kita bahas satu-satu dengan contoh dari LabaBersih.

1. Atom — Label yang Gak Pernah Berubah

Atom = label/tag konstan. Ditulis dengan titik dua di depan: :ok, :error, :dibuat.

# Atom di LabaBersih:
:ok           # operasi berhasil
:error        # operasi gagal
:asc          # sort ascending (FEFO: lot paling lama dulu)
true          # boolean true (ini juga atom!)
false         # boolean false (juga atom)
nil           # "gak ada nilai" (juga atom)

Kenapa gak pakai string aja? Karena atom lebih cepat untuk dibandingkan. Komputer tinggal cek "label sama atau beda?" — gak perlu baca karakter satu-satu kayak string.

2. Tuple — Paket Hasil (Ini yang Paling Sering Kamu Lihat)

Tuple = kumpulan nilai dengan ukuran tetap. Ditulis pakai kurung kurawal: {a, b}.

Pattern terpenting di SELURUH codebase LabaBersih:

# SETIAP function di LabaBersih return 1 dari 2:

{:ok, result}      # berhasil — result = data yang diminta
{:error, reason}   # gagal — reason = kenapa gagal

# Contoh nyata:
Orders.ship_order(order_id, email)
# → {:ok, %{order: order, journal: journal}}
# → {:error, :already_shipped}
# → {:error, {:insufficient_stock, "Forbest", 3, 5}}

Cara caller handle-nya:

case Orders.ship_order(order_id, email) do
  {:ok, result} ->
    # sukses! result berisi order + journal
    put_flash(socket, :info, "Pesanan berhasil dikirim")

  {:error, :already_shipped} ->
    # order sudah dikirim sebelumnya (idempotent, bukan error fatal)
    put_flash(socket, :info, "Pesanan sudah dikirim sebelumnya")

  {:error, reason} ->
    # error lainnya — tampilkan pesan ke user
    put_flash(socket, :error, "Gagal: #{inspect(reason)}")
end

3. Map — Data dengan Nama (Kayak JSON Object)

Map = key-value pairs. Kalau kamu kenal JSON, map = JSON object.

# Map biasa:
%{name: "Budi", phone: "081234", total: 200_000}

# Akses value:
order.customer_name    # → "Budi"
order.total_harga      # → 200000

# Map di LabaBersih biasanya = Ecto Struct (Bab 4)
# Contoh: %Order{}, %Product{}, %JournalEntry{}

Update map (ingat: immutable!)

# BUKAN mengubah order, tapi bikin SALINAN BARU:
updated = %{order | status: "dikirim"}

# order asli tetap "dikemas"
# updated = salinan dengan status "dikirim"

4. List — Kumpulan Data (Kayak Array)

# List items di order:
items = [
  %{sku: "FRB01", qty: 3, price: 45_000},
  %{sku: "RTN01", qty: 1, price: 60_000}
]

# Jumlah items:
length(items)  # → 2

# Loop setiap item:
Enum.each(items, fn item ->
  IO.puts(item.sku)
end)

# Transform setiap item (kayak .map() di JavaScript):
skus = Enum.map(items, fn item -> item.sku end)
# → ["FRB01", "RTN01"]

List Pattern yang sering muncul di LabaBersih:

# Cek list kosong atau isi:
[]         # list kosong
[_ | _]    # list yang ada isinya (minimal 1 elemen)

# Contoh nyata di code:
case items do
  [] -> {:error, "Order tanpa item"}
  [_ | _] -> # ada items, lanjut proses
end

5. String — Tulisan + Interpolasi

# String biasa:
name = "LabaBersih"

# String interpolation (masukkan variabel ke dalam string):
message = "Pesanan #{order.id} berhasil dikirim"
# → "Pesanan PS2603-00001 berhasil dikirim"

# Multi-line string:
description = """
Penjualan TikTok Bestari
Tanggal: 30 Mar 2026
Total: Rp 200.000
"""

Yang penting: #{...} di dalam string = interpolasi. Isinya di-evaluate dan jadi text.

6. Pattern Matching — SKILL TERPENTING

Ini yang bikin Elixir fundamentally berbeda dari bahasa lain. Di JavaScript, = artinya "assign" (masukkan nilai). Di Elixir, = artinya "match" (cocokkan pola).

Level 1: Destructuring (Bongkar data)

# Match tuple — bongkar isi tuple ke variabel:
{:ok, order} = Orders.ship_order(id, email)
# Sekarang variabel `order` berisi data order
# TAPI: kalau return {:error, _} → CRASH (karena :ok gak match :error)

# Match map — ambil field tertentu:
%{customer_name: name, total_harga: total} = order
# Sekarang `name` = "Budi", `total` = 200000

# Match list — ambil elemen pertama:
[first | rest] = [1, 2, 3]
# first = 1, rest = [2, 3]

Level 2: Multi-clause Functions (Ini yang bikin readable)

Ini kekuatan utama. Satu function bisa punya banyak versi, masing-masing handle case berbeda:

# Dari LabaBersih — advance_fulfillment_status:

def advance_fulfillment_status("unfulfilled"), do: {:ok, "picking"}
def advance_fulfillment_status("picking"),    do: {:ok, "packed"}
def advance_fulfillment_status("packed"),     do: {:ok, "shipped"}
def advance_fulfillment_status("shipped"),    do: {:ok, "in_transit"}
def advance_fulfillment_status("in_transit"), do: {:ok, "delivered"}
def advance_fulfillment_status(status),       do: {:error, "#{status} gak bisa maju"}

# Baca dari atas ke bawah — kayak baca SOP gudang:
# "unfulfilled" → boleh maju ke "picking"
# "picking" → boleh maju ke "packed"
# ... dst
# status lain → TOLAK

Level 3: Case + Pattern Matching

# ship_order internal — handle berbagai kondisi:

case order.status do
  "dikemas" ->
    # BOLEH ship — lanjut proses
    do_ship(order)

  "dikirim" ->
    # Sudah dikirim — idempotent, skip (bukan error)
    {:ok, :already_shipped}

  status when status in ["selesai", "dibatalkan"] ->
    # Status final — TOLAK
    {:error, {:invalid_status, status}}

  other ->
    # Status gak dikenal — TOLAK
    {:error, {:unknown_status, other}}
end

Level 4: Pattern Match di Function Parameters

# Function yang terima map dan langsung bongkar field-nya:

def process_item(%{sku: sku, quantity: qty, price: price}) do
  # sku, qty, price langsung tersedia sebagai variabel
  # Gak perlu: item.sku, item.quantity, item.price
  total = qty * price
end

# Kalau parameter gak punya field `sku` → ERROR saat compile
# Gak perlu cek manual "if item.sku != undefined"

7. Underscore (_) — "Saya Gak Peduli Nilai Ini"

# Underscore = wildcard, match apapun tapi BUANG nilainya

{:ok, _} = some_function()
# Saya cuma mau tau berhasil, gak peduli result-nya

{:error, _reason} = some_function()
# _reason = variabel yang sengaja gak dipakai
# Prefix _ = compiler gak warn "unused variable"

def handle_event("save", _params, socket) do
  # Saya tau event "save", gak butuh params-nya
end

8. Keyword List — Options / Named Arguments

# Keyword list = list of {atom, value} tuples
# Sering dipakai sebagai "options" di function call:

list_orders(org_id, status: "dikirim", page: 1, per_page: 20)

# Ini sama dengan:
list_orders(org_id, [{:status, "dikirim"}, {:page, 1}, {:per_page, 20}])

# Versi pendek lebih enak dibaca
# Kamu akan sering lihat pattern ini di LabaBersih

9. Sigils — Shortcut untuk Data Spesial

# ~w = word list (bikin list dari kata-kata):
@statuses ~w(dibuat diproses selesai dibatalkan)
# Sama dengan: ["dibuat", "diproses", "selesai", "dibatalkan"]

# Di LabaBersih, ini dipakai untuk define valid statuses:
@order_statuses ~w(dibuat diproses selesai dibatalkan)
@fulfillment_statuses ~w(unfulfilled picking packed shipped in_transit delivered rts_detected hold_requested retrying returned)

# Guna: validate input. Kalau status diluar list → TOLAK

Baca Code Asli LabaBersih

Sekarang coba baca code asli dari orders.ex. Kamu harusnya bisa paham 80%+ setelah bab ini:

def ship_order(order_id, actor_email) do
  order = get_order!(order_id)

  case order.status do
    "dikirim" ->
      {:ok, :already_shipped}

    "dikemas" ->
      do_ship_order(order, actor_email)

    status ->
      {:error, {:invalid_status, status}}
  end
end

Cara bacanya (atas ke bawah):

1. def ship_order(order_id, actor_email) — function bernama ship_order, terima 2 parameter
2. order = get_order!(order_id) — ambil order dari database (tanda ! = crash kalau gak ketemu)
3. case order.status do — cek status order
4. "dikirim" -> — kalau sudah dikirim: return {:ok, :already_shipped} (idempotent)
5. "dikemas" -> — kalau dikemas: lanjut proses ship (do_ship_order)
6. status -> — status lain apapun: return error

Cheat Sheet — Simbol yang Sering Muncul

Checklist Review — Pertanyaan Bab 2

Ringkasan Bab 2