Existem nomes pronunciáveis ​​para operadores comuns de Haskell? [fechadas]

Estou lendo Aprenda um Haskell para um grande bem , e nunca sei como pronunciar os operadores Haskell. Eles têm nomes "reais"? ?

Por exemplo, como você lê em voz alta uma expressão como esta?

Just (+3) <*> Just 9

Eu sei que >>=é "vincular", mas e os outros? Como o Google não leva em consideração caracteres não alfanuméricos, é difícil fazer uma pesquisa eficiente ...

Sei que você pode criar seus próprios operadores, portanto, é claro que nem todos os operadores podem ter nomes, mas espero que os mais comuns (por exemplo, aqueles definidos em Applicativeou Monad) devam ter nomes ...

Aqui está como eu os pronunciei:

>> = ligação
>> então
*> então
-> a                 a -> b: a a b 
<- bind               (como desugars para >> =)
mapa <$> (f)
<$ map-replace by     0 <$ f: "f map-replace by 0" 
<*> ap (ply)            (como é o mesmo que Control.Monad.ap) 
$                          (none, assim como "" [espaço em branco] ) 
. canalize para            a. b: "b canalizar para a"
!! índice
! índice / estrito     a! b: "um índice b", foo! x: foo estrito x 
<|> ou / alternativo   expr <|> term: "expr ou termo"
++ concat / plus / append
[] lista vazia
: contras
:: do tipo / como       fx :: Int: fx do tipo Int
\ lambda
@ como                 vai ll @ (l: ls): vai ll como eu contras ls 
~ vai preguiçoso               ~ (a, b): vai par preguiçoso 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"                                      |

Meus favoritos pessoais são "peixe esquerdo" (<= <) e "peixe direito" (> =>) . Quais são apenas a composição Kleisli esquerda e direita dos operadores de mônadas. Componha peixe, componha!

Tomei a liberdade de reunir as respostas em um programa haskell muito simples, que somente através da correspondência de padrões tenta traduzir o código haskell para o inglês. Eu chamo isso letteratorporque traduz símbolos em 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