Neden fonksiyon parametrelerine açıklama eklemiyorsunuz?

Bu soruyu cevaplandırılabilir hale getirmek için, bir programcının aklındaki belirsizlik maliyetinin birkaç ekstra tuşa basılmasından çok daha pahalı olduğunu varsayalım.

Buna göre, neden takım arkadaşlarımın işlev parametrelerine açıklama yapmamaları ile kaçmalarına izin vereyim ? Aşağıdaki kodu, çok daha karmaşık bir kod parçasının ne olabileceğinin bir örneği olarak alın:

let foo x y = x + y

Şimdi, ipucunun hızlı bir incelemesi size F # 'nin x ve y'nin ints olmasını istediğinizi belirlediğini gösterecektir. Eğer istediğin buysa, her şey yolunda. Ama istediğini yapıp yapmadığını bilmiyorum. İki dizeyi birleştirmek için bu kodu oluşturduysanız ne olur? Ya da muhtemelen iki kat eklemek istediğinizi düşünüyorsanız? Ya da türünü belirlemek için fareyi her bir işlev parametresinin üzerine getirmek istemiyorsam ne olur?

Şimdi bunu örnek olarak alın:

let foo x y = "result: " + x + y

F # şimdi muhtemelen dizeleri birleştirmek istediğinizi varsayar, bu nedenle x ve y dizeleri olarak tanımlanır. Bununla birlikte, kodunuzu koruyan zavallı adam olarak, buna bakabilirim ve belki birlikte x ve y (inç) eklemek isteyip istemediğinizi merak edebilir ve sonucu UI amaçları için bir dizgeye eklemeyi isteyip istemediğinizi merak edebilirim.

Kesinlikle bu kadar basit örnekler için, bir kişi onun gitmesine izin verebilirdi, ancak neden açık türden bir açıklama politikası uygulamıyor?

let foo (x:string) (y:string) = "result: " + x + y

Belirsiz olmanın zararı nedir? Elbette, bir programcı yapmaya çalıştıkları şey için yanlış türler seçebilirdi, ama en azından bunu amaçladıklarını biliyorum, sadece bir gözetim değildi.

Bu ciddi bir soru ... F # için hala çok yeniyim ve şirketimin izini sürdüm. Benim kabul ettiğim standartlar, gelecek yılların kültürüne nüfuz edeceğinden emin olduğum bitmeyen kopyala yapıştırma içine gömülü olan gelecekteki F # kodlamasının temeli olacaktır.

Öyleyse ... F # 'nin tip çıkarımında, tutulması için değerli bir özellik haline getiren, sadece gerektiğinde not veren özel bir şey var mı? Veya uzman F # kullanıcıları, önemsiz olmayan uygulamalar için parametrelerini açıklama alışkanlığı yaratır mı?

F # kullanmıyorum, ancak Haskell'de, dil en yaygın türdeki çıkarımlara sahip olsa da (en azından) en üst seviye tanımları ve bazen de yerel tanımları açıklamak için iyi bir form olarak kabul ediliyor. Bunun birkaç nedeni var:

• Okuma
  Bir fonksiyonun nasıl kullanılacağını bilmek istediğinizde, imzanın mevcut olması inanılmaz derecede yararlıdır. Kendiniz çıkarmaya çalışmak veya sizin için yapacak araçlara güvenmek yerine, basitçe okuyabilirsiniz.

• Üstlenmeden
  bir fonksiyonu değiştirmek istediğinizde açık bir imzaya sahip olan, size dönüşümleri orijinal kod niyet korumak bazı güvence verir. Yazılı bir dilde, çok polimorfik kodun yazmayı denetleyeceğini ancak istediğiniz şeyi yapmamasını görebilirsiniz. Tip imzası, bir arayüzde tip bilgisini somutlayan bir “engeldir”.

• Performans
  Haskell'de, çıkarılan bir işlevin türü, çalışma zamanı gönderimini ifade edebilecek şekilde aşırı yüklenebilir (ön sınıf yoluyla). Sayısal türler için, varsayılan tür isteğe bağlı bir tamsayıdır. Bu özelliklerin tam genelliğine ihtiyacınız yoksa, işlevi ihtiyacınız olan türe göre özelleştirerek performansı artırabilirsiniz.

Yerel tanımlar, let-bound değişkenler ve lambdaların formal parametreleri için, bu tip imzaların genellikle kodda ekleyeceği değerden daha pahalı olduğunu buldum . Bu nedenle, kod incelemesinde, üst seviye tanımlamalar için imzalarda ısrar etmenizi ve başka bir yerde yalnızca makul açıklamalar istemenizi öneririm .

Jon, burada tekrar etmeyeceğim makul bir cevap verdi . Bununla birlikte, size gereksinimlerinizi karşılayabilecek bir seçenek göstereceğim ve bu süreçte evet / hayır dışında farklı bir cevap göreceksiniz.

Son zamanlarda, ayrıştırıcı birleştiricileri kullanarak ayrıştırma ile çalışıyorum. Ayrıştırmayı biliyorsanız, ilk aşamada bir lexer ve ikinci aşamada bir ayrıştırıcı kullanırsınız. Lexer metni belirteçlere, ayrıştırıcı belirteçleri AST'ye dönüştürür. Şimdi F # işlevsel bir dil ve birleştiriciler bir arada kullanılmak üzere tasarlandığında, ayrıştırıcı birleştiriciler, hem lexer hem de ayrıştırıcıda aynı işlevleri kullanmak üzere tasarlanmıştır, ancak ayrıştırıcı birleştirici işlevlerinin türünü ayarlarsanız, yalnızca bunları kullanmak için kullanabilirsiniz lex veya ayrıştırmak ve ikisini birden değil.

Örneğin:

/// Parser that requires a specific item.

// a (tok : 'a) : ('a list -> 'a * 'a list)                     // generic
// a (tok : string) : (string list -> string * string list)     // string
// a (tok : token)  : (token list  -> token  * token list)      // token

veya

/// Parses iterated left-associated binary operator.


// leftbin (prs : 'a -> 'b * 'c) (sep : 'c -> 'd * 'a) (cons : 'd -> 'b -> 'b -> 'b) (err : string) : ('a -> 'b * 'c)                                                                                    // generic
// leftbin (prs : string list -> string * string list) (sep : string list -> string * string list) (cons : string -> string -> string -> string) (err : string) : (string list -> string * string list)  // string
// leftbin (prs : token list  -> token  * token list)  (sep : token list  -> token  * token list)  (cons : token  -> token  -> token  -> token)  (err : string) : (token list  -> token  * token list)   // token

Kod telif hakkı olduğu için buraya dahil etmeyeceğim ancak Github'da mevcut . Buraya kopyalamayın.

İşlevlerin çalışması için, genel parametrelerle bırakılmalıdır, ancak işlev kullanımına bağlı olarak, çıkarılan türleri gösteren yorumlar eklerim. Bu, işlevi kullanım için genel bırakırken bakım işlevini anlamayı kolaylaştırır.

Hata sayısı, bir programdaki karakter sayısı ile doğru orantılıdır!

Bu genellikle kod satırlarıyla orantılı olan hataların sayısı olarak ifade edilir. Ancak aynı miktarda kod içeren daha az satır olması aynı miktarda hata verir.

Bu nedenle açık olmak güzel olsa da, yazdığınız tüm ek parametreler hatalara yol açabilir.