Existe-t-il des noms prononçables pour les opérateurs Haskell courants? [fermé]


204

Je lis Learn You a Haskell for Great Good , et je ne sais jamais prononcer les opérateurs Haskell. Ont-ils de «vrais» noms? ?

Par exemple, comment lisez-vous à haute voix une expression comme celle-ci?

Just (+3) <*> Just 9

Je sais que >>=c'est "lier", mais qu'en est-il des autres? Étant donné que Google ne prend pas en compte les caractères non alphanumériques, il est difficile de faire une recherche efficace ...

Je me rends compte que vous pouvez créer vos propres opérateurs, donc bien sûr, tous les opérateurs ne peuvent pas avoir de noms, mais je m'attends à ce que les opérateurs communs (par exemple ceux définis dans Applicativeou Monad) doivent avoir des noms ...


C'est une bonne question, et je ne connais aucune réponse. Peut-être que nous avons besoin d'un schéma de nommage, ou peut-être que les auteurs de bibliothèques devraient fournir des noms prononçables dans le cadre des documents Haddock.
Paul Johnson,

3
Très bonne question. Habituellement, je lis <*> comme "appliquer" et <$> comme "fmap". Quant aux autres je n'en ai aucune idée.
DuoSRX

3
S'agit-il d'un doublon de "Haskell: comment est-il <*>prononcé?" ? Même si ce n'est pas le cas, ses réponses méritent probablement d'être vérifiées.
Antal Spector-Zabusky

8
Consultez également la page du wiki Haskell sur la prononciation . C'est incomplet, mais pertinent.
Antal Spector-Zabusky

3
()est l'unité prononcée. Une fois, je me suis retrouvé coincé devant un public de quelques centaines de programmeurs fonctionnels ne sachant pas comment prononcer cela sur ma diapositive.
sigfpe

Réponses:


194

Voici comment je les prononce:

>> = lier
>> puis
*> puis
-> à                 a -> b: a à b 
<- lier               (comme il désugar à >> =)
<$> (f) carte
<$ map-replace by     0 <$ f: "f map-replace by 0" 
<*> ap (ply)            (car c'est la même chose que Control.Monad.ap) 
$                          (none, just as "" [whitespace] ) 
. tuyau à            un. b: "b pipe-to a"
!! indice
! index / strict     a! b: "un index b", foo! x: foo strict x 
<|> ou / alternative   expr <|> terme: "expr ou terme"
++ concat / plus / append
[] liste vide
: les inconvénients
:: de type / comme       fx :: Int: fx de type Int
\ lambda
@ as                 go ll @ (l: ls): go ll as l cons ls 
~ lazy               go ~ (a, b): go lazy pair a, b

100
pour moi, (.)c'est "composer".
luqui

47
Je prononce plutôt au (.)fur ofet à ($)mesure applied to: f . g . h $ xest donc lu f of g of h applied to x. Mais je comprends la divergence dans ce point de vue!
Ptival

39
Je pense que prononcer (.)comme "après" est plus sensé. La composition peut être indiquée dans deux directions, et l'appeler "après" explique immédiatement comment cela fonctionne aussi.

1
@Tinctorius, que la composition soit postérieure ou antérieure dépend d'un point de vue qui n'est pas universel. Par exemple, dans const 42 . fix id, peut-on vraiment dire const 42vient "après" une boucle infinie?
luqui

7
J'appellerais ++"ajouter" au lieu de concat, car concatc'est déjà quelque chose dans Haskell et son utilité est très différente.
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
Merci pour votre réponse. "dollar cyclop" m'a fait rire :)
Thomas Levesque

9
Cyclope est singulier, vous n'avez pas besoin de laisser tomber le s . :)

1
Et alors <*? Est-il si rarement utilisé qu'il n'a pas de nom commun?
Dannyu NDos


8

J'ai pris la liberté d'assembler les réponses dans un programme haskell très simple, que seule la correspondance de motifs essaie de traduire le code haskell en anglais. Je l'appelle letteratorparce qu'il traduit des symboles en lettres

-- 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
Celles-ci sont assez évidentes ... Ma question portait sur les opérateurs plus inhabituels comme <*>, >>...
Thomas Levesque

20
Pour être complet.
Thomas Eding
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.