Sözdizimi Tasarımı - Neden hiçbir argüman iletilmezse parantez kullanılır?

Birçok dilde, sözdizimi function_name(arg1, arg2, ...)bir işlevi çağırmak için kullanılır. Fonksiyonu herhangi bir argüman olmadan çağırmak istediğimizde yapmalıyız function_name().

Bir derleyici veya komut dosyası yorumlayıcısının ()onu işlev çağrısı olarak başarılı bir şekilde algılaması gerekebileceğini garip buluyorum . Bir değişkenin çağrılabilir olduğu biliniyorsa, neden function_name;yeterli olmaz?

Öte yandan, bazı dillerde yapabiliriz: function_name 'test';hatta function_name 'first' 'second';bir işlevi veya komutu çağırmak için.

Bence sadece öncelik sırasını açıklamak için gerekli olsaydı, diğer yerlerde isteğe bağlıysa parantez daha iyi olurdu. Örneğin, yapmak if expression == true function_name;kadar geçerli olmalıdır if (expression == true) function_name();.

Bence en sinir bozucu şey 'SOME_STRING'.toLowerCase()prototip işlevinde açıkça hiçbir argümana ihtiyaç duyulmadığında yapmaktır . Tasarımcılar neden daha basitine karşı karar verdi 'SOME_STRING'.lower?

Yasal Uyarı: Beni yanlış anlamayın, C benzeri sözdizimini seviyorum! ;) Sadece daha iyi olup olmadığını soruyorum. İsteğin ()herhangi bir performans avantajı var mı , yoksa kodu anlamayı kolaylaştırıyor mu? Sebebinin tam olarak ne olduğunu gerçekten merak ediyorum.

Birinci sınıf işlevleri kullanan diller için, bir işleve başvuruda bulunma sözdiziminin şu şekilde olması yaygındır :

a = object.functionName

bu işlevi çağırma eylemi :

b = object.functionName()

aYukarıdaki örnekte, yukarıdaki fonksiyona atıfta bulunulur (ve bunu yaparak arama yapabilirsiniz a()), bfonksiyonun dönüş değerini içerir.

Bazı diller parantez olmadan işlev çağrıları yapabilirken , işlevi çağırıp çağırmadıklarını veya yalnızca işleve başvurarak kafalarını karıştırabilir .

Nitekim, Scala buna izin vermektedir, ancak takip edilen bir kongre vardır: yöntem yan etkileri varsa, yine de parantez kullanılmalıdır.

Derleyici bir yazar olarak parantez içinde garantili varlığı oldukça uygun bulur; Bunun bir yöntem çağrısı olduğunu her zaman bilirdim ve garip durum için bir çatallanma oluşturmak zorunda kalmayacağım.

Bir programcı ve kod okuyucusu olarak, parantezlerin varlığı, hiçbir parametre geçmese de, yöntem çağrısı olduğundan kuşku duymaz.

Parametrelerin geçirilmesi, bir yöntem çağrısının tek tanımlayıcı özelliği değildir. Neden parametresiz bir metodu, parametreleri olan bir metottan farklı olarak kabul edeyim?

Bu aslında sözdizimi seçeneklerinin oldukça ince bir ifadesidir. Yazılan lamda matematiğine dayanan fonksiyonel dilleri konuşacağım.

Söz konusu dillerde, her işlevin tam olarak bir argümanı vardır . Sıklıkla "çoklu argüman" olarak düşündüğümüz şey aslında ürün tipi için tek bir parametredir. Örneğin, iki tam sayıyı karşılaştıran işlev:

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

tek bir tamsayı çifti alır. Parantez yok değil işlev parametreleri belirtmek; argümanla eşleşmek için kullanılırlar . Bunun gerçekten tek bir argüman olduğuna sizi ikna etmek için, bunun yerine parselin yapısını kaldırmak için desen eşleştirme yerine yansıtmalı fonksiyonları kullanabiliriz:

leq some_pair = some_pair.1 <= some_pair.2

Bu nedenle, parantez gerçekten desen eşleştirmemizi ve bazı yazı tiplerini kaydetmemizi sağlayan bir kolaylık. Onlar gerekli değildir.

Görünüşe göre tartışmasız bir fonksiyona ne dersiniz? Böyle bir fonksiyonun aslında bir alanı vardır Unit. Tek üye Unitgenellikle şu şekilde yazılır (), bu yüzden parantez içinde görünür.

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

Bu fonksiyonu çağırmak için, biz türünde bir değere uygulamak zorunda kalacak Unitolmalıdır (), bu yüzden yazma sonunda say_hi ().

Yani, bir tartışma listesi gibi bir şey gerçekten yok!

Örneğin Javascript'te () olmadan bir yöntem adı kullanmak, işlevi çalıştırmadan döndürür. Bu şekilde, örneğin işlevi başka bir yönteme argüman olarak iletebilirsiniz.

Java'da, () veya (...) izleyen bir tanımlayıcının, bir yöntem değişkeni anlamına gelirken, () olmayan bir tanımlayıcı bir üye değişkenine başvurduğundan seçim yapıldı. Bu, bir yöntem veya üye değişkenle ilgilenip ilgilenmediğiniz konusunda hiçbir şüpheniz olmadığı için okunabilirliği artırabilir. Aslında, aynı isim hem bir yöntem hem de bir üye değişkeni için kullanılabilir, her ikisinin de kendi sözdizimleriyle erişilebilir olacaktır.

Sözdizimi anlambilim izler, öyleyse anlambilimden başlayalım:

Bir işlev veya yöntem kullanmanın yolları nelerdir?

Aslında, birçok yol var:

• işlev, bağımsız değişkenli veya değişkensiz çağrılabilir
• bir fonksiyon değer olarak değerlendirilebilir
• bir fonksiyon kısmen uygulanabilir (en az bir tane daha argüman alarak ve geçen argümanların kapatılmasıyla bir kapatma oluşturulması)

Farklı kullanımlar için benzer bir sözdizimine sahip olmak, belirsiz bir dil veya en azından kafa karıştırıcı bir dil oluşturmak için en iyi yoldur (ve bunlardan yeterince sahibiz).

C ve C benzeri dillerde:

• Bir işlev çağrısı, olduğu gibi argümanları (hiçbiri olabilir) içine almak için parantez kullanılarak yapılır. func()
• Bir işlevin bir değer olarak ele alınması, basitçe ismini kullanarak &func(C bir işaretçi oluşturma)
• Bazı dillerde, kısmen uygulamak için kısa el sözdiziminiz vardır; Java, someVariable::someMethodörneğin izin verir (yöntem alıcısıyla sınırlıdır, ancak yine de yararlıdır)

Her kullanımın farklı bir sözdizimine sahip olduğunu ve bunları kolayca ayırt etmenizi sağladığını unutmayın.

Yan etkileri olan bir dilde IMO, bir değişkenin okunması arasında (teoride yan etki serbest) ayırt etmek gerçekten yararlıdır.

variable

ve yan etkilere neden olabilecek bir işlevi çağırmak

launch_nukes()

OTOH, eğer yan etki yoksa (tip sisteminde kodlananlar dışında), bir değişkeni okumakla argüman içermeyen bir işlevi çağırmak arasında ayrım yapmanın bir anlamı yoktur.

Diğer cevapların hiçbiri şu soru ile başa çıkmaya çalışmadı: Bir dil tasarımında ne kadar fazlalık olması gerekiyor? Çünkü bir dili x = sqrt yx'i y'nin kareköküne ayarlayacak şekilde tasarlasanız bile , bu mutlaka yapmanız gerektiği anlamına gelmez.

Artıklık olmayan bir dilde, her karakter dizisi bir şey ifade eder, yani tek bir hata yaparsanız, bir hata mesajı almazsınız, programınız yanlış olanı yapar, bu da sizden çok farklı bir şey olabilir amaçlanan ve hata ayıklamak çok zor. (Düzenli ifadelerle çalışan herkesin bileceği gibi.) Küçük bir fazlalık iyi bir şeydir, çünkü hatalarınızın çoğunun tespit edilmesini sağlar ve orada fazlalık olması ne kadar fazla olursa, teşhislerin doğru olması o kadar olasıdır. Şimdi elbette, bunu çok uzağa götürebilirsiniz (bugünlerde hiçbirimiz COBOL'da yazmak istemiyoruz), fakat doğru olan bir denge var.

Artıklık, okunabilirliğe de yardımcı olur, çünkü daha fazla ipucu vardır. Artıklık olmadan İngilizce okumak çok zor olurdu ve aynı programlama dilleri için de geçerlidir.

Çoğu durumda, bunlar dilin dilbilgisinin sözdizimsel seçimleridir. Çeşitli bireysel yapıların birlikte alındıklarında (göreceli olarak) belirgin olmaları için dilbilgisi için faydalıdır. (Bazı C ++ bildirimlerinde olduğu gibi belirsizlikler varsa, çözüm için belirli kurallar olması gerekir.) Derleyicinin tahmin etme enlemi yoktur; dil şartnamesini takip etmek gerekir.

Visual Basic, çeşitli formlarda, değer döndürmeyen prosedürler ile işlevler arasında farklılık gösterir.

Prosedürler bir ifade olarak adlandırılmalıdır ve parens gerektirmez, varsa virgülle ayrılmış argümanlar gerekir. İşlevler ifadenin bir parçası olarak çağrılmalıdır ve parens gerektirir.

İki form arasında manuel yeniden düzenlemeyi olması gerekenden daha acı verici hale getiren nispeten gereksiz bir ayrımdır.

(Öte yandan Visual Basic aynı parens kullanan ()diğer diller kullanmak düşünmek olabilir, fonksiyon çağrıları için büyüdükçe dizi referanslar için, bu nedenle dizi referanslar fonksiyon çağrıları benziyorsun. Ve bu işlev çağrısı içine bir dizinin manuel üstlenmeden kolaylaştırır! Yani []'s dizi referansları için, ancak digress…)

C ve C ++ dillerinde değişkenlerin içeriklerine isimleri kullanılarak otomatik olarak erişilir ve içeriği yerine değişkenin kendisine başvurmak istiyorsanız, unary &operatörünü uygularsınız .

Bu tür bir mekanizma fonksiyon isimlerine de uygulanabilir. İşlenmemiş işlev adı, bir işlev çağrısı anlamına gelebilir; oysa, unary &işlevi, işlevi (kendisine) veri olarak adlandırmak için kullanılır. Şahsen, yan etki içermeyen argüman işlevlerine değişkenlerle aynı sözdizimi ile erişme fikrini seviyorum.

Bu tamamen mantıklı (bunun için başka sözdizimsel seçimler olduğu gibi).

Tutarlılık ve okunabilirlik.

Sana işlevi çağırmak olduğunu öğrenirsek Xböyle: X(arg1, arg2, ...)o zaman ben hiçbir argümanlar için aynı şekilde çalışır bekliyoruz: X().

Şimdi aynı zamanda değişkeni bir sembol olarak tanımlayabileceğinizi ve bunun gibi kullanabileceğinizi öğrendim:

a = 5
b = a
...

Şimdi bunu bulduğumda ne düşünürdüm?

c = X

Tahminin benimki kadar iyi. Normal koşullarda, Xbir değişkendir. Fakat yolunuza gidersek, bunun bir işlevi de olabilir! Hangi sembolün hangi gruba eşlenip eşleşmediğini (değişkenler / fonksiyonlar) hatırlamıyor muyum?

“İşlevler büyük harfle başlar. Değişkenler küçük harfle başlar” gibi yapay kısıtlamalar uygulayabiliriz, ancak bu gerekli değildir ve bazen tasarım hedeflerinin bazılarına yardımcı olsa da işleri daha karmaşık hale getirir.

1. Not: Diğer cevaplar bir şeyi daha görmezden gelir: dil, aynı işlevi hem işlev hem de değişken için kullanmanıza ve bağlamla ayırt etmenize izin verebilir. Common LispÖrnek olarak görün . İşlev xve değişken xmükemmel bir şekilde bir arada bulunur.

Yan not 2: Kabul cevabı bize sözdizimi gösterilmektedir: object.functionname. İlk olarak, birinci sınıf fonksiyonları olan diller için evrensel değildir. İkincisi, bir programcı olarak bunu ek bir bilgi olarak ele functionnamealırdım : a object. İster objectbir nesne, bir sınıf veya bir ad o kadar önemli değil, ama buna ait olduğunu söyler yerde . Bu object., her bir küresel işlev için yapay sözdizimi eklemek veya objecttüm küresel işlevleri tutmak için bazılarını oluşturmak zorunda olduğunuz anlamına gelir .

Her iki durumda da, fonksiyonlar ve değişkenler için ayrı ad alanlarına sahip olma özelliğini kaybedersiniz.

Diğer cevaplara eklemek için şu C örneğini alın:

void *func_factory(void)
{
        return 0;
}

void *(*ff)(void);

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

Eğer çağrı operatörü isteğe bağlı olsaydı, işlev ataması ile işlev çağrısı arasında ayrım yapmanın bir yolu olmazdı.

Bu tür bir sistemden yoksun olan dillerde daha da problemlidir, örneğin JavaScript, tür çıkarımının neyin bir fonksiyon olup olmadığını anlamak için kullanılamaması.