mexico - haskell online

:: a->(a-> b)-> operador b(Haskell)

Question

Escribiendo programas de Haskell me encontré con la necesidad de un operador como este.

(|>) :: a -> (a -> b) -> b
(|>) = flip ($)
infixl 0 |>

Creo que es útil cuando pegamos muchas funciones juntas.

tText cs = someFun cs   |>
           lines        |>
           map (drop 4) |>
           reverse

Lo prefiero sobre el . porque con |> el orden en que se aplican las funciones es el mismo que el orden en que se escriben las funciones.

tText'' cs = reverse      . 
            map (drop 4) . 
            lines        . 
            someFun $ cs

La pregunta es: ¿es esto ( |> ) algo que ya existe en Prelude / alguna otra biblioteca básica? Reimplementar cosas simples es algo tonto que me gustaría evitar.

Una búsqueda de Hoogle no ayudó. Lo más cercano que encontré fue >>> (Flechas), pero parece una exageración.

Answer 1

En cuanto a mi experiencia, no conozco ninguna de esas bibliotecas. Y si tal biblioteca existe, aconsejaría no usarla.

A menos que esté utilizando el paquete de lentes, sugeriría no usar operadores definidos externamente de ese tipo. (En el caso de ese paquete de lentes, realmente necesita y ya tiene un operador de este tipo).

En mi experiencia, IMHO y tal ...

En los casos en que la legibilidad mejora con una composición avanzada en contraste con la composición habitual (no solo cuando se trata de lentes), es beneficioso definir un operador especial en ese módulo o localmente a través de let o where . Para eso, tiendo a usar símbolos de unicode en lugar de combos ascii.

(·) = flip (.)
infixl 1 (·)

(§) = ($) -- left associative, no flip
infixl 0 (§)

Hace algunos años (cuando no había lentes), también pensé en definir mi propio módulo para estos. Pero luego crecí para usar ese módulo tan poco frecuente que tendía a reinventar la rueda de todos modos. Para tener estos operadores en una biblioteca puede incluso aumentar el esfuerzo de leer el código: el lector tiene que buscar los operadores que rara vez se utilizan. En ese caso, los operadores definidos localmente son mucho mejores.

Answer 2

La biblioteca de lens define este operador como & .

Answer 3

No, no hay nada en una biblioteca estándar que yo sepa. Hace muchos años, gran parte de mi código importó mi breve pero útil módulo Forwards :

> module Forwards where

> infixl 0 |>
> infixl 9 .>

> (|>) = flip ($)
> (.>) = flip (.)

Incluso usé el mismo nombre que tú!

En estos días no lo uso mucho; me acostumbré al orden que usa la composición de funciones.

Siéntase libre de usar sus propios atajos útiles.

También uso $ menos de lo que solía. Donde solia escribir

thing = this $ that arg $ an other $ it

Ahora escribo

thing = this . that arg . an other $ it

Answer 4

También puede definir (|>) como "id de flip", y entender por qué esto funciona es una gran lección sobre la inferencia de tipos mediante la unificación como se usa en Haskell.