Có tên phát âm cho các nhà khai thác Haskell phổ biến? [đóng cửa]

Tôi đang đọc Learn You a Haskell for Great Good và tôi không bao giờ biết cách phát âm các toán tử Haskell. Họ có tên "thật" không? ?

Chẳng hạn, làm thế nào để bạn đọc to một biểu thức như thế này?

Just (+3) <*> Just 9

Tôi biết đó >>=là "ràng buộc", nhưng những người khác thì sao? Vì Google không tính đến các ký tự không phải là chữ và số, nên thật khó để thực hiện tìm kiếm hiệu quả ...

Tôi nhận ra rằng bạn có thể tạo các toán tử của riêng mình, vì vậy tất nhiên không phải tất cả các toán tử đều có thể có tên, nhưng tôi hy vọng rằng các toán tử chung (ví dụ: các toán tử được xác định trong Applicativehoặc Monad) phải có tên ...

Đây là cách tôi phát âm chúng:

>> = liên kết
>> sau đó
*> sau đó
-> to                 a -> b: a to b 
<- bind               (vì nó giải mã cho >> =)
Bản đồ <$> (f)
<$ map-thay thế bằng     0 <$ f: "f map-thay thế bằng 0" 
<*> ap (ply)            (vì nó giống như Control.Monad.ap) 
$                          (không, chỉ là "" [khoảng trắng] ) 
. ống đến            a. b: "b ống-to a"
!! mục lục
! chỉ số / nghiêm ngặt     a! b: "một chỉ số b", foo! x: foo nghiêm ngặt x 
<|> hoặc / expr thay thế   <|> hạn: "expr hoặc hạn"
++ concat / plus / chắp thêm
[] danh sách trống
: khuyết điểm
:: của loại / như       fx :: Int: fx của loại Int
\ lambda
@ as                 go ll @ (l: ls): go ll as l cons ls 
~ lazy               go ~ (a, b): đi đôi lười biếng 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"                                      |

Sở thích cá nhân của tôi là "cá trái" (<= <) và "cá phải" (> =>) . Đó chỉ là thành phần Kleisli trái và phải của các toán tử đơn nguyên. Sáng tác tanh, sáng tác!

Tôi đã tự do lắp ráp các câu trả lời vào một chương trình haskell rất đơn giản, mà chỉ thông qua việc khớp mẫu cố gắng dịch mã haskell sang tiếng Anh. Tôi gọi nó letteratorbởi vì nó dịch các ký hiệu thành các chữ cái

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