KAL
Menu

Procs

Mendefinisikan proc dengan nilai kembalian result, parameter bernama, parameter bawaan, dan parameter var.

Daftar isi

Proc adalah bentuk fungsi (function) pada Nim, yaitu blok kode bernama yang dapat dipanggil ulang dengan argumen yang berbeda-beda. Topik ini membahas definisi proc, nilai kembalian melalui variabel result, parameter bawaan (default), parameter bernama, parameter var, serta overloading nama proc. Contoh utamanya berupa kalkulator empat operasi aritmetika dasar yang hasilnya mudah dihitung ulang.

Definisi proc dan pemanggilannya#

Sebuah proc didefinisikan dengan kata kunci proc, diikuti nama, daftar parameter bertipe, tipe kembalian, tanda sama dengan, dan tubuh proc yang diindentasi. Setiap parameter wajib menyertakan tipe, dan koma boleh meringkas beberapa parameter yang bertipe sama menjadi satu penulisan, misalnya a, b: int. Proc dipanggil dengan menuliskan namanya diikuti argumen di dalam tanda kurung.

Program berikut memuat empat proc untuk operasi aritmetika. Proc bagikan sekaligus memperlihatkan return yang menghentikan proc lebih awal, yaitu ketika pembaginya nol.

nim kalkulator.nim 
# Kalkulator sederhana untuk empat operasi dasar

proc jumlahkan(a: float, b: float): float =
  result = a + b

proc kurangkan(a: float, b: float): float =
  result = a - b

proc kalikan(a: float, b: float): float =
  result = a * b

proc bagikan(a: float, b: float): float =
  if b == 0.0:
    return 0.0
  result = a / b

echo "10 + 4 = ", jumlahkan(10.0, 4.0)
echo "10 - 4 = ", kurangkan(10.0, 4.0)
echo "10 x 4 = ", kalikan(10.0, 4.0)
echo "10 / 4 = ", bagikan(10.0, 4.0)
echo "10 / 0 = ", bagikan(10.0, 0.0)
bash 
# kompilasi dan jalankan program, hint kompilasi disembunyikan
nim c --hints:off -r kalkulator.nim
text Keluaran 
10 + 4 = 14.0
10 - 4 = 6.0
10 x 4 = 40.0
10 / 4 = 2.5
10 / 0 = 0.0

Setiap pemanggilan mengembalikan nilai float yang langsung diteruskan ke echo. Pembagian 10.0 dengan 4.0 menghasilkan 2.5, sedangkan pembagian dengan nol mengembalikan 0.0 melalui return yang ditempatkan sebelum perhitungan. Argumen dipisahkan koma dan dipetakan ke parameter menurut posisinya.

Nama proc mengikuti konvensi camelCase, dan proc dapat dipanggil dari proc lain maupun dari pernyataan tingkat atas berkas. Pada pemanggilan posisi, urutan argumen menentukan parameter yang menerimanya, sehingga jumlahkan(10.0, 4.0) menugaskan 10.0 kepada a dan 4.0 kepada b. Tubuh proc memakai indentasi dua spasi pada contoh, sebagaimana blok kode lainnya.

Nilai kembalian melalui result#

Proc yang menyatakan tipe kembalian memiliki variabel tersirat bernama result. Variabel ini otomatis diinisialisasi dengan nilai bawaan tipe kembalian, yaitu 0 untuk angka dan string kosong untuk string, sehingga tidak wajib diisi pada setiap jalur eksekusi. Nilai result dikembalikan secara otomatis ketika proc berakhir, sedangkan pernyataan return tetap dapat dipakai untuk mengembalikan nilai lebih awal.

nim Contoh: result terisi bertahap dan return yang mendahului 
proc akumulasi(x: int): int =
  result = result + x

proc pembagiNol(a: float, b: float): float =
  if b == 0.0:
    return 0.0
  result = a / b

echo akumulasi(5)
echo akumulasi(7)
echo pembagiNol(10.0, 2.0)
echo pembagiNol(10.0, 0.0)
text Keluaran 
5
7
5.0
0.0

Proc akumulasi menambahkan argumen ke result tanpa menginisialisasinya, karena result sudah bernilai 0 pada setiap pemanggilan. Proc pembagiNol memperlihatkan return yang menghentikan proc sebelum perhitungan pembagian dijalankan. Ekspresi terakhir pada tubuh proc juga dikembalikan tanpa result maupun return, sehingga proc duaKali(x: int): int = x * 2 mengembalikan dua kali argumennya.

Nilai bawaan result mengikuti tipe kembalian proc, sehingga proc bertipe int memulai dari 0 dan proc bertipe float memulai dari 0.0. Perilaku ini membuat proc yang hanya menambah ke result tidak membutuhkan inisialisasi, sebagaimana proc akumulasi pada potongan di atas.

Parameter bawaan dan parameter bernama#

Parameter bawaan (default parameter) menyimpan nilai yang dipakai apabila argumennya tidak diberikan. Nilainya ditulis setelah tanda sama dengan pada daftar parameter, dan pemanggil boleh melewati parameter tersebut. Parameter bernama (named argument) memungkinkan argumen ditulis dengan bentuk nama = nilai, sehingga urutannya bebas dan makna setiap argumen terbaca jelas pada pemanggilan yang panjang.

Program berikut memanggil proc sapa dengan tiga cara. Pemanggilan pertama melewati sapaan sehingga nilai bawaan Halo dipakai, pemanggilan kedua memberikan sapaan berdasarkan posisi argumen, dan pemanggilan ketiga menyebut parameter sapaan secara bernama.

nim sapa_pengguna.nim 
proc sapa(nama: string, sapaan: string = "Halo") =
  echo sapaan, ", ", nama, "!"

sapa("Budi")
sapa("Citra", "Selamat pagi")
sapa("Dewi", sapaan = "Selamat sore")
text Keluaran 
Halo, Budi!
Selamat pagi, Citra!
Selamat sore, Dewi!

Karena bernama, argumen juga boleh ditulis terbalik, misalnya sapa(sapaan = "Hai", nama = "Ali") menghasilkan Hai, Ali!. Kombinasi argumen posisi dan argumen bernama pada satu pemanggilan juga sah, sebagaimana terlihat pada pemanggilan ketiga dalam program di atas.

Parameter var#

Parameter biasa bersifat tak dapat diubah di dalam tubuh proc, sehingga penugasan ke parameter memicu error 'x' cannot be assigned to. Parameter yang dinyatakan dengan kata kunci var di depan tipenya bersifat sebaliknya. Proc yang menerimanya boleh memberi nilai baru, dan perubahan itu terlihat oleh pemanggil karena yang diteruskan adalah variabel pemanggil itu sendiri, bukan salinannya.

Program berikut menukar isi dua variabel melalui proc tukar. Kedua parameternya berupa var int, sehingga penugasan di dalam proc mengubah p dan q milik pemanggil.

nim tukar_nilai.nim 
proc tukar(a: var int, b: var int) =
  let sementara = a
  a = b
  b = sementara

var p = 3
var q = 8
echo "sebelum: p = ", p, ", q = ", q
tukar(p, q)
echo "sesudah: p = ", p, ", q = ", q
text Keluaran 
sebelum: p = 3, q = 8
sesudah: p = 8, q = 3

Argumen untuk parameter var harus berupa variabel var. Variabel let ditolak compiler dengan pesan expression 'p' is immutable, not 'var', karena nilai let tidak dapat diubah sehingga tidak ada gunanya diteruskan ke parameter yang dimodifikasi.

Menukar dua nilai membutuhkan variabel sementara karena penugasan langsung a = b menghapus nilai lama a sebelum sempat disalin. Proc tukar menyimpan a ke sementara, menyalin b ke a, lalu menyalin sementara ke b. Pola tiga langkah seperti ini lazim pada proc dengan parameter var, karena setiap perubahan langsung terlihat oleh pemanggil.

Overloading nama proc#

Nim mengizinkan beberapa proc memakai nama yang sama selama daftar parameternya berbeda tipe. Mekanisme ini disebut overloading, dan compiler memilih proc yang cocok berdasarkan tipe argumen pada setiap pemanggilan. Proc echo pada pustaka standar bekerja dengan cara ini, sehingga satu nama echo dapat menampilkan angka, string, maupun wadah lainnya tanpa proc terpisah.

nim Contoh: dua proc dengan nama yang sama 
proc tampilkan(x: int) =
  echo "angka: ", x

proc tampilkan(x: string) =
  echo "teks: ", x

tampilkan(24)
tampilkan("nim")
text Keluaran 
angka: 24
teks: nim

Pemanggilan dengan argumen int menjalankan proc pertama, sedangkan argumen string menjalankan proc kedua. Overloading sebaiknya dipakai untuk proc yang melakukan pekerjaan serupa pada tipe berbeda, bukan untuk tugas yang tidak berkaitan, agar maksud setiap nama tetap tunggal. Compiler menolak pula pemanggilan yang argumennya tidak cocok dengan tipe pada proc mana pun, sebagaimana type mismatch pada umumnya.

Ringkasan#

  • Proc dengan tipe kembalian memiliki variabel result yang terinisialisasi otomatis dan dikembalikan saat proc berakhir.
  • return menghentikan proc lebih awal, dan ekspresi terakhir tubuh proc dikembalikan secara tersirat.
  • Parameter bawaan dipakai saat argumennya dilewati, sedangkan parameter bernama ditulis dalam bentuk nama = nilai dengan urutan bebas.
  • Parameter var meneruskan variabel pemanggil sehingga perubahan di dalam proc terlihat di luar, sedangkan parameter biasa tidak dapat diubah.

Referensi#