Gibt es aussprechbare Namen für gängige Haskell-Operatoren? [geschlossen]

Ich lese Learn You a Haskell for Great Good und weiß nie, wie man die Haskell-Operatoren ausspricht. Haben sie "echte" Namen? ?

Wie liest man zum Beispiel einen Ausdruck wie diesen vor?

Just (+3) <*> Just 9

Ich weiß, dass >>=das "binden" ist, aber was ist mit den anderen? Da Google nicht alphanumerische Zeichen nicht berücksichtigt, ist es schwierig, eine effiziente Suche durchzuführen ...

Mir ist klar, dass Sie Ihre eigenen Operatoren erstellen können, daher können natürlich nicht alle Operatoren Namen haben, aber ich gehe davon aus, dass die gemeinsamen (z. B. die in Applicativeoder definierten Monad) Namen haben müssen ...

So spreche ich sie aus:

>> = binden
>> dann
*> dann
-> zu                 a -> b: a zu b 
<- binden               (wie es zu >> = desugiert)
<$> (f) Karte
<$ map-replace by     0 <$ f: "f map-replace by 0" 
<*> ap (ply)            (wie es mit Control.Monad.ap identisch ist) 
$                          (keine, nur als "" [Leerzeichen] ) 
. Rohr zu            einem. b: "b Pipe-to-a"
!! Index
! Index / streng     a! b: "a index b", foo! x: foo strict x 
<|> oder / alternativer   Ausdruck <|> Begriff: "Ausdruck oder Begriff"
++ concat / plus / append
[] leere Liste
: Nachteile
:: vom Typ / als       fx :: Int: fx vom Typ Int
\ lambda
@ as                 go ll @ (l: ls): go ll as l cons ls 
~ faul               go ~ (a, b): go faul Paar 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"                                      |

Meine persönlichen Favoriten sind "linker Fisch" (<= <) und "rechter Fisch" (> =>) . Welches sind nur die linke und rechte Kleisli Zusammensetzung der Monaden Operatoren. Komponieren Sie fischig, komponieren Sie!

Ich habe mir erlaubt, die Antworten zu einem sehr einfachen Haskell-Programm zusammenzufassen, das nur durch Mustervergleich versucht, Haskell-Code ins Englische zu übersetzen. Ich nenne es, letteratorweil es Symbole in Buchstaben übersetzt

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