Belajar Emacs - Emacs Lisp Dasar

#Pendahuluan

Hingga episode 8, kalian memakai Emacs sebagai pengguna. Episode 9 adalah gerbang menuju level berikutnya: membaca dan menulis Emacs Lisp (Elisp) — bahasa yang menggerakkan seluruh editor. Ini yang membedakan "pengguna Emacs" dari "penghuni Emacs".

Kenapa penting? Karena hampir semua kustomisasi yang akan kita bangun di 20 episode berikutnya — init file (episode 10), paket sendiri (episode 26), tuning performa (episode 27) — adalah Elisp. Tanpa membaca Elisp, kalian hanya akan menyalin config dari internet tanpa paham. Dengan dasar ini, kalian akan menulis config sendiri.

#S-Expression: Bahan Bangunan

Elisp adalah bahasa Lisp — kode ditulis sebagai s-expression (symbolic expression): list yang dibungkus kurung, dengan operator di depan:

(+ 1 2)          ; penjumlahan
(- 10 4)         ; pengurangan
(concat "hello" " " "emacs")  ; gabung string
(format "x = %d" 42)          ; format ala printf

Aturan baca: fungsi pertama, argumen berikutnya. (+ 1 2 3) = 1 + 2 + 3. Inilah "prefix notation" — semua operator adalah fungsi biasa.

#List, Atom, Quote

Struktur dasar Elisp:

• Atom: angka (42), string ("teks"), symbol (t, nil, setq).
• List: (a b c) — urutan elemen dalam kurung.
• Quote ' : mencegah evaluasi — '(a b c) berarti "list yang berisi symbol a b c", bukan "panggil fungsi a".

'(1 2 3)          ; list literal
(list 1 2 3)      ; sama, via fungsi list
(setq x '(1 2 3)) ; simpan list ke variabel x

t dan nil adalah kebenaran Lisp: t benar, nil salah (dan juga list kosong). Ini berbeda dari bahasa lain — nil punya dua peran.

#Buffer scratch: Playground Kalian

Buffer *scratch* (dibuka default di Emacs) adalah tempat mengevaluasi Elisp tanpa risiko. Mode-nya lisp-interaction-mode. Jalur cepat evaluasi:

C-x C-e   →  eval-last-sexp: evaluasi s-expression sebelum point

Ketik (+ 1 2) di *scratch*, letakkan point tepat setelah kurung tutup, tekan C-x C-e. Hasil 3 muncul di minibuffer.

#defun: Mendefinisikan Fungsi

defun mendefinisikan fungsi. Sintaksnya:

(defun nama-fungsi (argumen...)
  "Dokumentasi satu baris."
  (badan-fungsi...))

Fungsi kustom pertama:

(defun hello (nama)
  "Sapa seseorang."
  (message "Halo, %s!" nama))

Evaluasi dengan C-x C-e, lalu panggil:

(hello "developer")

message mencetak ke minibuffer dan buffer *Messages*. Fungsi ini sudah bisa dipanggil dari M-x juga — ketik M-x hello RET dan Emacs meminta argumen nama di minibuffer.

#Nilai Kembalian

Fungsi Lisp mengembalikan nilai ekspresi terakhir:

(defun tambah-satu (n)
  "Kembalikan n + 1."
  (+ n 1))
 
(tambah-satu 41)   ; → 42

#defvar & setq: Variabel

• setq mengubah nilai variabel (boleh belum ada).
• defvar mendefinisikan variabel dengan dokumentasi — cara yang benar untuk variabel "pengaturan".

(setq my-name "alice")      ; set tanpa dokumentasi
(defvar my-greeting "Halo"
  "Sapaan default yang dipakai fungsi hello.")  ; set + docstring

defvar juga tidak menimpa nilai yang sudah ada — sifat penting untuk variabel paket (definisi ulang tidak menghapus nilai yang diset pengguna).

#Predicate & Conditionals

Elisp memakai if, when, unless, dan predicates (fungsi berakhiran ?):

(if (> 3 2)
    "tiga lebih besar"
  "dua lebih besar")
 
(when (string= "a" "a") "kondisi benar")
(unless nil "nil itu false")
 
(stringp "teks")   ; t — string?
(numberp 42)       ; t — angka?
(zerop 0)          ; t — nol?

when untuk satu kasus saja, if untuk dua cabang, unless kebalikan when. Ini cukup untuk 90% logika config Emacs.

#Lambda & Map

lambda membuat fungsi anonim; mapcar menerapkannya ke tiap elemen list:

(mapcar (lambda (x) (* x x)) '(1 2 3 4))
; → (1 4 9 16)

Kombinasi lambda + mapcar muncul terus di config modern — misalnya menambahkan hook ke banyak mode sekaligus di episode 26.

#Latihan: Fungsi yang Benar-Benar Dipakai

Gabungkan semua konsep — fungsi yang menyapa berdasarkan waktu:

(defun sapa-waktu (nama)
  "Sapa NAMA sesuai jam saat ini."
  (let* ((jam (string-to-number (format-time-string "%H")))
         (sapaan (cond
                  ((< jam 12) "Selamat pagi")
                  ((< jam 17) "Selamat siang")
                  (t "Selamat malam"))))
    (message "%s, %s!" sapaan nama)))
 
(sapa-waktu "budi")   ; evaluasi → sesuai jam sekarang

let* mengikat variabel lokal, cond adalah if berantai, format-time-string mengambil jam. Semua fungsi ini — string-to-number, cond, let* — bisa diselidiki dengan C-h f dari episode 8.

#Pitfall Elisp Dasar

• Lupa tanda kurung: Emacs membantu dengan electric-pair-mode (auto-close kurung). Aktifkan di *scratch*: M-x electric-pair-mode.
• setq pada variabel sistem: jangan setq variabel yang seharusnya diset dengan customize-set-variable — terutama yang ber-docstring "user option". Episode 10 memperkenalkan pola use-package yang menanganinya.
• (message ...) di tengah config yang sering dievaluasi: pesan akan membanjiri *Messages*. Pakai message hanya untuk debugging.
• Evaluasi dua kali: fungsi yang dipanggil saat load (misal di init file) berjalan setiap start. Fungsi yang hanya didefinisikan (defun) aman — evaluasi ulang hanya mendefinisikan ulang.

#Penutup

Pada episode 9 ini, kalian telah membaca dan menulis Elisp pertama.

Inti yang harus dibawa pulang:

• s-expression: fungsi di depan, argumen di belakang; ' untuk quote.
• defun mendefinisikan fungsi + docstring; defvar variabel + docstring; setq ubah nilai.
• C-x C-e mengevaluasi ekspresi di *scratch* — playground tercepat.
• when/if/cond, lambda, mapcar, let* — cukup untuk config sehari-hari.
• Semua nama fungsi bisa diselidiki dengan C-h f — tidak perlu menghafal.

Di episode 10 selanjutnya, kita membangun fondasi permanen: init config & use-package — struktur ~/.emacs.d/init.el, kenapa use-package menjadi standar sejak Emacs 29, pola custom-set-variables, dan membaca error lewat C-h e. Sampai jumpa di episode 10!