Esistono nomi pronunciabili per gli operatori Haskell comuni? [chiuso]

Sto leggendo Learn You a Haskell for Great Good e non so mai come pronunciare gli operatori Haskell. Hanno nomi "reali"? ?

Ad esempio, come leggi ad alta voce un'espressione come questa?

Just (+3) <*> Just 9

lo so >>= è "vincolante", ma per quanto riguarda gli altri? Poiché Google non tiene conto dei caratteri non alfanumerici, è difficile effettuare una ricerca efficiente ...

Mi rendo conto che puoi creare i tuoi operatori, quindi ovviamente non tutti gli operatori possono avere nomi, ma mi aspetto che quelli comuni (ad esempio quelli definiti in Applicativeo Monad) debbano avere nomi ...

Ecco come li pronuncio:

>> = bind
>> allora
*> allora
-> a                 a -> b: da a a 
<<bind               (come desugars a >> =)
<$> (f) mappa
<$ map-sostituisci con     0 <$ f: "f map-sostituisci con 0" 
<*> ap (ply)            (poiché è uguale a Control.Monad.ap) 
$                          (nessuno, proprio come "" [spazi bianchi] ) 
. pipe to            a. b: "b pipe-to a"
!! indice
! indice / rigoroso     a! b: "a indice b", pippo! x: pippo rigoroso x 
<|> o / termine alternativo   <|> termine: "termine o termine"
++ concat / plus / append
[] elenco vuoto
: cons
:: di tipo / come       fx :: Int: fx di tipo Int
\ lambda
@ as                 go ll @ (l: ls): go ll as l cons ls 
~ lazy               go ~ (a, b): go lazy pair 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"                                      |

I miei preferiti personali sono "pesce di sinistra" (<= <) e "pesce di destra" (> =>) . Quali sono solo la composizione Kleisli destra e sinistra degli operatori delle monadi. Componi pesce, componi!

Mi sono preso la libertà di riunire le risposte in un programma haskell molto semplice, che solo attraverso la corrispondenza dei modelli cerca di tradurre il codice haskell in inglese. Lo chiamo letteratorperché traduce i simboli in lettere

-- 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