Expresando cadena larga de composiciones en Haskell

Question

(sin importancia fondo info/motivación)

I estaba ejecutando una versión diferente de nub, inspirado por el Yesod book's discouragement de usarlo.

map head . group . sort es más eficiente que una llamada a nub. Sin embargo, en nuestro caso, el orden es importante ...

Así que comencé a escribir un "mejor" como la versión sin importancia. Y terminé con esto:

mynub = unsort . map head . groupBy (\x y -> fst x == fst y) . sortBy (comparing fst) . rememberPosition 

rememberPosition = flip zip [0..] 
unsort = map fst . sortBy (comparing snd) 

Esto sin duda hace un montón de trabajo extra, pero debe ser O (n log n) en lugar de O del nudo originales (n). Pero eso está fuera del punto. El problema es es tan largo! Realmente no es tan complicado, pero es largo (y soy una de esas personas que odian ir más allá de 80 columnas, o barras de desplazamiento horizontales en bloques de código StackOverflow).

(la pregunta)

¿Cuáles son mejores formas en Haskell para expresar cadenas largas de la composición de funciones tales como esto?

Answer 1

romper la línea, y el uso de la disposición:

mynub = unsort 
     . map head 
     . groupBy ((==) `on` fst) 
     . sortBy (comparing fst) 
     . rememberPosition 

Answer 2

ancho de línea se resuelve fácilmente :)

> mynub = { unsort 
>   . map head 
>   . groupBy (\x y -> fst x == fst y) 
>   . sortBy (comparing fst) 
>   . rememberPosition 
>   } 

pero apenas estoy acostumbrado a leer la composición de derecha a izquierda. De arriba a abajo es un poco demasiado. (.) Flecha o (>>>) = flip parece más agradable para mí, pero no tengo ni idea de si sería idiomática

> mynub = { rememberPosition 
>  >>> sortBy (comparing fst) 
>  >>> groupBy (\x y -> fst x == fst y) 
>  >>> map head 
>  >>> unsort 
>   }