มีชื่อที่ออกเสียงได้สำหรับตัวดำเนินการ Haskell ทั่วไปหรือไม่ [ปิด]

ฉันกำลังอ่านLearn You a Haskell เพื่อสิ่งที่ดีมากและฉันไม่เคยรู้วิธีออกเสียงผู้ใช้ Haskell พวกเขามีชื่อ "ของจริง" หรือไม่? ?

ตัวอย่างเช่นคุณอ่านออกเสียงนิพจน์เช่นนี้ได้อย่างไร

Just (+3) <*> Just 9

ฉันรู้ว่านั่น>>=คือ "ผูก" แต่แล้วคนอื่นล่ะ? เนื่องจาก Google ไม่คำนึงถึงตัวอักษรที่ไม่ใช่ตัวอักษรและตัวเลขจึงเป็นเรื่องยากที่จะทำการค้นหาที่มีประสิทธิภาพ ...

ฉันรู้ว่าคุณสามารถสร้างโอเปอเรเตอร์ของคุณเองได้ดังนั้นแน่นอนว่าโอเปอร์เรเตอร์อาจไม่มีชื่อทั้งหมด แต่ฉันคาดหวังว่าคนทั่วไป (เช่นที่กำหนดไว้ในApplicativeหรือMonad) ต้องมีชื่อ ...

นี่คือวิธีที่ฉันออกเสียงพวกเขา:

>> = ผูก
>> จากนั้น
*> จากนั้น
-> ถึง                 a -> b: a ถึง b 
<- ผูก               (ตามที่ desugars to >> =)
แผนที่ <$> (f)
<$ แผนที่แทนที่โดย     0 <$ f: "F แผนที่แทนที่โดย 0" 
<*> AP (เร่)            (มันเป็นเช่นเดียวกับ Control.Monad.ap) 
$                          (ไม่เพียงเท่านี้ "" [ช่องว่าง] ) 
. ท่อ           b: "b ไปป์ a"
!! ดัชนี
! ดัชนี / เข้มงวด     ! b: "ดัชนี a", foo! x: foo เข้มงวด x 
<|> หรือ / exprทางเลือก   <|> คำศัพท์: "expr หรือคำศัพท์"
++ concat / plus / append
[] รายการที่ว่างเปล่า
: ข้อเสีย
:: ของประเภท / as       fx :: Int: fx ของประเภท Int
แลมบ์ดา
@ as                 go ll @ (l: ls): ไปเช่นเดียวกับ l cons ls 
~ lazy               go ~ (a, b): go go จับคู่ขี้เกียจ 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"                                      |

โปรดส่วนตัวของฉันคือ "ปลาซ้าย" (<= <)และ "ปลาที่ถูกต้อง" (> =>) ซึ่งเป็นเพียงองค์ประกอบ Kleisli ด้านซ้ายและขวาของผู้ประกอบการพระ เขียนคาวเขียน!

ฉันใช้เสรีภาพในการรวบรวมคำตอบลงในโปรแกรม Haskell ที่ง่ายมากซึ่งผ่านการจับคู่รูปแบบเท่านั้นที่พยายามแปลรหัส Haskell เป็นภาษาอังกฤษ ฉันเรียกมันว่าletteratorเพราะมันแปลสัญลักษณ์เป็นตัวอักษร

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