Warum nicht Funktionsparameter mit Anmerkungen versehen?

Um diese Frage beantworten zu können, nehmen wir an, dass die Mehrdeutigkeit eines Programmierers viel teurer ist als ein paar zusätzliche Tastenanschläge.

Warum sollte ich meinen Teamkollegen gestatten, ihre Funktionsparameter nicht zu kommentieren? Nehmen Sie den folgenden Code als Beispiel für einen weitaus komplexeren Code:

let foo x y = x + y

Eine kurze Betrachtung des Tooltips zeigt Ihnen nun, dass Sie mit F # festgelegt haben, dass x und y Ints sein sollen. Wenn Sie das beabsichtigt haben, ist alles in Ordnung. Aber ich weiß nicht, ob Sie das beabsichtigt haben. Was wäre, wenn Sie diesen Code erstellt hätten, um zwei Zeichenfolgen miteinander zu verknüpfen? Oder was ist, wenn ich denke, dass Sie wahrscheinlich Doppel hinzufügen wollten? Oder was ist, wenn ich nicht mit der Maus über jeden einzelnen Funktionsparameter fahren möchte, um dessen Typ zu bestimmen?

Nun nimm dies als Beispiel:

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

F # geht nun davon aus, dass Sie wahrscheinlich beabsichtigt haben, Zeichenfolgen zu verketten. Daher werden x und y als Zeichenfolgen definiert. Als der arme Trottel, der Ihren Code verwaltet, könnte ich mir das ansehen und fragen, ob Sie vielleicht beabsichtigt haben, x und y (ints) zusammenzufügen und das Ergebnis dann zu UI-Zwecken an einen String anzuhängen.

Für solch einfache Beispiele könnte man es sicherlich loslassen, aber warum nicht eine Richtlinie mit expliziten Typanmerkungen erzwingen?

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

Was schadet es, eindeutig zu sein? Sicher, ein Programmierer könnte die falschen Typen für das auswählen, was er versucht, aber zumindest weiß ich, dass sie es beabsichtigt haben, dass es nicht nur ein Versehen war.

Dies ist eine ernste Frage ... Ich bin noch sehr neu in F # und ebne den Weg für meine Firma. Die Standards, die ich übernehme, werden wahrscheinlich die Grundlage für die gesamte zukünftige F # -Codierung sein, eingebettet in das endlose Kopieren, von dem ich sicher bin, dass es die Kultur für die kommenden Jahre durchdringen wird.

Also ... gibt es etwas Besonderes an der Typinferenz von F #, das es zu einer wertvollen Funktion macht, sie beizubehalten und nur dann zu kommentieren, wenn es nötig ist? Oder machen es sich Experten zur Gewohnheit, ihre Parameter für nicht-triviale Anwendungen zu kommentieren?

Ich verwende kein F #, aber in Haskell wird es als gute Form angesehen, (mindestens) Definitionen der obersten Ebene und manchmal auch lokale Definitionen zu kommentieren, obwohl die Sprache eine allgegenwärtige Typinferenz aufweist. Dies hat einige Gründe:

• Lesen
  Wenn Sie wissen möchten, wie eine Funktion verwendet wird, ist es unglaublich nützlich, die Typensignatur zur Verfügung zu haben. Sie können es einfach lesen, anstatt zu versuchen, es selbst abzuleiten oder sich auf Tools zu verlassen, die es für Sie erledigen.

• Refactoring
  Wenn Sie eine Funktion ändern möchten, können Sie durch eine explizite Signatur sicher sein, dass bei Ihren Transformationen die Absicht des ursprünglichen Codes erhalten bleibt. In einer vom Typ abgeleiteten Sprache werden Sie möglicherweise feststellen, dass stark polymorpher Code die Typprüfung durchführt, aber nicht das tut, was Sie beabsichtigt haben. Die Typensignatur ist eine „Barriere“, die Typinformationen an einer Schnittstelle konkretisiert.

• Leistung
  In Haskell kann der abgeleitete Typ einer Funktion (über Typklassen) überladen sein, was einen Laufzeitversand implizieren kann. Bei numerischen Typen ist der Standardtyp eine Ganzzahl mit beliebiger Genauigkeit. Wenn Sie diese Funktionen nicht vollständig benötigen, können Sie die Leistung verbessern, indem Sie die Funktion auf den gewünschten Typ spezialisieren.

Bei lokalen Definitionen, letgebundenen Variablen und formalen Parametern für Lambdas stelle ich fest, dass Typensignaturen im Code normalerweise mehr kosten als der Wert, den sie hinzufügen würden. Ich empfehle Ihnen daher, bei der Codeüberprüfung auf Signaturen für Definitionen der obersten Ebene zu bestehen und an anderer Stelle nur nach vernünftigen Anmerkungen zu fragen .

Jon gab eine vernünftige Antwort, die ich hier nicht wiederholen werde. Ich zeige Ihnen jedoch eine Option, die Ihre Anforderungen erfüllen könnte, und dabei wird eine andere Art von Antwort als Ja / Nein angezeigt.

In letzter Zeit habe ich mit Parsing mit Parser-Kombinatoren gearbeitet. Wenn Sie sich mit Parsing auskennen, wissen Sie, dass Sie in der ersten Phase in der Regel einen Lexer und in der zweiten Phase einen Parser verwenden. Der Lexer konvertiert Text in Token und der Parser konvertiert Token in einen AST. Jetzt, da F # eine funktionale Sprache ist und Kombinatoren kombiniert werden sollen, verwenden Parser-Kombinatoren die gleichen Funktionen sowohl im Lexer als auch im Parser. Wenn Sie jedoch den Typ für die Parser-Kombinator-Funktionen festlegen, können Sie diese nur verwenden lex oder zu analysieren und nicht beides.

Beispielsweise:

/// 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

oder

/// 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

Da der Code urheberrechtlich geschützt ist, werde ich ihn hier nicht einfügen, er ist jedoch bei Github erhältlich . Kopieren Sie es hier nicht.

Damit die Funktionen funktionieren, müssen sie mit den generischen Parametern belassen werden, aber ich füge Kommentare hinzu, die die abgeleiteten Typen in Abhängigkeit von den verwendeten Funktionen anzeigen. Dies macht es einfach, die Funktion für die Wartung zu verstehen, während die generische Funktion für die Verwendung belassen wird.

Die Anzahl der Fehler ist direkt proportional zur Anzahl der Zeichen in einem Programm!

Dies wird normalerweise als die Anzahl der Fehler angegeben, die proportional zu den Codezeilen sind. Wenn Sie jedoch weniger Zeilen mit der gleichen Codemenge haben, erhalten Sie die gleiche Anzahl an Fehlern.

Es ist zwar nett, explizit zu sein, aber alle zusätzlichen Parameter, die Sie eingeben, können zu Fehlern führen.