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

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?

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.

Depuis MSDN :

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

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"

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

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

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

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

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 #).

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

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"

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

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.

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.

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.

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

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.

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