क्या आम हास्केल ऑपरेटरों के लिए उच्चारण करने योग्य नाम हैं? [बन्द है]

Question

मैं ग्रेट गुड के लिए लर्न यू हस्कल पढ़ रहा हूं , और मुझे कभी नहीं पता कि हास्केल ऑपरेटरों का उच्चारण कैसे करें। क्या उनके पास "वास्तविक" नाम हैं? ?

उदाहरण के लिए, आप इस तरह एक अभिव्यक्ति को जोर से कैसे पढ़ते हैं?

Just (+3) <*> Just 9

मुझे पता है कि >>="बाइंड" है, लेकिन दूसरों के बारे में क्या? चूंकि Google गैर-अल्फ़ान्यूमेरिक वर्णों को ध्यान में नहीं रखता है, इसलिए एक कुशल खोज करना कठिन है ...

मुझे लगता है कि आप अपने खुद के ऑपरेटर बना सकते हैं, इसलिए निश्चित रूप से सभी ऑपरेटरों के नाम नहीं हो सकते हैं, लेकिन मुझे उम्मीद है कि आम लोगों (उदाहरण के लिए Applicativeया उनमें परिभाषित Monad) के नाम होने चाहिए ...

Comments

यह एक अच्छा सवाल है, और मैं किसी भी जवाब के बारे में पता नहीं हूँ। शायद हमें नामकरण योजना की आवश्यकता है, या शायद पुस्तकालय लेखकों को हैडॉक डॉक्स के हिस्से के रूप में प्रशंसनीय नाम प्रदान करना चाहिए।

— पॉल जॉनसन

बहुत अच्छा सवाल है। आमतौर पर मैं <*> को "लागू करें" और <$> को "फ़ैप" के रूप में पढ़ता हूं। दूसरों के लिए मेरे पास कोई विचार नहीं है।

— डुओएसआरएक्स

क्या यह "हास्केल: कैसे <*>उच्चारण है?" ? यहां तक ​​कि अगर यह नहीं है, तो इसके जवाब शायद बाहर की जाँच के लायक हैं।

— एंटाल स्पेक्टर-जैबुस्की

इसके अलावा, उच्चारण पर हास्केल विकी का पेज देखें । यह अधूरा है, लेकिन प्रासंगिक है।

— एंटाल स्पेक्टर-ज़बूसकी

()उच्चारण इकाई है। एक बार मैंने अपने आप को सौ कार्यात्मक प्रोग्रामर के एक जोड़े के दर्शकों के सामने अटक पाया, न जाने कैसे अपनी स्लाइड पर।

— सिगफैप

Answer 1

यहाँ मैं उन्हें उच्चारण करता हूँ:

>> = बाँध
>> फिर
*> तब
-> से                 a -> b: a से b 
<- bind               (जैसा कि यह desugars से >> =) तक
<$> (एफ) नक्शा
<$ मैप-रिप्लेसमेंट     0 <$ f: "f मैप-रिप्लेस बाय 0" 
<*> एपी (प्लाई)            (जैसा कि यह Control.Monad.ap के समान है) 
$                          (कोई नहीं, बस "" [व्हाट्सएप] ) है 
। पाइप            ए। बी: "बी पाइप-टू"
!! सूची
! सूचकांक / सख्त     ! b: "a index b", foo! x: foo सख्त x 
<>> या / वैकल्पिक   expr <>> शब्द: "expr or term"
++ समवर्ती / प्लस / परिशिष्ट
[] खाली सूची
: विपक्ष
:: टाइप ऑफ / एफएक्स के रूप में       :: इंट: एफएक्स ऑफ टाइप इंट
\ lambda
@ as                 go ll @ (l: ls): go ll as l l ls 
~ lazy               go ~ (a, b): go lazy pair a, b

Comments

मेरे लिए, (.)"रचना" है।

— लुकी

मैं आमतौर पर नहीं बल्कि उच्चारण (.)के रूप में ofऔर ($)के रूप में applied to: f . g . h $ xइसलिए पढ़ा जाता है f of g of h applied to x। लेकिन मैं इस दृष्टिकोण में विचलन को समझता हूं!

— १२:२१

मुझे लगता है (.)कि "के बाद" के रूप में उच्चारण अधिक समझदार है। रचना को दो दिशाओं में निरूपित किया जा सकता है, और इसे कॉल करने के बाद "तुरंत" बताता है कि यह कैसे काम करता है।

@Tinctorius, चाहे रचना से पहले या बाद में एक बिंदु पर निर्भर करता है जो सार्वभौमिक नहीं है। उदाहरण के लिए, const 42 . fix idक्या हम वास्तव में कह सकते हैं कि const 42"अनंत लूप के बाद" आता है?

— ल्यूकी

मैं ++इसके बजाय "परिशिष्ट" कहूंगा concat, क्योंकि concatहास्केल में पहले से ही एक चीज है और यह उपयोगिता बहुत अलग है।

— बेंजामिन कोवाच

Answer 2

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

Comments

आपके उत्तर के लिए धन्यवाद। "डॉलर साइक्लोप" ने मुझे हँसाया :)

— थॉमस लेवेस्क ने

साइक्लोप्स एकवचन है, आपको एस ड्रॉप करने की आवश्यकता नहीं है । :)

किस बारे में <*? क्या इसका उपयोग शायद ही कभी किया जाता है कि इसका कोई सामान्य नाम नहीं है?

— डैनीउ एनडोस

Answer 3

मेरे व्यक्तिगत पसंदीदा "बाईं मछली" (<= <) और "सही मछली" (> =>) हैं । जो कि भिक्षुओं के संचालकों की सिर्फ बायीं और दाईं क्लीसली रचना हैं। मछलियों की रचना करो, रचना करो!

Comments

एक मछली, दो मछली, लाल मछली, नीली मछली!

— 4castle

Answer 4

मैंने उत्तर को एक बहुत ही सरल हैस्केल कार्यक्रम में इकट्ठा करने के लिए आज़ादी ले ली, कि केवल पैटर्न मिलान के माध्यम से अंग्रेजी में हैस्केल कोड का अनुवाद करने की कोशिश करता है। मैं इसे कहता हूं 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

Answer 5

+      plus
-      minus (OR negative OR negate for unary use)
*      multiply OR times
/      divide
.      dot OR compose
$      apply OR of

Comments

ये बहुत स्पष्ट हैं ... मेरा प्रश्न अधिक असामान्य ऑपरेटरों के बारे में था <*>, जैसे >>...

— थॉमस लेवेस्क

संपूर्णता के लिए।

— थॉमस ईडिंग