일반적인 Haskell 연산자에 대한 명확한 이름이 있습니까? [닫은]

나는 당신 에게 Great Good을위한 Haskell을 배우고 있으며, Haskell 연산자를 발음하는 법을 결코 모른다. "실제"이름이 있습니까? ?

예를 들어, 이런 식을 어떻게 소리내어 읽습니까?

Just (+3) <*> Just 9

나는 그것이 >>="바인드" 라는 것을 알고 있지만, 다른 사람들은 어떻습니까? Google은 영숫자가 아닌 문자를 고려하지 않기 때문에 효율적인 검색을 수행하기가 어렵습니다 ...

나는 당신이 자신의 연산자를 만들 수 있다는 것을 알고 있습니다. 물론 모든 연산자가 이름을 가질 수는 없지만 일반적인 연산자 (예 : Applicative또는에 정의 된 연산자 Monad)에는 이름이 있어야합니다 ...

내가 그들을 발음하는 방법은 다음과 같습니다.

>> = 바인드
>> 그때
*> 그런 다음
->에서                 a- > b : a에서 b 
<-바인드              
<$> (f) 맵
<$ map-replace by     0 <$ f : "f map-replace by 0" 
<*> ap (ply)            (Control.Monad.ap와 동일) 
$                          (없음, ""[공백]과 동일 ) 
. 에 파이프            . b : "b 파이프 투 a"
!! 인덱스
! 색인 / 엄격한     ! b : "인덱스 b", foo! x : foo strict x 
<|> 또는 대체   expr <|> 용어 : "expr 또는 term"
++ concat / plus / append
[] 빈 목록
: 단점
:: / 유형의       fx :: Int : 유형의 Int fx
람다
@ as                 go ll @ (l : ls) : l 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"                                      |

내가 가장 좋아하는 것은 "left fish" (<= <) 및 "right fish" (> =>) 입니다. 모나드 연산자의 왼쪽과 오른쪽 Kleisli 구성입니다. 비린내가 작곡하세요!

나는 패턴 매칭을 통해서만 하스켈 코드를 영어로 번역하려고 시도하는 매우 간단한 하스켈 프로그램으로 답을 모으기 위해 자유를 얻었습니다. 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