Un modo per "aprire Seq" o un effetto simile?

Question

a 
|>Seq.map fixLine 
|>Seq.map splitCells 
|>Seq.map getName 
|>Seq.where(fun a->not<|Seq.isEmpty a) 
|>Seq.map fixName 

Trovalo sempre fastidioso mentre tieni un sacco di Seq. in linee. Suggerisci un buon modo per omettere loro ...

Ad esempio, utilizzare List.map per gli elenchi, utilizzare solo map per ss, o dividerli in diversi moduli quando sto usando seguenti e liste.

a 
|>map fixLine 
|>map splitCells 
|>map getName 
|>where(fun a->not<|isEmpty a) 
|>map fixName 

Sembra davvero meglio.

Answer 1

Si potrebbe anche solo definire alias per le funzioni desiderate:

let map = Seq.map 
let where = Seq.filter 

Oppure potrebbe rendere ancora più conciso definendo i tuoi operatori:

let (|!>) s f = Seq.map f s 
let (|*>) s f = Seq.filter f s 

a 
|!> fixLine 
|!> splitCells 
|!> getName 
|*> (fun a->not<|isEmpty a) 
|!> fixName 

Ma a questo punto, il tuo codice diventa troppo criptico - ad esempio qualcuno che guarda il codice avrà difficoltà a capire cosa sta succedendo.

E, infine, si potrebbe creare il codice originale aspetto un po 'meglio per accorgersi che una composizione di map s è un map di composizione:

a 
|> Seq.map (fixLine >> splitCells >> getName) 
|> Seq.filter (not << isEmpty) 
|> Seq.map fixName 

Questa è la soluzione che personalmente preferirei.

---

In generale, la mia esperienza personale dimostra che, nonostante il primo impulso a "fissare" la ripetitività, rendendo le parti ripetitive stessi più piccoli, c'è solito una soluzione migliore che renderebbe il codice non solo guardare meglio, ma meglio fattorizzato.

Answer 2

Non penso che ci sia un modo semplice per evitare di ripetere il Seq - questo è solo un posto dove F # rende le cose un po 'più esplicite (in modo da sapere cosa sta succedendo).

Ma è possibile utilizzare la F# Core Fluent library che ti dà una C# -come sintassi più con .:

a.map(fixLine).map(splitCells).map(getName).filter(isEmpty >> not).map(fixName)