Apa arti tanda seru dalam deklarasi Haskell?

Saya menemukan definisi berikut ketika saya mencoba mempelajari Haskell menggunakan proyek nyata untuk mengendarainya. Saya tidak mengerti apa arti tanda seru di depan setiap argumen dan sepertinya buku-buku saya tidak menyebutkannya.

data MidiMessage = MidiMessage !Int !MidiMessage

Ini deklarasi ketat. Pada dasarnya, itu berarti bahwa itu harus dievaluasi untuk apa yang disebut "bentuk normal kepala lemah" ketika nilai struktur data dibuat. Mari kita lihat sebuah contoh, sehingga kita dapat melihat apa artinya ini:

data Foo = Foo Int Int !Int !(Maybe Int)

f = Foo (2+2) (3+3) (4+4) (Just (5+5))

Fungsi di fatas, ketika dievaluasi, akan mengembalikan "thunk": yaitu kode yang akan dieksekusi untuk mencari nilainya. Pada titik itu, Foo bahkan belum ada, hanya kodenya.

Tetapi pada titik tertentu seseorang mungkin mencoba melihat ke dalamnya, mungkin melalui pencocokan pola:

case f of
     Foo 0 _ _ _ -> "first arg is zero"
     _           -> "first arge is something else"

Ini akan mengeksekusi kode yang cukup untuk melakukan apa yang dibutuhkan, dan tidak lebih. Jadi itu akan membuat Foo dengan empat parameter (karena Anda tidak dapat melihat di dalamnya tanpa itu ada). Yang pertama, sejak kami mengujinya, kami perlu mengevaluasi sampai ke sana 4, di mana kami menyadari itu tidak cocok.

Yang kedua tidak perlu dievaluasi, karena kami tidak mengujinya. Jadi, daripada 6disimpan di lokasi memori itu, kami hanya akan menyimpan kode untuk kemungkinan evaluasi nanti (3+3),. Itu akan berubah menjadi 6 hanya jika seseorang melihatnya.

Namun, parameter ketiga ada !di depannya, jadi dievaluasi secara ketat: (4+4)dijalankan, dan 8disimpan di lokasi memori itu.

Parameter keempat juga dievaluasi secara ketat. Tapi di sinilah agak rumit: kita mengevaluasi tidak sepenuhnya, tetapi hanya untuk bentuk kepala normal yang lemah. Ini berarti bahwa kita mencari tahu apakah itu sesuatu Nothingatau Justsesuatu, dan menyimpannya, tetapi kita tidak melangkah lebih jauh. Itu berarti bahwa kita tidak menyimpan Just 10tetapi sebenarnya Just (5+5), membiarkan bagian dalam tidak dievaluasi. Ini penting untuk diketahui, meskipun saya pikir semua implikasi ini melampaui lingkup pertanyaan ini.

Anda dapat membuat anotasi argumen fungsi dengan cara yang sama, jika Anda mengaktifkan BangPatternsekstensi bahasa:

f x !y = x*y

f (1+1) (2+2)akan mengembalikan thunk (1+1)*4.

Cara sederhana untuk melihat perbedaan antara argumen konstruktor yang ketat dan tidak ketat adalah bagaimana mereka berperilaku ketika mereka tidak terdefinisi. Diberikan

data Foo = Foo Int !Int

first (Foo x _) = x
second (Foo _ y) = y

Karena argumen non-ketat tidak dievaluasi oleh second, menyampaikan undefinedtidak menyebabkan masalah:

> second (Foo undefined 1)
1

Tetapi argumen yang ketat tidak bisa undefined, bahkan jika kita tidak menggunakan nilainya:

> first (Foo 1 undefined)
*** Exception: Prelude.undefined

Saya percaya ini adalah penjelasan ketat.

Haskell adalah bahasa fungsional murni dan malas , tetapi kadang-kadang overhead dari kemalasan bisa terlalu banyak atau boros. Jadi untuk mengatasinya, Anda dapat meminta kompiler untuk mengevaluasi argumen sepenuhnya ke fungsi alih-alih menguraikan pemicu.

Ada informasi lebih lanjut di halaman ini: Kinerja / Ketat .