Apakah ada nama yang bisa diucapkan untuk operator Haskell yang umum? [Tutup]

Saya membaca Learn You a Haskell for Great Good , dan saya tidak pernah tahu bagaimana cara mengucapkan operator Haskell. Apakah mereka memiliki nama "asli"? ?

Misalnya, bagaimana Anda membaca dengan keras ekspresi seperti ini?

Just (+3) <*> Just 9

Saya tahu itu >>="mengikat", tetapi bagaimana dengan yang lain? Karena Google tidak memasukkan karakter non-alfanumerik ke dalam akun, agak sulit untuk melakukan pencarian yang efisien ...

Saya menyadari Anda dapat membuat operator sendiri, jadi tentu saja tidak semua operator dapat memiliki nama, tetapi saya berharap yang umum (misalnya yang ditentukan dalam Applicativeatau Monad) harus memiliki nama ...

Inilah cara saya mengucapkannya:

>> = bind
>> lalu
*> lalu
-> to                 a -> b: a to b 
<- bind               (seperti keinginan untuk >> =)
<$> (f) peta
<$ map-replace by     0 <$ f: "f map-replace oleh 0" 
<*> ap (ply)            (karena sama dengan Control.Monad.ap) 
$                          (tidak ada, sama seperti "" [spasi] ) 
. pipa ke            a. b: "b pipe-to a"
!! indeks
! indeks / ketat     a! b: "indeks b", foo! x: foo ketat x 
<|> atau / expr alternatif   <|> istilah: "expr atau istilah"
++ concat / plus / append
[] daftar kosong
: kontra
:: bertipe / as       fx :: Int: fx bertipe 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"                                      |

Favorit pribadi saya adalah "ikan kiri" (<= <) dan "ikan kanan" (> =>) . Yang hanya komposisi Kleisli kiri dan kanan dari operator monads. Susun mencurigakan, buat komposisi!

Saya mengambil kebebasan untuk mengumpulkan jawaban ke dalam program haskell yang sangat sederhana, yang hanya melalui pencocokan pola mencoba menerjemahkan kode haskell ke dalam bahasa Inggris. Saya menyebutnya letteratorkarena menerjemahkan simbol menjadi huruf

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