Qualcosa * altro * simile a $ in F # di Haskell diverso da <|?

Question

So che c'è l'operatore (<|) di ritorno, a cui si fa riferimento in diverse altre risposte SO. Ma questo non funziona bene se combinato con i tubi anteriori (|>), che è comune nel concatenamento. Comunque sto cercando le opzioni correlate. Fondamentalmente esiste una versione integrata della definizione della funzione sottostante? O è una pratica cattiva/pericolosa?

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

ci sono alcune caratteristiche Haskell, come optional infissione utilizzando apici inversi, e sezioni, che non sono disponibili in F #. Ciò rende alcuni costrutti un po 'più prolissi.

Di solito, mi piacerebbe scrivere semplicemente un tubo di funzioni come sopra in questo modo:

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

Questa è, a mio parere, molto più leggibile. Ad esempio, utilizzando Seq.filter ^% (>) 2, avevo intuitivamente letto che nel senso 'tutti i valori superiori a 2', ma non è ciò che fa:

> 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"] 

Se si lascia il lettore del codice in dubbio di ciò che il codice sì, hai reso tutti meno produttivi. L'utilizzo di Seq.filter (fun x -> x < 2) potrebbe sembrare più dettagliato, ma non è ambiguo per il lettore.