Alles * sonst * ähnlich wie Haskell's $ in F # außer <|?

Question

Ich weiß, dass es die Back-Pipe (<|)-Operator, in mehreren anderen SO-Antworten verwiesen. Aber das funktioniert nicht gut, wenn es mit den Vorwärtsleitungen (|>) kombiniert wird, die in der Verkettung üblich sind. Ich suche jedoch nach verwandten Optionen. Gibt es eine eingebaute Version der folgenden Funktionsdefinition? Oder ist das eine schlechte/gefährliche Übung?

let inline (^%) f = f 

let stuff = 
    [1;2;3] 
    |> Seq.filter ^% (>) 2 
    |> Seq.map ^% fun x -> x.ToString() 


// compare to this, which doesn't compile (and would be hard to follow even if it did) 
let stuff = 
    [1;2;3] 
    |> Seq.filter <| (>) 2 
    |> Seq.map <| fun x -> x.ToString() 

Answer 1

Es gibt einige Haskell Features wie optionale infixing mit Backticks und Abschnitte, die in F # nicht verfügbar sind. Das macht bestimmte Konstrukte etwas ausführlicher.

Normalerweise würde ich einfach ein Rohr von Funktionen wie die oben wie folgt schreiben:

let stuff = 
    [1;2;3] 
    |> Seq.filter (fun x -> x < 2) 
    |> Seq.map string 

Das ist, meiner Meinung nach, viel besser lesbar. Zum Beispiel mit Seq.filter ^% (>) 2, würde ich intuitiv lesen, dass ‚alle Werte größer als 2‘ dahin, aber das ist nicht das, was sie tut:

> let inline (^%) f = f;; 

val inline (^%) : f:'a -> 'a 

> let stuff = 
    [1;2;3] 
    |> Seq.filter ^% (>) 2 
    |> Seq.map ^% fun x -> x.ToString() 
    |> Seq.toList;; 

val stuff : string list = ["1"] 

Wenn Sie den Leser des Codes in Zweifel, was verlassen der Code tut, du hast gerade alle weniger produktiv gemacht. Die Verwendung von Seq.filter (fun x -> x < 2) kann ausführlicher aussehen, ist aber für den Leser eindeutig.