Desain Sintaks - Mengapa menggunakan tanda kurung ketika tidak ada argumen yang disampaikan?

Dalam banyak bahasa, sintaks function_name(arg1, arg2, ...)digunakan untuk memanggil suatu fungsi. Ketika kita ingin memanggil fungsi tanpa argumen, kita harus melakukannya function_name().

Saya merasa aneh bahwa kompiler atau juru bahasa naskah harus ()berhasil mendeteksinya sebagai panggilan fungsi. Jika suatu variabel diketahui bisa dipanggil, mengapa tidak function_name;cukup?

Di sisi lain, dalam beberapa bahasa kita dapat melakukan: function_name 'test';atau bahkan function_name 'first' 'second';untuk memanggil fungsi atau perintah.

Saya pikir kurung akan lebih baik jika mereka hanya diperlukan untuk menyatakan urutan prioritas, dan di tempat lain adalah opsional. Misalnya, melakukan if expression == true function_name;harus sama validnya dengan if (expression == true) function_name();.

Hal yang paling menyebalkan menurut saya adalah melakukan 'SOME_STRING'.toLowerCase()ketika jelas tidak ada argumen yang diperlukan oleh fungsi prototipe. Mengapa para desainer memutuskan menentang yang lebih sederhana 'SOME_STRING'.lower?

Penafian: Jangan salah, saya suka sintaksis C-like! ;) Saya hanya bertanya apakah itu bisa lebih baik. Apakah memerlukan ()memiliki keunggulan kinerja, atau apakah membuatnya lebih mudah memahami kode? Saya benar-benar ingin tahu apa alasan sebenarnya.

Untuk bahasa yang menggunakan fungsi kelas satu , cukup umum bahwa sintaks yang merujuk ke suatu fungsi adalah:

a = object.functionName

sedangkan tindakan memanggil fungsi itu adalah:

b = object.functionName()

adalam contoh di atas akan merujuk ke fungsi di atas (dan Anda bisa menyebutnya dengan melakukan a()), sementara bakan berisi nilai pengembalian fungsi.

Sementara beberapa bahasa dapat melakukan panggilan fungsi tanpa tanda kurung, itu bisa membingungkan apakah mereka memanggil fungsi, atau hanya merujuk ke fungsi.

Memang, Scala memungkinkan ini, meskipun ada konvensi yang diikuti: jika metode ini memiliki efek samping, tanda kurung harus tetap digunakan.

Sebagai penulis kompiler, saya akan menemukan kehadiran kurung dijamin cukup nyaman; Saya akan selalu tahu bahwa itu adalah pemanggilan metode, dan saya tidak perlu membangun bifurkasi untuk kasus aneh.

Sebagai seorang programmer dan pembaca kode, keberadaan tanda kurung tidak diragukan lagi bahwa itu adalah pemanggilan metode, meskipun tidak ada parameter yang dilewati.

Melewati parameter bukan satu-satunya karakteristik pendefinisian pemanggilan metode. Mengapa saya memperlakukan metode tanpa parameter yang berbeda dari metode yang memiliki parameter?

Ini sebenarnya adalah kebetulan pilihan sintaks yang cukup halus. Saya akan berbicara dengan bahasa fungsional, yang didasarkan pada kalkulus lambda yang diketik.

Dalam bahasa tersebut, setiap fungsi memiliki tepat satu argumen . Apa yang sering kita anggap sebagai "argumen berganda" sebenarnya adalah parameter tunggal dari jenis produk. Jadi misalnya, fungsi yang membandingkan dua bilangan bulat:

leq : int * int -> bool
leq (a, b) = a <= b

membutuhkan sepasang bilangan bulat. Tanda kurung tidak menunjukkan parameter fungsi; mereka digunakan untuk mencocokkan pola argumen. Untuk meyakinkan Anda bahwa ini benar-benar satu argumen, kita dapat menggunakan fungsi proyektif alih-alih pencocokan pola untuk mendekonstruksi pasangan:

leq some_pair = some_pair.1 <= some_pair.2

Dengan demikian, tanda kurung benar-benar kenyamanan yang memungkinkan kita untuk mencocokkan pola dan menyimpan beberapa pengetikan. Mereka tidak diharuskan.

Bagaimana dengan fungsi yang seolah-olah tidak memiliki argumen? Fungsi semacam itu sebenarnya memiliki domain Unit. Anggota tunggal Unitbiasanya ditulis sebagai (), jadi itu sebabnya tanda kurung muncul.

say_hi : Unit -> string
say_hi a = "Hi buddy!"

Untuk memanggil fungsi ini, kita harus menerapkannya ke nilai tipe Unit, yang harus (), jadi kita akhirnya menulis say_hi ().

Jadi, sebenarnya tidak ada daftar argumen!

Dalam Javascript misalnya menggunakan nama metode tanpa () mengembalikan fungsi itu sendiri tanpa menjalankannya. Dengan cara ini misalnya Anda dapat melewatkan fungsi sebagai argumen ke metode lain.

Di Jawa pilihan dibuat bahwa pengidentifikasi diikuti oleh () atau (...) berarti pemanggilan metode sementara pengidentifikasi tanpa () merujuk ke variabel anggota. Ini dapat meningkatkan keterbacaan, karena Anda tidak ragu apakah Anda berurusan dengan metode atau variabel anggota. Bahkan, nama yang sama dapat digunakan untuk metode dan variabel anggota, keduanya akan dapat diakses dengan sintaks masing-masing.

Sintaks mengikuti semantik, jadi mari kita mulai dari semantik:

Apa cara menggunakan fungsi atau metode?

Sebenarnya ada beberapa cara:

• suatu fungsi dapat dipanggil, dengan atau tanpa argumen
• suatu fungsi dapat diperlakukan sebagai nilai
• suatu fungsi dapat diterapkan sebagian (membuat penutupan mengambil setidaknya satu argumen lebih sedikit dan menutup argumen yang diteruskan)

Memiliki sintaksis yang serupa untuk kegunaan yang berbeda adalah cara terbaik untuk membuat bahasa yang ambigu atau setidaknya yang membingungkan (dan kami memiliki cukup banyak dari itu).

Dalam bahasa C, dan bahasa mirip C:

• memanggil fungsi dilakukan dengan menggunakan tanda kurung untuk melampirkan argumen (mungkin tidak ada) seperti pada func()
• memperlakukan fungsi sebagai nilai dapat dilakukan dengan hanya menggunakan namanya seperti dalam &func(C membuat pointer fungsi)
• dalam beberapa bahasa, Anda memiliki sintaksis pendek untuk menerapkan sebagian; Java memungkinkan someVariable::someMethodmisalnya (terbatas pada penerima metode, tetapi masih berguna)

Perhatikan bagaimana setiap penggunaan memiliki sintaks yang berbeda, memungkinkan Anda membedakannya dengan mudah.

Dalam bahasa dengan efek samping, IMO sangat membantu untuk membedakan antara pembacaan variabel (dalam efek samping teori)

variable

dan memanggil fungsi, yang mungkin menimbulkan efek samping

launch_nukes()

OTOH, jika tidak ada efek samping (selain yang dikodekan dalam sistem tipe) maka tidak ada titik untuk bahkan membedakan antara membaca variabel dan memanggil fungsi tanpa argumen.

Tidak ada jawaban lain yang mencoba menjawab pertanyaan: berapa banyak redundansi dalam desain suatu bahasa? Karena bahkan jika Anda dapat mendesain bahasa sehingga x = sqrt ymenetapkan x ke akar kuadrat dari y, itu tidak berarti Anda harus melakukannya.

Dalam bahasa tanpa redundansi, setiap urutan karakter berarti sesuatu, yang berarti bahwa jika Anda membuat kesalahan tunggal, Anda tidak akan mendapatkan pesan kesalahan, program Anda akan melakukan hal yang salah, yang mungkin sesuatu yang sangat berbeda dari apa yang Anda dimaksudkan dan sangat sulit untuk di-debug. (Seperti yang diketahui oleh siapa pun yang bekerja dengan ekspresi reguler.) Sedikit redundansi adalah hal yang baik karena memungkinkan banyak kesalahan Anda terdeteksi, dan semakin banyak redundansi, semakin besar kemungkinan diagnosis akan akurat. Sekarang tentu saja, Anda bisa mengambil terlalu jauh (tidak ada dari kita yang ingin menulis dalam COBOL hari ini), tetapi ada keseimbangan yang benar.

Redundansi juga membantu keterbacaan, karena ada lebih banyak petunjuk. Bahasa Inggris tanpa redundansi akan sangat sulit dibaca, dan hal yang sama berlaku untuk bahasa pemrograman.

Dalam kebanyakan kasus, ini adalah pilihan sintaksis tata bahasa. Ini berguna untuk tata bahasa agar berbagai konstruksi individu menjadi (relatif) tidak ambigu ketika disatukan. (Jika ada ambiguitas, seperti dalam beberapa deklarasi C ++, harus ada aturan khusus untuk resolusi.) Kompiler tidak memiliki lintang untuk menebak; diperlukan untuk mengikuti spesifikasi bahasa.

Visual Basic, dalam berbagai bentuk, membedakan antara prosedur yang tidak mengembalikan nilai, dan fungsi.

Prosedur harus disebut sebagai pernyataan, dan tidak memerlukan paren, cukup argumen yang dipisahkan koma, jika ada. Fungsi harus dipanggil sebagai bagian dari ekspresi, dan memerlukan parens.

Ini adalah perbedaan yang relatif tidak perlu yang membuat refactoring manual antara kedua bentuk lebih menyakitkan daripada yang seharusnya.

(Di sisi lain Visual Basic menggunakan parens yang sama ()untuk referensi array seperti untuk panggilan fungsi, sehingga referensi array terlihat seperti panggilan fungsi. Dan ini memudahkan refactoring manual dari array menjadi panggilan fungsi! Jadi, kita bisa merenungkan bahasa lain menggunakan []'s untuk referensi array, tapi saya ngelantur ...)

Dalam bahasa C dan C ++ isi variabel secara otomatis diakses dengan menggunakan namanya, dan jika Anda ingin merujuk ke variabel itu sendiri alih-alih isinya, Anda menerapkan &operator unary .

Mekanisme semacam ini juga bisa diterapkan pada nama-nama fungsi. Nama fungsi mentah dapat menyiratkan panggilan fungsi, sedangkan &operator unary akan digunakan untuk merujuk ke fungsi (itu sendiri) sebagai data. Secara pribadi, saya suka ide mengakses fungsi no-argumen bebas efek samping dengan sintaks yang sama dengan variabel.

Ini sangat masuk akal (seperti pilihan sintaksis lainnya untuk ini).

Konsistensi dan keterbacaan.

Jika saya belajar bahwa Anda memanggil fungsi Xseperti ini: X(arg1, arg2, ...), maka saya mengharapkan untuk bekerja dengan cara yang sama tanpa argumen: X().

Sekarang pada saat yang sama saya belajar bahwa Anda dapat mendefinisikan variabel sebagai beberapa simbol, dan menggunakannya seperti ini:

a = 5
b = a
...

Sekarang apa yang akan saya pikirkan ketika saya menemukan ini?

c = X

Dugaanmu sebaik milikku. Dalam keadaan normal, Xini adalah variabel. Tetapi jika kami mengambil jalan Anda, itu juga bisa menjadi fungsi! Apakah saya harus mengingat apakah simbol mana yang memetakan ke grup mana (variabel / fungsi)?

Kita dapat memaksakan batasan artifisial, misalnya "Fungsi dimulai dengan huruf kapital. Variabel mulai dengan huruf kecil", tetapi itu tidak perlu dan membuat segalanya lebih rumit, meskipun kadang-kadang mungkin membantu beberapa tujuan desain.

Catatan-samping 1: Jawaban lain sama sekali mengabaikan satu hal lagi: bahasa memungkinkan Anda menggunakan nama yang sama untuk fungsi dan variabel, dan membedakan berdasarkan konteks. Lihat Common Lispsebagai contoh. Fungsi xdan variabel xhidup berdampingan dengan sangat baik.

Side-catatan 2: Jawaban yang diterima menunjukkan sintaks: object.functionname. Pertama, itu tidak universal untuk bahasa dengan fungsi kelas satu. Kedua, sebagai seorang programmer saya akan memperlakukan ini sebagai informasi tambahan: functionnamemilik seorang object. Apakah objectobjek, kelas atau namespace tidak terlalu menjadi masalah, tapi itu memberitahu saya bahwa itu milik suatu tempat . Ini berarti Anda harus menambahkan sintaks buatan object.untuk setiap fungsi global atau membuat beberapa objectuntuk menahan semua fungsi global.

Dan bagaimanapun, Anda kehilangan kemampuan untuk memiliki ruang nama terpisah untuk fungsi dan variabel.

Untuk menambah jawaban lain, ambil contoh C ini:

void *func_factory(void)
{
        return 0;
}

void *(*ff)(void);

void example()
{
        ff = func_factory;
        ff = func_factory();
}

Jika operator pemanggilan adalah opsional, tidak akan ada cara untuk membedakan antara penugasan fungsi dan pemanggilan fungsi.

Ini bahkan lebih bermasalah dalam bahasa yang tidak memiliki sistem tipe, misalnya JavaScript, di mana inferensi tipe tidak dapat digunakan untuk mencari tahu apa yang bisa dan tidak berfungsi.