Belajar Haskell - Konsep Dasar & Arsitektur Utama

#Pendahuluan

Setelah di episode 1 kita memahami mengapa Haskell ada — empat pilar desainnya dan penggunanya di industri — pada episode ini kita membedah bagaimana toolchain Haskell bekerja dari kode sumber hingga program berjalan. Memahami arsitektur ini penting karena hampir semua masalah yang kalian temui sepanjang series berakar di sini: kenapa kompilasi lambat, kenapa HLS butuh versi GHC yang sama, kenapa cabal berbeda dari stack, dan apa sebenarnya yang dieksekusi saat main berjalan.

#Dari Kode ke Binary: Perjalanan GHC

GHC (Glasgow Haskell Compiler) adalah kompiler Haskell yang paling banyak dipakai, dan menjadi wajah de facto bahasa ini. Alurnya secara garis besar:

100%

Tahapan yang perlu kalian pahami:

Parser membaca file .hs dan membangun sintaks tree. Error sintaks muncul di sini.
Type checker memeriksa tipe dengan algoritma Hindley-Milner — fase ini yang menangkap mayoritas bug kalian.
Core IR adalah bahasa inti GHC yang sangat kecil dan berperilaku baik; semua fitur Haskell diturunkan (desugar) ke sini.
STG (Spineless Tagless G-machine) menambahkan detail evaluasi lazy.
Code generator menghasilkan native code langsung, atau meneruskan ke backend LLVM untuk optimasi lebih agresif, atau ke target wasm32wasi untuk WASM.

Mengapa ada beberapa backend? Karena setiap target punya trade-off: native backend default cepat untuk build sehari-hari, backend LLVM menghasilkan kode yang kadang lebih optimal di workload numerik, dan target WASM membuka jalan menjalankan Haskell di browser atau edge runtime (dibahas di episode 18).

Kompilasi dengan optimasi

ghc -O2 -o hello Main.hs

Flag -O2 mengaktifkan optimasi penuh; untuk development, -O0 (default) membuat build lebih cepat.

#GHCi: REPL untuk Eksperimen Cepat

GHCi adalah REPL (Read-Eval-Print Loop) interaktif Haskell. Ini adalah best friend kalian untuk mencoba ekspresi tanpa build:

Sesi GHCi singkat

$ ghci
ghci> 2 + 3 * 4
14
ghci> let double x = x * 2
ghci> double 21
42
ghci> :t map
map :: (a -> b) -> [a] -> [b]
ghci> :q
Leaving GHCi.

let untuk mendefinisikan fungsi di sesi, :t untuk menanyakan tipe sebuah ekspresi, dan :q untuk keluar. Sepanjang series kita akan sering memakai GHCi sebagai lab — khususnya perintah :t, :i, dan :set +s yang dibahas di episode 10.

#Komponen Ekosistem

Komponen	Fungsi
`ghc`	Kompiler — mengubah `.hs` menjadi binary native/WASM
`ghci`	REPL interaktif untuk eksperimen dan debugging
`runghc` / `runhaskell`	Menjalankan file `.hs` langsung tanpa build step
`cabal`	Build tool & package manager (Hackage)
`stack`	Build tool dengan snapshot reproducible (Stackage)
`hls`	Haskell Language Server — IntelliSense untuk editor
`Prelude`	Standard library default yang selalu di-import

#Prelude: Perpustakaan yang Selalu Ada

Prelude adalah kumpulan fungsi dan tipe dasar yang otomatis tersedia di setiap modul — seperti +, map, filter, length, print, tipe Int, Bool, String, dan seterusnya. Kalian tidak perlu import apa pun untuk memakainya. Inilah sebabnya contoh di episode 0 (addOne, double) langsung berjalan tanpa import.

Prelude - tanpa import apa pun

main :: IO ()
main = print (map (*2) [1,2,3])

map (*2) [1,2,3] menghasilkan [2,4,6] dan print mencetaknya ke layar — semua dari Prelude.

#runghc vs Kompilasi Penuh

runghc menafsirkan file .hs secara langsung, cocok untuk script cepat dan contoh di series ini. Untuk produksi, kalian selalu mengkompilasi dengan ghc atau lewat cabal untuk mendapat binary yang dioptimasi dan terisolasi dependensinya:

Menjalankan langsung vs kompilasi

runghc Main.hs          # cepat, untuk development
ghc -O2 -o app Main.hs  # hasil binary native
./app

#Arsitektur Program: dari runghc ke main

Ketika kalian menjalankan file Haskell, urutannya selalu sama:

Struktur minimal program Haskell

main :: IO ()
main = putStrLn "Hello, Haskell!"

main :: IO () berarti "aksi main adalah aksi IO yang menghasilkan nilai kosong (). Program yang berinteraksi dengan dunia luar harus bermuara di main. Sisi kiri :: mendeklarasikan tipe; detailnya akan kita bedah di episode 5, dan apa itu IO di episode 11.

Tip

Aturan praktis memahami arsitektur GHC: sumber .hs -> type checker (bug terbanyak tertangkap di sini) -> Core -> code generator -> binary. Ketika build error membingungkan, tanyakan dulu "di fase mana ini terjadi" — error tipe sering terlihat seperti masalah lain, tapi lokasinya hampir selalu di type checker.

#Cabal vs Stack: Dua Jalur Build

Kalian akan melihat dua nama build tool sepanjang series ini. Secara singkat:

cabal adalah build tool standar yang memakai paket dari Hackage, bebas memilih versi dependensi.
stack membungkus cabal dengan snapshot Stackage — kumpulan versi paket yang sudah diuji kompatibel satu sama lain — sehingga build reproducible tanpa mikir versi.

Aspek	cabal	stack
Sumber paket	Hackage (bebas versi)	Stackage snapshot (terkurasi)
Reproducibility	via `cabal.project.freeze`	via resolver LTS
Kemudahan pemula	sedang	tinggi
Kontrol versi	maksimal	dibatasi snapshot

Kita bedah keduanya secara mendalam di episode 9, termasuk cara memilih untuk proyek kalian.

#Penutup

Pada episode 2 ini, kalian telah memahami bagaimana toolchain Haskell bekerja dari sumber hingga eksekusi.

Inti yang harus dibawa pulang:

GHC mengkompilasi lewat rantai Parser → Type checker → Core → STG → Code generator, dengan backend native, LLVM, dan wasm32wasi.
GHCi adalah REPL andalan: :t untuk tipe, let untuk definisi, :q untuk keluar.
Ekosistem: ghc, ghci, runghc, cabal, stack, HLS, dan Prelude yang selalu tersedia.
Setiap program bermuara di main :: IO (); interaksi dunia luar dikurung di IO.
cabal bebas versi (Hackage), stack reproducible (snapshot Stackage).

Di episode 3 selanjutnya kita akan melakukan instalasi & hello world — memastikan toolchain benar-benar berfungsi dengan menulis program pertama, menjalankannya via runghc dan cabal run, serta mengenal alur kerja build paling dasar yang akan dipakai sepanjang series. Sampai jumpa di episode 3!