Julia: Renommer `shift!` et `unshift!` ?

Nous pourrions renommer en gros ces fonctions :

| vieux | nouveau |
|-----|-----|
| push! | rpush! |
| pop! | rpop! |
| unshift! | lpush! |
| shift! | lpop! |

Ou un mot-clé gauche/droite (début/fin ? premier/dernier ?) si les problèmes de performances pouvaient être résolus

La gauche et la droite semblent un peu ambiguës ; peut-être que le recto/verso de @c42f ou quelque chose de similaire serait plus clair ?

Je ne suis pas sûr que l'avant et l'arrière soient plus clairs qu'à gauche et à droite. Bien sûr, pour la terminologie gauche/droite, il est un peu dommage que nous imprimions les vecteurs verticalement, mais avant/arrière ne sont pas meilleurs à cet égard.

Oh, et nous utilisons déjà l et r pour les

Je ne suis pas sûr que l'avant et l'arrière soient plus clairs qu'à gauche et à droite.

Je ne suis pas sûr non plus. front s'associe avec des indices inférieurs (comme Base.front ) et back avec des indices plus élevés dans mon esprit, mais je suis sûr que ce type d'association varie.

Peut-être de meilleures idées : head - tail et first - last semblent nettement moins ambigus étant donné leurs significations préexistantes ?

Les noms hpush! , hpop! , tpush! et tpop! ne sont pas mauvais. Cependant, nous associons déjà la gauche et la droite à l'ordre des tableaux dans foldl et foldr , etc. En fait, puisque ceux-ci ont les l et r au fin, les noms analogues sont pushl! , popl! , pushr! et popr! que j'apprécie en quelque sorte :)

Parmi les options disponibles jusqu'à présent pour renommer les quatre fonctions, les versions suffixées pushl! , popl! , pushr! et popr! me semblent les meilleures.

J'ai quelques réserves quant à renommer push! et pop! . Par exemple, envisagez de pousser et d'accéder à une file d'attente prioritaire. Dans ce cas, il n'y a pas de "droite" et de "gauche", il n'y a qu'un ordre naturel et une structure de données qui renvoie l'élément le plus petit/le plus grand. Il existe également la version de pop! qui utilise une clé pour une utilisation avec des structures de données de type dictionnaire, et popr! n'aurait pas non plus beaucoup de sens en tant que verbe dans ce cas.

Je pense que push! et pop! peuvent rester et être utilisés par PriorityQueues. Ils peuvent également simplement créer des alias pushr! et popr! pour les tableaux.

J'adore shift! & unshift! , c'est la même chose avec javascript. s'il vous plaît réserver ceci!

Jusqu'à présent, j'aime le mieux la suggestion du premier post.

Je pense qu'il est bon d'utiliser les noms push*! et pop*! pour souligner la similitude entre les variantes, et pour que les variantes puissent être trouvées facilement en complétant les tabulations. (J'aime la suggestion de suffixe r et l .)

-2 à la terminologie r et l . Les noms sont un peu moches, et il y en a 4. Je préférerais seulement renommer shift et unshift comme le suggère l'OP. Mais je pense aussi que shift et unshift sont suffisamment utilisés pour que nous puissions tout aussi bien les garder. Il serait malheureux d'introduire des termes que personne d' autre n'utilise pour des opérations aussi incroyablement courantes.

Le vecteur push_front , il existe donc un précédent pour cela.

Je suppose que les noms existants peuvent être retracés jusqu'au shift intégré dans sh , et perl l'a probablement repris et a inventé unshift (http://www.perlmonks.org /?node_id=613144) D'autres langues (php, javascript, ...?) ont suivi, il y a donc beaucoup de précédents.

Je préfère les mots anglais corrects... :) ( unshift est dans l'OED datant de 1972.)

ou au moins mentionner shift! & unshift! dans la doc de pop! & push! :

help?> pop!
search: pop! popdisplay apropos deepcopy precompile __precompile__ peakflops promote_type
also see: `shift!` `unshift!` `push!`

  pop!(collection, key[, default])

  Delete and return the mapping for key if it exists in collection, otherwise return default, or
  throw an error if default is not specified. 

Une autre idée : push/pop!(first, x, ...) et push/pop!(last, x, ...) .

Théoriquement, cette syntaxe se généralise bien à des choses comme pop!(min, x) .

ou au moins mentionner shift! & unshift! dans la doc de pop! & push! :

Lié au #23789

Super idée, @TotalVerb !

Ou fusionner avec splice! / insert! , avec first et last comme pseudo-indices ?

Autre idée : push/pop !(first, x, ...)

Ah quoi ? Ok, c'est une idée vraiment créative :-)

Il semble assez étrange d'utiliser les fonctions first et last uniquement comme syntaxe, plutôt que d'avoir quoi que ce soit à voir avec le code réel qu'elles contiennent. C'est plutôt bien, mais je ne suis pas sûr que ce genre de chose devrait être encouragé dans l'écosystème car cela peut conduire à des enchevêtrements étranges ? Par exemple, si jamais vous vouliez renommer des fonctions qui étaient utilisées comme syntaxe, que faire alors ? Certes pas du tout probable pour first et last , mais quand même.

Je dois dire qu'aussi cool que soit cette idée – cela me rappelle l'idée de X[mean, :, sum] – je pense que c'est trop sophistiqué pour une opération aussi fondamentale. Je suppose que les options que je suis en faveur à ce stade sont:

1. Laissez les choses telles qu'elles sont - si "shift" et "unshift" le sont, elles sont assez standard.
2. Renommez shift! et unshift! en popl! et pushl! .
3. En plus de 2, renommez pop! et push! en popr! et pushr! .
4. En plus de 3, créez des alias pop! et push! pour popr! et pushr! .

Je suis en grande partie entre 1 et 2, mais il y a aussi un certain attrait pour 3 et 4.

Je pense que 1) il est tout à fait logique que l'application de la même opération (pousser ou sauter) au début et à la fin d'un tableau ait au moins des noms connexes ; push! et shift! forment une paire peu intuitive ; 2) le mot shift! peut être confondu avec le décalage de bits >> , comme on peut facilement le voir en recherchant "shift" dans la documentation ; 3) de nombreux utilisateurs de Julia n'auront pas de fond perl/javascript de toute façon.
Je suis donc en faveur de l'option 2 dans le post ci-dessus.
Mais, si on les renomme, que faire des circshift! ?

L'option 2 ou 4 de Stefan me semble bonne. Je ne pense pas que circshift! doive changer, car ce n'est pas une opération de type pop

Proposition:

| vieux | nouveau | alias |
|----:|----:|----:|
| push! | pushr! | push! |
| pop! | popr! | pop! |
| unshift! | pushl! | |
| shift! | popl! | |

Je dois dire que c'est tentant, surtout si nous gardons push! et pop! comme alias pour les cas où vous utilisez uniquement une structure en tant que pile et ne vous souciez pas vraiment de savoir si c'est la gauche ou à droite vous poussez et sautez de.

Imo utilisant front et back est (nettement) plus clair que l'abréviation de left et right .

D'autant plus que nos vecteurs sont verticaux (donc ça devrait être haut/bas) 🙂. D'autres options peuvent être début/fin ou premier/dernier.

gauche/droite me semble bien ; c'est cohérent avec notre terminologie de réduction ( foldl et foldr ), et avec la façon dont les vecteurs sont généralement entrés [a,b,c,…] et sortis par print .

L'autre bonne chose à propos de gauche/droite est qu'il a une abréviation à un caractère bien établie.

Sérieusement, je ne sais pas quelle extrémité d'un vecteur est l'avant ou l'arrière. L'index avant est-il 1 ou est-ce l'arrière ? Oui, nous imprimons parfois nos vecteurs verticalement, mais nous les imprimons également de gauche à droite dans d'autres cas. Nous utilisons déjà systématiquement les noms hérités gauche/droite pour de nombreuses autres fonctions.

Que diriez-vous d'avoir simplement de nouvelles méthodes pour l'ajout ! et en tête ! où le deuxième argument est un scalaire ?

Cette conversation est revenue à https://github.com/JuliaLang/julia/issues/23902#issuecomment-332615200, qui à son tour invite à nouveau https://github.com/JuliaLang/julia/issues/23902#issuecomment-332668546 , c'est-à-dire soit head / tail ou first / last terminologie ? :)

Oups, désolé d'avoir prolongé la discussion. Mon point était que plutôt que d'inventer de nouveaux mots, nous devrions réutiliser ceux qui existent déjà.

Oups, désolé d'avoir prolongé la discussion. Mon point était que plutôt que d'inventer de nouveaux mots, nous devrions réutiliser ceux qui existent déjà.

Désolé @phaverty ! Nous avons simulé. Ma réponse était censée suivre celle de @StefanKarpinski , plutôt que de commenter votre commentaire :). Meilleur!

Je préfère les popfirst! , pushfirst! , poplast! , pushlast! avec pop! et push! comme alias pour les deux dernier.

où le deuxième argument est un scalaire ?

Il n'est pas possible de définir un scalaire de manière générique.

"Il n'est pas possible de définir le scalaire de manière générique."

Ah, je vois. Vous pourriez spécifier, disons,

ajouter !( x::Vector{T}, y::T )

, mais vous voulez vraiment que y soit "quelque chose qui puisse être converti en T". Mais, le système de types ne sait pas (encore ?) quel ensemble de types peut être converti. Dommage.

Faisons un vote (non contraignant, informatif) :

• 👍 pour pushr! , popr! , pushl! et popl! avec push! et pop! comme alias pour les deux premiers
• pour garder les choses telles qu'elles sont
• pour une autre option

Ce choix d'emoji est quelque peu biaisé ;).

Et :+1: sur la suggestion d'OPs si tu préfères ça ;)

J'ai quelques réflexions sur le renommage de ces fonctions, je vais donc m'excuser d'avance pour avoir éventuellement ajouté du bruit à cette conversation. Jusqu'à présent, les noms de Julia des fonctions push! , pop! , shift! et unshift! sont les mêmes que Perl, Ruby et JavaScript (https://en .wikipedia.org/wiki/Double-ended_queue#Operations). Personnellement, ces noms ne me dérangent pas car je les ai appris à l'origine en Perl, mais j'admets pleinement que shift/unshift ne sont pas mémorables. Il semble également y avoir un camp qui pense que le push/pop est une mauvaise paire complémentaire .

Une autre idée : push/pop!(first, x, ...) et push/pop!(last, x, ...) .

Si nous devions aller dans cette direction, je suggérerais que nous utilisions enqueue! et dequeue! comme noms de ces fonctions.

Ce que j'aime dans les noms originaux, c'est qu'ils n'utilisent qu'un seul mot. En essayant de garder un mot mais de faire des associations plus agréables, j'ai trouvé push! et pull! pour FIFO et push! et pop! pour FILO. Cela ferait fonctionner push/pop au début d'une file d'attente au lieu de la fin :

Vieux | Nouveau
-------|-----
pousser! | mettre!
pop! | tirer!
décalage! | pousser!
décaler ! | pop!

Nous pourrions laisser push/pop à la fin et déplacer put/pull au début pour être moins cassant, mais je pense que cela laisserait les choses quelque peu confuses.

Une autre alternative consiste à utiliser append! et prepend! pour désigner respectivement push! et shift! . Cependant, je n'ai pas de mots raisonnables pour retirer la file d'attente et behead et curtail étaient les meilleurs que j'ai pu trouver...

@phaverty Tant qu'il est possible d'avoir un Vector{Any} , ce sera ambigu.

Je vais republier ceci : https://github.com/JuliaLang/julia/issues/23902#issuecomment -332919287

@omus Renommer shift! en push! semble inutilement déroutant.

append! opère sur deux collections, tandis que push! et. Al. fonctionne sur un élément, donc IMO ce nom ne peut tout simplement pas être utilisé ici.

Enfin, nous pourrions toujours adopter l'unicode et utiliser quelque chose comme :

ASCII | Unicode | Nom Unicode | Alias
---|---|---|---
pousser! | | flèche vers la gauche vers la barre |
pop! | | flèche vers la droite depuis la barre | cartesvers
décalage! | | flèche vers la droite vers la barre |
décaler ! | | flèche vers la droite depuis la barre | cartes de

Considérez la barre dans l'unicode comme la file d'attente. ~Malheureusement, ces caractères Unicode n'ont pas de jolis alias dans le REPL d'après ce que je peux dire~.

Renommer shift! en push! semble inutilement déroutant.

Honnêtement, je serais mécontent si nous prenions réellement cette approche. Cette approche essaie certainement d'être gentille avec les nouveaux arrivants et vraiment méchante avec les utilisateurs existants de Julia.

@omus , par exemple ↦ est \mapsto .

Ok, j'ai menti : j'ai encore une chose à dire. Comme une suggestion plus sérieuse est que nous pourrions aller avec cette approche. Il perd le joli push/pop mais est beaucoup plus clair quant à l'opération en cours :

Vieux | Nouveau
-- | --
pousser! | dernier !
pop! | dernier sorti!
décalage! | premier arrivé!
décaler ! | premier sorti !

N'hésitez pas à voter contre la plupart de ces suggestions. Après avoir fait quelques recherches sur ce sujet, la seule vraie conclusion à laquelle je suis arrivé est que les informaticiens ont adopté la terminologie push/pop et n'avaient aucune idée de ce qu'il fallait nommer shift/unshift.

Maintenant que nous avons un repliement constant, les arguments de mots clés pour cela devraient être rapides, n'est-ce pas ? Je ne comprends pas pourquoi nous aurions 4 fonctions pour cela au lieu de 2, d'autant plus que les fonctions multi-mots sont spécifiquement déconseillées pour promouvoir le refactoring.

Aussi divertissant que cela soit, il semble que nous ne puissions pas faire mieux que le statu quo ici.

Aussi divertissant que cela soit, il semble que nous ne puissions pas faire mieux que le statu quo ici.

Le montant du soutien au PO semble-t-il substantiel ? Peut-être que fermer ce problème est un peu prématuré ? :)

Oui, la suggestion de l'OP a 11 en haut et 0 en bas ...

J'ai interprété ceux-ci comme un soutien à la notion générale de changement de nom, pas à cette suggestion spécifique.

Il est clair pour moi qu'après toute cette discussion, nous n'avons pas trouvé d'alternative vraiment convaincante.

FWIW pushfront! est toujours mon préféré et un changement de nom intéressant à mon avis, mais c'est peut-être mon parti pris C++.

J'aime pushfront! et popfront! .

Eh bien, j'ai fait un PR dans #25100 pour utiliser pushfront! / popfront! car je pense que c'est la chose minimale que nous pouvons faire pour renommer unshift! . Vraiment la seule chose que unshift! a pour lui est (a) c'est le statu quo, et (b) il a un précédent dans perl/javascript/php/d'autres langues héritant de choix douteux de perl

N'hésitez pas à l'abattre ;-)

Semblable à ce que @Sacha0 a mentionné dans #25100. Je pense que si nous voulons vraiment changer de nom, je suggère d'aller avec:

enqueue!(::typeof(first), a, item) = unshift!(a, item)
enqueue!(::typeof(last), a, item) = push!(a, item)
dequeue!(::typeof(first), a) = shift!(a)
dequeue!(::typeof(last), a) = pop!(a)

julia> enqueue!(::typeof(first), a, item) = unshift!(a, item);

julia> enqueue!(::typeof(last), a, item) = push!(a, item);

julia> dequeue!(::typeof(first), a) = shift!(a);

julia> dequeue!(::typeof(last), a) = pop!(a);

julia> foo = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> enqueue!(first, foo, 0)
4-element Array{Int64,1}:
 0
 1
 2
 3

julia> dequeue!(first, foo)
0

julia> enqueue!(last, foo, 5)
4-element Array{Int64,1}:
 1
 2
 3
 5

julia> dequeue!(last, foo)
5

Alternativement :

push!(::typeof(first), a, item) = unshift!(a, item)
push!(::typeof(last), a, item) = push!(a, item)
pop!(::typeof(first), a) = shift!(a)
pop!(::typeof(last), a) = pop!(a)

Nous pourrions également conserver push! et pop! sans passer first ou last qui serait par défaut push!(last, ...) et pop!(last, ...) .