¿Hay nombres pronunciables para los operadores comunes de Haskell? [cerrado]

Estoy leyendo Learn You a Haskell for Great Good , y nunca sé cómo pronunciar los operadores de Haskell. ¿Tienen nombres "reales"? ?

Por ejemplo, ¿cómo se lee en voz alta una expresión como esta?

Just (+3) <*> Just 9

Sé que eso >>=es "obligatorio", pero ¿qué pasa con los demás? Como Google no tiene en cuenta caracteres no alfanuméricos, es difícil hacer una búsqueda eficiente ...

Me doy cuenta de que puede crear sus propios operadores, por lo que, por supuesto, no todos los operadores pueden tener nombres, pero espero que los comunes (por ejemplo, los definidos en Applicativeo Monad) deben tener nombres ...

Así es como los pronuncio:

>> = enlace
>> entonces
*> entonces
-> a                 a -> b: a a b 
<- bind               (como se desugará a >> =)
<$> (f) mapa
<$ map-replace by     0 <$ f: "f map-replace by 0" 
<*> ap (ply)            (ya que es lo mismo que Control.Monad.ap) 
$                          (none, as as as "" [whitespace] ) 
. tubería a            a. b: "b pipe-to a"
!! índice
! índice / estricto     a! b: "un índice b", foo! x: foo estricto x 
<|> o / alternative   expr <|> term: "expr o term"
++ concat / plus / append
[] lista vacía
: contras
:: de tipo / como       fx :: Int: fx de tipo Int
\ lambda
@ as                 go ll @ (l: ls): ir ll como l cons ls 
~ vago               ir ~ (a, b): ir vago par a, b

| sym  | pronunciation                                    |
|------|--------------------------------------------------|
| |    | "such that"                                      |
| <-   | "is drawn from"                                  |
| =    | "is defined to be" / "is defined as"             |
| ::   | "has type" / "of type" / "is of type"            |
| ->   | "a function that takes ... and returns a ..." /  |
|      |                          "function that maps" /  |
|      |                          "is a function from" /  |
|      |                                          "to"    |
| $    | "apply"                                          |
| _    | "whatever"                                       |
| !!   | "index"                                          |
| ++   | "concat"                                         |
| []   | "empty list"                                     |
| :    | "cons"                                           |
| \    | "lambda"                                         |
| =>   | "implies" / "then"                               |
| *>   | "then"                                           |
| <$>  | "fmap" / "dollar cyclops"                        |
| <$   | "map-replace by"                                 |
| <*>  | "ap" / "star cyclops"                            |
| .    | "pipe to" / "compose" / "dot"                    |
| <|>  | "or"                                             |
| @    | "as"                                             |
| ~    | "lazy"                                           |
| <=<  | "left fish"                                      |

Mis favoritos personales son "pez izquierdo" (<= <) y "pez derecho" (> =>) . Que son solo la composición izquierda y derecha de Kleisli de operadores de mónadas. Componer a pescado, componer!

Me tomé la libertad de reunir las respuestas en un programa haskell muy simple, que solo a través de la coincidencia de patrones intenta traducir el código haskell al inglés. Lo llamo letteratorporque traduce símbolos en letras

-- letterator

main = translateLn <$> getLine >>= putStrLn

translateLn :: String -> String
translateLn = unwords . map t . words

t :: String -> String -- t(ranslate)

-- historical accurate naming
t "=" = "is equal too" -- The Whetstone of Witte - Robert Recorde (1557)

-- proposed namings
-- src http://stackoverflow.com/a/7747115/1091457
t ">>=" = "bind"
t "*>"  = "then"
t "->"  = "to"                   -- a -> b: a to b
t "<$"  = "map-replace by"       --  0 <$ f: "f map-replace by 0"
t "<*>" = "ap(ply)"              --  (as it is the same as Control.Monad.ap)
t "!!"  = "index"
t "!"   = "index/strict"         --  a ! b: "a index b", foo !x: foo strict x
t "<|>" = "or/alternative"       -- expr <|> term: "expr or term"
t "[]"  = "empty list"
t ":"   = "cons"
t "\\"  = "lambda"
t "@"   = "as"                   -- go ll@(l:ls): go ll as l cons ls
t "~"   = "lazy"                 -- go ~(a,b): go lazy pair a, b
-- t ">>"  = "then"
-- t "<-"  = "bind"              -- (as it desugars to >>=)
-- t "<$>" = "(f)map"
-- t "$"   = ""                  -- (none, just as " " [whitespace])
-- t "."   = "pipe to"           -- a . b: "b pipe-to a"
-- t "++"  = "concat/plus/append" 
-- t "::"  = "ofType/as"         -- f x :: Int: f x of type Int

-- additional names
-- src http://stackoverflow.com/a/16801782/1091457
t "|"   = "such that"
t "<-"  = "is drawn from"
t "::"  = "is of type" 
t "_"   = "whatever"
t "++"  = "append"
t "=>"  = "implies"
t "."   = "compose"
t "<=<" = "left fish"
-- t "="   = "is defined as"
-- t "<$>" = "(f)map"

-- src http://stackoverflow.com/a/7747149/1091457
t "$"   = "of" 

-- src http://stackoverflow.com/questions/28471898/colloquial-terms-for-haskell-operators-e-g?noredirect=1&lq=1#comment45268311_28471898
t ">>"  = "sequence"
-- t "<$>" = "infix fmap"
-- t ">>=" = "bind"

--------------
-- Examples --
--------------

-- "(:) <$> Just 3 <*> Just [4]" 
-- meaning "Cons applied to just three applied to just list with one element four"
t "(:)"  = "Cons"
t "Just" = "just"
t "<$>"  = "applied to"
t "3"    = "three" -- this is might go a bit too far
t "[4]"  = "list with one element four" -- this one too, let's just see where this gets us

-- additional expressions to translate from
-- src http://stackoverflow.com/a/21322952/1091457
-- delete (0, 0) $ (,) <$> [-1..1] <*> [-1..1]
-- (,) <$> [-1..1] <*> [-1..1] & delete (0, 0)
-- liftA2 (,) [-1..1] [-1..1] & delete (0, 0)
t "(,)" = "tuple constructor"
t "&" = "then" -- flipped `$`

-- everything not matched until this point stays at it is
t x = x

+      plus
-      minus (OR negative OR negate for unary use)
*      multiply OR times
/      divide
.      dot OR compose
$      apply OR of