Comment prononcer «=>» comme utilisé dans les expressions lambda dans .Net

160

Je rencontre très rarement d'autres programmeurs!

Ma pensée quand j'ai vu le jeton pour la première fois était "implique que" puisque c'est ce qu'il lirait comme une preuve mathématique mais ce n'est clairement pas son sens.

Alors, comment dire ou lire "=>" comme dans: -

IEnumerable<Person> Adults = people.Where(p => p.Age > 16)

Ou y a-t-il même une manière convenue de le dire?

Christopher Edwards
la source
6
120 votes positifs sont assez remarquables pour une question fermée.
datps du
J'ai toujours tendance à prononcer est "implique" comme l'opérateur de même apparence en logique.
IllidanS4 veut que Monica revienne le

Réponses:

149

Je dis généralement «tel que» lors de la lecture de cet opérateur.

Dans votre exemple, p => p.Age> 16 se lit comme suit: "P, tel que p.Age est supérieur à 16".

En fait, j'ai posé cette question sur les forums officiels de pré-publication de linq, et Anders Hejlsberg a répondu en disant

Je lis généralement l'opérateur => comme "devient" ou "pour lequel". Par exemple,
Func f = x => x * 2;
Func test = c => c.City == "Londres";
se lit comme suit: "x devient x * 2" et "c pour lequel c.City est égal à Londres"

En ce qui concerne «va» - cela n'a jamais eu de sens pour moi. «p» ne va nulle part.

Dans le cas de la lecture de code à quelqu'un, par exemple au téléphone, tant qu'il est un autre programmeur C #, j'utiliserais simplement le mot «lambda» - c'est-à-dire «p lambda p dot age supérieur à seize."

Dans les commentaires, Steve Jessop a mentionné les `` cartes vers '' dans le cas des transformations - en prenant l'exemple d'Anders:

x => x * 2;

lirait

x correspond à x fois 2.

Cela semble beaucoup plus proche de l'intention réelle du code que de «devenir» dans ce cas.

Erik Forbes
la source
1
Ce n'est exact que lorsque le lambda est utilisé comme filtre.
Andru Luvisi
4
«Goes to» est un rendu moins gênant de «remplit le cadre de pile de»
Peter Wone
1
Je n'aime vraiment pas "x devient x * 2"; x est une entrée et reste le même partout. Le lire de cette façon ressemble à une opération d'affectation.
Germán
@Peter - hah, très vrai. =) @ Germán - J'ai tendance à être d'accord, même si je ne peux pas penser à un meilleur exemple de transformations. Peut-être «se transforme en»?
Erik Forbes
5
Je dirais "cartes à" dans ce cas. Il y a donc un léger risque que les gens pensent que vous parlez d'un conteneur, mais vous pouvez clarifier cela en expliquant la première fois que vous le dites, que ce que vous voulez dire est "l'opérateur lambda, vous savez, égal-signe-supérieur- que".
Steve Jessop
56

Depuis MSDN :

Toutes les expressions lambda utilisent l'opérateur lambda =>, qui est lu comme "va à".

Kent Boogaart
la source
7
Intéressant. Le plus intéressant est peut-être que c'était vrai pour la version VS2010 , mais les instructions ont été supprimées de la version VS2012 .
Blair Conrad
@BlairConrad - peut-être vrai lorsque vous avez écrit votre commentaire, mais il est maintenant disponible pour toutes les versions actuelles de VS.
cp.engr
Je ne vois plus les mots «va à» dans la documentation MSDN liée dans la réponse ci-dessus. Je me souviens vers 2010 d'un mentor qui m'avait dit que la fonction lambda devait être lue comme "va à" et c'est comme ça que je l'ai toujours lue. Trébucher sur cette question cependant, la lire comme «telle que» a plus de sens pour moi.
matt.fc
18

Lecture du code par téléphone

De Eric Lippert:

Personnellement, je dirais c => c + 1 comme "voir va voir plus un". Quelques variations que j'ai entendues:

Pour une projection, (Client c) => c. Nom: "le client voit devient voir le nom du point"

Pour un prédicat, (Customer c) => c.Age> 21: "customer see such that see dot age is greater than vingt-et-un"

Gulzar Nazim
la source
«Goes to» était la phrase que j'ai le plus entendue lorsque je travaillais dans les équipes LINQ.
DamienG
15

Je l'ai toujours appelé "l'opérateur wang" :-)

"p wang age de p supérieur à 16"

Aidos
la source
10
C'est Numberwang!
comichael
4
Tu dois me dire où ailleurs sur la planète on appelle ça "wang". J'ai eu un membre de l'équipe qui m'a dit que c'était un "wang" et le seul endroit sur internetz que chacun de nous puisse trouver est sur cette réponse.
Kristopher
1
@Wartickler Je viens d'Australie occidentale - je l'ai toujours appelé l'opérateur wang :-)
Aidos
7

J'ai vu des gens dire "Flèche".

Brian
la source
6
J'espère que c'est une blague.
Jacob Carpenter
Ce n'est pas - j'ai vu la même chose.
Erik Forbes
1
Je pense que les gens qui disent «flèche» veulent dire ceci: ->
Dour High Arch
6
Je n'ai jamais vu ça. Entendu, peut-être, mais pas vu.
ctacke
La flèche me semble raisonnable car elle voulait représenter le signe de la flèche du calcul lambda. J'ai entendu des universitaires l'appeler flèche ou flèche droite, j'ai vu du code Haskell sur des diapositives en latex avec l'opérateur -> changé en symbole de flèche.
Robert
7

J'utilise "va à" parce qu'un livre LINQ me l'a dit :)

CodeChef
la source
5

Que diriez-vous des "cartes vers"? Il est à la fois succinct et sans doute plus précis techniquement (c'est-à-dire pas de suggestion de changement d'état comme avec "va vers" ou "devient", pas de conflation d'un ensemble avec sa fonction caractéristique comme avec "tel que" ou "pour lequel") que le d'autres alternatives. Bien que s'il existe déjà une norme comme la page MSDN semble l'indiquer, vous devriez peut-être simplement y aller (au moins pour le code C #).

Max Strini
la source
3

"Maps to" est ma prononciation préférée. Mathématiquement parlant, une fonction "mappe" ses arguments sur sa valeur de retour (on pourrait même appeler la fonction un "mapping"), il me semble donc logique d'utiliser cette terminologie en programmation, notamment en programmation fonctionnelle (en particulier le calcul lambda) est très proche des mathématiques. C'est aussi plus neutre que "devient", "va vers", etc., car il ne suggère pas de changement d'état, comme mentionné sans contexte.

Will Vousden
la source
2

Je n'y ai pas beaucoup réfléchi, mais je dis simplement "à". Il est court et concis et implique que la variable est transmise à l'expression. Je suppose qu'il pourrait être confondu avec le chiffre 2 ("deux"), mais j'ai tendance à prononcer "to" plus comme "ta" quand je parle. Personne (qui connaît les lambdas, du moins) ne m'a jamais dit qu'ils pensaient que c'était ambigu ...

// "Func f equals x to x times two"
Func f = x=> x * 2;

// "Func test equals c to c dot City equals London"
Func test = c => c.City == "London"
Mark Brackett
la source
2

Ma réponse courte: "c 'lambda-de' e". Bien que je m'accroche à la «fonction« lambda »c» «e», je pense que lambda-of est le compromis œcuménique. L'analyse suit.

C'est une excellente question ne serait-ce que pour les réponses bizarres. La plupart des traductions ont d'autres significations que pour les expressions lambda, conduisant à des interprétations exotiques. En tant que vieux hacker d'expression lambda, j'ignore simplement la notation .NET et je la réécris comme lambda dans ma tête tout en souhaitant qu'ils aient fait presque n'importe quoi d'autre pour cela.


Pour raconter le code au téléphone, vous voulez que quelqu'un puisse écrire le code dans l'ordre. C'est un problème, bien sûr, mais lambda-arrow ou quelque chose est probablement le meilleur que vous puissiez obtenir, ou peut-être lambda-in, mais lambda-of est le plus précis.

Le problème est l'utilisation de l'infixe et comment nommer le tout et le rôle des parties gauche et droite avec quelque chose qui fonctionne lorsqu'il est prononcé à la place de l'infixe.

Cela peut être un problème trop contraint!


Je n'utiliserais pas «tel que» parce que cela implique que le côté droit est un prédicat que le côté gauche devrait satisfaire. C'est très différent de parler d'un côté droit dont le côté gauche a été abstrait en tant que paramètre fonctionnel. (La déclaration MSDN sur "Toutes les expressions lambda" est tout simplement offensante et inexacte.)

Il y a quelque chose qui cloche à propos de "va à" bien que cela puisse être aussi proche que possible. "Va vers" implique une transformation, mais il n'y a pas exactement une variable c qui va vers une expression dans c. L'abstraction d'une fonction est un peu insaisissable. Je pourrais m'y habituer, mais j'aspire toujours à quelque chose qui met l'accent sur l'abstraction de la variable.

Étant donné que le côté gauche est toujours un identifiant simple dans les cas utilisés jusqu'à présent [mais attendez les extensions qui peuvent confondre cela plus tard], je pense que pour "c => expression" je lirais "c" expression lambda-function " "'ou même" c' arg '"fonction" expression ". Dans le dernier cas, je pourrais alors dire des choses comme "b 'arg' c 'arg' 'fonction' expression".

Il vaudrait peut-être mieux indiquer encore plus clairement qu'une expression lambda est introduite et dire quelque chose comme "'arg' b 'arg' c 'fonction' expression".

Comprendre comment traduire tout cela dans d'autres langues est un exercice pour l'étudiant [; <).

Je m'inquiète toujours de "(b, c) => expression" et d'autres variantes qui pourraient apparaître si ce n'est déjà fait. Peut-être "'args' b, c 'expression de fonction'".


Après toutes ces réflexions, je remarque que je suis en train de traduire "c => e" par "'lambda' c 'fonction' e" et que le mappage à la forme exacte doit être compris par contexte: λc (e ), c => e, f f (c) = e, etc.

Je m'attends à ce que l'explication "passe-à" l'emporte simplement parce que c'est là qu'une majorité dominante va voir les expressions lambda pour la première fois. C'est dommage. Un bon compromis pourrait être "c ' lambda-of ' e"

orcmid
la source
1
«Je n'utiliserais pas« tel que »parce que cela implique que le côté droit est un prédicat» - quand il est utilisé comme prédicat, alors c'est une traduction valide, à moins que je ne vous comprenne mal.
Erik Forbes
2

Si vous imaginez une expression lambda comme la méthode anonyme qu'elle est, "va à" a un sens assez décent.

(n => n == String.Empty)

n "va à" l'expression n == String.Empty.

Il va à la méthode anonyme, vous n'avez donc pas besoin d'aller à la méthode dans le code!

Désolé.

Honnêtement, je n'aime pas utiliser "va à" dans ma tête, mais j'ai vu d'autres personnes dire que cela semblait bizarre, et j'ai pensé que je clarifierais cela.

Jonesopolis
la source
2

Outre l'acquisition de la portée précédente (toutes les variables et constantes qui sont dans la portée d'une ligne de code normale au point où une expression lambda se produit sont disponibles pour le code de l'expression), une expression lambda est essentiellement du sucre syntaxique pour une fonction en ligne.

La liste de valeurs à gauche de l'opérateur de production ("=>") contribue à la structure et au contenu du cadre de pile utilisé pour effectuer l'appel à cette fonction. Vous pourriez dire que la liste de valeurs contribue à la fois aux déclarations de paramètres et aux arguments passés; dans un code plus conventionnel, ceux-ci déterminent la structure et le contenu de la trame de pile utilisée pour faire l'appel à une fonction.

En conséquence, les valeurs «vont» au code de l'expression. Diriez-vous plutôt "définit le cadre de pile pour" ou "va à"? :)

Dans l'application étroitement définie d'expressions booléennes utilisées comme conditions de filtre (une utilisation dominante des expressions lambda largement considérée par d'autres réponses à cette question), il est très raisonnable de sauter la méthode en faveur de l'intention du code, ce qui conduit à " pour lequel «être tout aussi succinct et en dire plus sur le sens du code.

Cependant, les expressions lambda ne sont pas la seule province de Linq et en dehors de ce contexte, la forme plus générale «va à» devrait être utilisée.


Mais pourquoi «va»?

Parce que "remplit le cadre de pile du code suivant" est beaucoup trop long pour continuer à le dire. Je suppose que vous pourriez dire "est / sont transmis à".

Une différence cruciale entre les paramètres explicitement passés et les variables capturées (si je me souviens bien - corrigez-moi si je me trompe) est que les premiers sont passés par référence et les seconds par valeur.

Peter Wone
la source
1
Je ne vois pas exactement comment votre conclusion découle de votre discussion. D'un autre côté, je pense que caractériser => en termes de mise en œuvre (ou non) des fermetures n'est pas une bonne façon d'aborder la question qui est posée.
orcmid
Le premier paragraphe est trompeur. Les expressions Lambda sont des constructions de première classe. L'intégration de fonctions est une optimisation. Le dernier paragraphe l'est encore plus. Les variables liées dans une expression lambda (ce que vous appelez des «variables capturées») ne sont transmises nulle part. Ils sont encadrés et ajoutés en tant que partie de l'objet lambda. S'ils étaient adoptés, vous devrez les nommer à nouveau - pour mentionner une différence.
Neowizard
1

Une partie du problème est que vous pouvez le lire à haute voix différemment selon la façon dont il est structuré. C'est dommage que ce ne soit pas aussi joli ou aussi intégré que celui de ruby.

Tad Donaghe
la source
Comment dites-vous |? Identique à la pipe?
dtc
Difficile de trouver un guide à ce sujet, mais _why utilise «prendre chacun», c'est-à-dire People.each {| person | met person.name} devient "Avec les gens, prenez chaque personne et imprimez le nom"
Adam Lassek
1

En Ruby, ce même sybmol s'appelle «hashrocket», et j'ai entendu des programmeurs C # utiliser ce terme aussi (même si cela est faux).

Pharylone
la source
0

Mes deux centimes:

s => s.Age > 12 && s.Age < 20

"L'expression Lambda avec le paramètre s est { return s.Age > 12 && s.Age < 20;}"

J'aime ça parce que ça me rappelle d'où vient l'expression de lamdba

delegate(Student s) { return s.Age > 12 && s.Age < 20; };

=> est juste un raccourci pour que vous n'ayez pas à utiliser le mot-clé délégué et à inclure les informations de type car elles peuvent être déduites par le compilateur.

Allan
la source
0

Mon terme pour => appliqué aux exemples présentés résultat

'result = s => s.Age > 12 && s.Age < 20'

s où l'âge est supérieur à 12 et l'article inférieur à 20 ans

'result = x => x * 2'

x où x est multiplié par 2

'result = c => c.City == "London"'

c où c.city équivaut à "Londres"

'result = n => n == String.Empty'

n où n est une chaîne vide

Arthur
la source