Czy istnieją wymawiane nazwy dla popularnych operatorów Haskell? [Zamknięte]


204

Czytam „ Naucz się Haskella dla wielkiego dobra” i nigdy nie wiem, jak wymówić operatorów Haskell. Czy mają „prawdziwe” imiona? ?

Na przykład, jak odczytujesz na głos takie wyrażenie?

Just (+3) <*> Just 9

Wiem, że >>=to „wiąże”, ale co z pozostałymi? Ponieważ Google nie bierze pod uwagę znaków niealfanumerycznych, trudno jest przeprowadzić wydajne wyszukiwanie ...

Zdaję sobie sprawę, że możesz tworzyć własne operatory, więc oczywiście nie wszyscy operatorzy mogą mieć nazwy, ale spodziewam się, że wspólne (np. Zdefiniowane w Applicativelub Monad) muszą mieć nazwy ...


To dobre pytanie i nie znam żadnych odpowiedzi. Być może potrzebujemy schematu nazewnictwa, a może autorzy bibliotek powinni podawać wymawiane nazwy jako część dokumentów Haddocka.
Paul Johnson,

3
Bardzo dobre pytanie. Zwykle czytam <*> jako „zastosuj”, a <$> jako „fmap”. Co do innych, nie mam pojęcia.
DuoSRX,

3
Czy to duplikat „Haskell: Jak się <*>wymawia?” ? Nawet jeśli nie jest, jego odpowiedzi prawdopodobnie warto sprawdzić.
Antal Spector-Zabusky

8
Sprawdź także stronę wiki Haskell dotyczącą wymowy . Jest niekompletny, ale istotny.
Antal Spector-Zabusky

3
()wymawia się jako jednostkę. Pewnego razu utknąłem przed widownią kilkuset funkcjonalnych programistów, którzy nie potrafili wymówić tego na slajdzie.
sigfpe

Odpowiedzi:


194

Oto jak je wymawiam:

>> = wiąż
>> następnie
*> następnie
-> do                 a -> b: od a do b 
<- wiązanie               (jak desagars do >> =)
Mapa <$> (f)
<$ map-replace by     0 <$ f: "f map-replace by 0" 
<*> ap (ply)            (ponieważ jest taki sam jak Control.Monad.ap) 
$                          (brak, tylko jako „” [białe spacje] ) 
. potok do            . b: „b-potok do”
!! indeks
! indeks / ścisłe     a! b: „indeks b”, foo! x: foo strict x 
<|> lub / alternatywny   wyraz <|> wyrażenie: „wyrażenie lub wyrażenie”
++ concat / plus / append
[] pusta lista
: Cons
:: typu / as       fx :: Int: fx typu Int
\ lambda
@ as                 go ll @ (l: ls): go ll as l cons ls 
~ lazy               go ~ (a, b): go leniwa para a, b

100
dla mnie (.)jest „komponować”.
luqui

47
Zazwyczaj raczej wymawiam (.)jako ofi ($)jako applied to: f . g . h $ xjest stąd czytany f of g of h applied to x. Ale rozumiem rozbieżności w tym punkcie widzenia!
Ptival,

39
Myślę, że wymawianie (.)jako „po” jest bardziej sensowne. Kompozycję można oznaczyć w dwóch kierunkach, a nazwanie jej „po” natychmiast wyjaśnia, jak to działa.

1
@Tinctorius, czy kompozycja jest wcześniejsza, czy wcześniejsza, zależy od punktu widzenia, który nie jest uniwersalny. Na przykład, const 42 . fix idczy naprawdę możemy powiedzieć, że const 42pojawia się „po” nieskończonej pętli?
luqui

7
Nazwałbym ++„append” zamiast concat, ponieważ concatjest to już coś w Haskell i jego użyteczność jest bardzo inna.
Benjamin Kovach

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

2
Dziękuję za odpowiedź. „dollar cyclop” rozśmieszył mnie :)
Thomas Levesque

9
Cyklop jest osobliwy, nie musisz upuszczać s . :)

1
Co <*? Czy jest tak rzadko używany, że nie ma wspólnej nazwy?
Dannyu NDos


8

Pozwoliłem sobie zebrać odpowiedzi w bardzo prosty program haskell, który tylko poprzez dopasowanie wzorców próbuje przetłumaczyć kod haskell na angielski. Nazywam to, letteratorponieważ tłumaczy symbole na litery

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

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

12
Te z nich są dość oczywiste ... Moje pytanie było o bardziej nietypowych, takich jak operatorzy <*>, >>...
Thomas Levesque

20
Dla pełności.
Thomas Eding,
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.