Metodi di concatenamento da sinistra a destra in Haskell (opposto a destra a sinistra)

Question

Vengo dalla Scala. Così ho spesso fare cose come:

println((1 to 10).filter(_ < 3).map(x => x*x)) 

In Haskell, dopo ho scoperto che posso liberarmi di tutte le parentesi nidificate utilizzando $ e ., di recente ho trovato a scrivere:

putStrLn . show . map (**2) . filter (< 3) $ [1..10] 

Ora, questo funziona, ma il codice si legge da destra a sinistra e, a meno che non mi sposti in arabo, per me è difficile ragionare.

C'è qualche altro trucco che mi fa incatenare le funzioni da sinistra a destra? O questo è solo il modo idiomatico di Haskell?

Answer 1

Sfortunatamente, è il modo idiomatico di Haskell. Ma l'operatore & potrebbe fare quello che vuoi.

import Data.Function ((&)) 

[1..10] & filter (< 3) & map (**2) & show & putStrLn 

Sostanzialmente, (&) = flip ($). Allo stesso modo, Control.Arrow.(>>>) = flip (.)

UPDATE (6+ mesi dopo): Devo ammettere, questo problema è una grande fonte di frustrazione per me e mi sono state giocando con questo potenziale soluzione:

https://gist.github.com/obadz/9f322df8ba6c8a9767683d2f86af8589#file-directionalops-hs-L81

Answer 2

Perché non creare un nuovo operatore?

(#) :: a -> (a -> b) -> b 
(#) = flip id 

Ora si può semplicemente scrivere

[1..10] # filter (< 3) # map (**2) # show # putStrLn 

Questo è l'equivalente dell'operatore (&) da Data.Function.

Answer 3

Sì, è idiota Haskell. Non arabo, ma piuttosto matematico, derivato dalla sintassi per la composizione. Vedi anche Haskell composition (.) vs F#'s pipe forward operator (|>).

Eppure, anche in Haskell a volte preferisce scrivere le chiamate nella direzione opposta, e troverete un paio di librerie (per esempio Data.Function dal di base 4.8.0) che hanno definito

(&) = flip ($) 

in modo che puoi esprimere la tua chiamata come

[1..10] & filter (< 3) & map (**2) & show & putStrLn