Yaygın Haskell operatörleri için belirgin isimler var mı? [kapalı]

Büyük İyilik için Haskell Öğrenin'i okuyorum ve Haskell operatörlerinin nasıl telaffuz edileceğini asla bilemiyorum. "Gerçek" isimleri var mı? ?

Örneğin, böyle bir ifadeyi yüksek sesle nasıl okursunuz?

Just (+3) <*> Just 9

Bunun >>="bağlama" olduğunu biliyorum , ama diğerleri ne olacak? Google alfasayısal olmayan karakterleri hesaba katmadığından, verimli bir arama yapmak biraz zor ...

Kendi operatörlerinizi oluşturabileceğinizin farkındayım, bu yüzden elbette tüm operatörlerin isimleri olmayabilir, ancak ortak olanların (örneğin Applicativeveya içinde tanımlananlar Monad) isimlere sahip olmasını bekliyorum ...

Onları nasıl telaffuz ederim:

>> = bağlama
>> sonra
*> sonra
->                 a -> b: a - b 
<- bağlama               (>> = olarak seçildiği gibi)
<$> (f) harita
<$ map-replace by     0 <$ f: "f map-replace 0" 
<*> ap (kat)            (Control.Monad.ap ile aynı olduğu gibi) 
$                          (yok, tıpkı "" [boşluk] gibi ) 
. bir boru            . b: "b" - "
!! indeks
! endeks / katı     a! b: "bir dizin b", foo! x: foo katı x 
<|> veya / alternatif   ifade <|> terim: "ifade veya terim"
++ concat / plus / append
[] boş liste
: Eksileri
:: type /       fx olarak :: Int: Int türü fx
\ lambda
@ as                 go ll @ (l: ls): l eksilerini l olarak git ~ 
tembel               git ~ (a, b): tembel çift git 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"                                      |

Kişisel favorilerim "sol balık" (<= <) ve "sağ balık" (> =>) . Monad operatörlerinin sadece sol ve sağ Kleisli bileşimi. Balık oluştur, oluştur!

Cevapları çok basit bir haskell programında bir araya getirme özgürlüğünü aldım, sadece desen eşleştirme yoluyla haskell kodunu ingilizceye çevirmeye çalışıyor. Ben diyorum letteratorçünkü sembolleri harflere çeviriyor

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