Belajar Haskell - FFI & Interop

#Pendahuluan

Tidak ada bahasa yang hidup sendiri. Di episode 18 ini kita membuka pintu antara Haskell dan ekosistem di luar dirinya: C/C++ lewat Foreign Function Interface (FFI), dan WebAssembly untuk menjalankan kode Haskell di tempat yang tidak pernah terpikirkan sebelumnya — browser dan edge runtime.

Mengapa bab ini penting? Karena di dunia nyata, kalian akan memanggil library C yang sudah teruji (kripto, compression, native driver), atau diminta memakai logika Haskell dari aplikasi lain. FFI adalah jembatan itu, dan dukungan WASM yang stabil di GHC 9.14 membuka peluang distribusi yang benar-benar baru.

#FFI: Memanggil Kode C dari Haskell

Foreign Function Interface (FFI) memungkinkan Haskell memanggil fungsi dari bahasa lain — praktis selalu C. Sintaks dasarnya foreign import:

foreign import ccall unsafe "math.h pow"
    c_pow :: Double -> Double -> Double
 
main :: IO ()
main = print (c_pow 2.0 10.0)   -- 1024.0

• foreign import — mendeklarasikan pemanggilan keluar dari Haskell.
• ccall — calling convention standar C.
• "math.h pow" — header dan nama simbol di C.
• c_pow — nama fungsi di sisi Haskell.

Kalau nama fungsi Haskell sama dengan simbol C, string bisa dihilangkan:

foreign import ccall unsafe "sqrt"
    sqrtC :: Double -> Double

#Menulis Fungsi C Sendiri

Proses dua arah: tulis kode C, link dengan binary Haskell, lalu panggil.

csrc/adder.c

int adder(int a, int b) {
    return a + b;
}

foreign import ccall unsafe "adder"
    c_adder :: Int -> Int -> Int
 
main :: IO ()
main = print (c_adder 40 2)   -- 42

Kompilasi dengan GHC, menyertakan file C:

ghc -O2 Main.hs csrc/adder.c -o app
./app

GHC mengkompilasi .c secara otomatis — tanpa makefile khusus untuk kasus sederhana.

#Memahami ABI

ABI (Application Binary Interface) adalah "kontrak di level binary": bagaimana fungsi dipanggil, bagaimana argumen dan nilai kembali dilewatkan, dan bagaimana memori diatur. Ketika FFI menyebut "calling convention", itulah bagian dari ABI. Poin-poin penting:

• Jenis data: Int di Haskell dipetakan ke long/intptr_t C — ukuran platform-dependent. Gunakan tipe eksplisit (CInt, CLong, CString, CUChar) dari Foreign.C.Types untuk mencegah kebingungan ukuran.
• String: String Haskell tidak bisa langsung dipakai; konversi lewat CString (peka nul-terminated) dengan helper newCString/peekCString.
• Ownership memori: siapa yang mengalokasi harus yang membebaskan. Jangan membebaskan pointer yang dialokasi Haskell, dan sebaliknya.

#Keamanan FFI

FFI menembus semua jaminan tipe — kalian perlu disiplin ekstra:

1. unsafe vs safe: foreign import ... unsafe mengasumsikan fungsi C cepat dan tidak memanggil kembali ke Haskell; untuk I/O yang lama atau blocking, gunakan safe agar tidak memblokir seluruh runtime.
2. Lindungi data: jangan mengekspos mutable state C ke kode pure; bungkus di balik aksi IO atau monad khusus.
3. Null pointer: fungsi C sering mengembalikan NULL; cek dan terjemahkan ke Maybe/Either di sisi Haskell — jangan pernah membiarkan pointer mentah bocor ke logika.

#Interop Arah Berlawanan: Haskell sebagai Library C

FFI juga bekerja sebaliknya — mengekspor fungsi Haskell sebagai API C yang bisa dipanggil bahasa lain. Ini cara mengemas logika Haskell menjadi library yang bisa dipakai Python, Rust, atau C:

foreign export ccall "haskell_double"
    haskell_double :: Int -> Int
 
haskell_double :: Int -> Int
haskell_double x = x * 2

Setelah dikompilasi, haskell_double menjadi simbol C yang bisa di-extern dari bahasa lain. Teknik ini dipakai untuk membungkus logika critical (misal mesin bisnis) menjadi service yang bahasa lain hanya panggil — menjaga correctness logic tetap di Haskell.

#WASM: Haskell di Browser dan Edge

WebAssembly (WASM) adalah target eksekusi universal: binary yang berjalan di browser, edge runtime, dan container ringan. Sejak GHC 9.14, target wasm32wasi stabil — artinya kalian bisa mengkompilasi Haskell menjadi WASM dengan toolchain standar.

ghcup install wasm
ghc --target=wasm32wasi -O2 Main.hs -o app.wasm

Beberapa hal yang perlu diketahui:

• WASI (WebAssembly System Interface) adalah lapisan syscall untuk WASM di luar browser — memungkinkan file I/O, env var, dan argumen CLI.
• Kode Haskell yang pure (tidak menyentuh I/O rumit) dikompilasi hampir langsung. Kode yang memakai banyak IO perlu menyesuaikan dengan kemampuan WASI.
• Run-time GHC mendukung model thread yang sama, sehingga concurrency (episode 12) ikut terbawa ke WASM.

#Interop JavaScript dan Reflex

Untuk frontend, ekosistem Reflex (dengan Reflex-DOM) dan Jsaddle menyediakan cara membangun UI reaktif di browser sambil logika inti tetap di Haskell:

• Jsaddle mem-bridge calls ke DOM/JS dari runtime GHC — mirip konsep FFI, tapi untuk JavaScript.
• Reflex-DOM membangun UI functional reactive di atasnya — event dan sinyal dideklarasikan secara fungsional.

Dengan WASM stabil, jalur ini menjadi lebih praktis: logika Haskell yang sudah diuji dengan QuickCheck bisa dipakai di frontend tanpa ditulis ulang.

#Kesalahan Umum (Common Pitfalls)

1. Tipe FFI yang tidak cocok — selalu pakai CInt/CString/CUChar dari Foreign.C.Types, bukan Int/String.
2. unsafe untuk pemanggilan yang blocking — lama-lama seluruh runtime terkunci; gunakan safe.
3. Pointer yang bocor — setiap malloc/newCString harus punya free/peekCString yang berpasangan.
4. FFI di kode pure — pemanggilan C yang punya efek samping harus dibungkus IO.
5. Menggunakan fitur I/O yang belum didukung WASI — cek dukungan target sebelum porting kode IO besar.

#Penutup

Inti yang harus dibawa pulang:

• FFI (foreign import ccall) memanggil fungsi C; tipe harus memakai Foreign.C.Types.
• Pahami ABI: calling convention, ukuran tipe, dan ownership memori.
• foreign export membalik arah — Haskell menjadi library C untuk bahasa lain.
• wasm32wasi stabil di GHC 9.14: kode Haskell bisa jalan di browser dan edge.
• Pure core besar, IO boundary tipis — kunci portabilitas lintas platform.

Di episode 19 selanjutnya kita akan membahas testing lanjut & property-based — custom Arbitrary dan shrinking di QuickCheck, stateful testing dengan Hedgehog, golden files untuk regression, serta mengintegrasikan semuanya ke CI dengan GitHub Actions dan GHC matrix. Sampai jumpa di episode 19!