Julia: Cambiar el nombre de `shift!` Y `unshift!`?

Podríamos hacer un cambio de nombre al por mayor de estas funciones:

| viejo | nuevo |
| ----- | ----- |
| push! | rpush! |
| pop! | rpop! |
| unshift! | lpush! |
| shift! | lpop! |

O una palabra clave izquierda / derecha (¿inicio / fin? ¿Primero / último?) Si los problemas de rendimiento pueden resolverse

Izquierda y derecha parecen un poco ambiguas; ¿quizás el anverso / reverso de @c42f o algo similar sería más claro?

No estoy seguro de que la parte delantera y trasera estén más claras que la izquierda y la derecha. Por supuesto, para la terminología izquierda / derecha es un poco desafortunado que imprimamos vectores verticalmente, pero anverso / reverso no son mejores en ese sentido.

Ah, y ya usamos l y r para la izquierda y la derecha en las reducciones, así que hay un precedente, a menos que queramos cambiarlos también.

No estoy seguro de que la parte delantera y trasera estén más claras que la izquierda y la derecha.

Yo tampoco estoy seguro. front asocia con índices más bajos (como Base.front ) y back con índices más altos en mi mente, pero estoy seguro de que ese tipo de asociación varía.

Quizás mejores ideas: head - tail y first - last parecen claramente menos ambiguos dados sus significados preexistentes?

Los nombres hpush! , hpop! , tpush! y tpop! no son malos. Sin embargo, la izquierda ya asociado y derecha con el orden de las matrices en foldl y foldr , etc. En realidad, ya que éstos tienen el l y r en el Al final, los nombres análogos son pushl! , popl! , pushr! y popr! que disfruto :)

Fuera de las opciones hasta ahora para cambiar el nombre de las cuatro funciones, las versiones con sufijo pushl! , popl! , pushr! y popr! parecen mejores.

Sin embargo, tengo algunas reservas sobre el cambio de nombre de push! y pop! . Por ejemplo, considere presionar y pasar a una cola de prioridad. En este caso, no hay "derecha" ni "izquierda", solo hay un orden natural y una estructura de datos que devuelve el elemento menor / mayor. También existe la versión de pop! que toma una clave para su uso con estructuras de datos similares a diccionarios, y popr! tampoco tendría mucho sentido como verbo en ese caso.

Creo que push! y pop! pueden permanecer y ser utilizados por PriorityQueues. También pueden usar alias pushr! y popr! para Arrays.

Me encanta shift! & unshift! , es lo mismo con javascript. por favor reserve esto!

Hasta ahora, me gusta más la sugerencia de la primera publicación.

Creo que es bueno usar los nombres push*! y pop*! para enfatizar la similitud entre las variantes, y para que las variantes se puedan encontrar fácilmente al completar la pestaña. (Me gusta la sugerencia de sufijo r y l .)

-2 a r y l terminología. Los nombres son un poco feos y hay 4 de ellos. Preferiría solo cambiar el nombre de shift y unshift como sugiere el OP. Pero también siento que shift y unshift se usan lo suficientemente ampliamente como para que podamos simplemente mantenerlos. Sería desafortunado introducir términos que nadie más usa para operaciones tan increíblemente comunes.

@JeffBezanson El vector C ++ usa push_front , por lo que hay un precedente para esto.

Supongo que los nombres existentes se pueden rastrear hasta el shift incorporado en sh , y presumiblemente Perl tomó esto e inventó unshift (http://www.perlmonks.org /? node_id = 613144) Siguieron otros idiomas (php, javascript, ...?), por lo que hay muchos precedentes.

Prefiero palabras en inglés adecuadas ... :) ( unshift está en el OED que se remonta a 1972.)

o al menos mencionar shift! & unshift! en el documento 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. 

Otra idea: push/pop!(first, x, ...) y push/pop!(last, x, ...) .

En teoría, esta sintaxis se generaliza bien a cosas como pop!(min, x) .

o al menos mencionar shift! & unshift! en el documento de pop! & push! :

Relacionado con # 23789

¡Genial idea, @TotalVerb!

¿O fusionar con splice! / insert! , con first y last como pseudoíndices?

Otra idea: push / pop! (Primero, x, ...)

¿Ah que? Ok, esta es una idea realmente creativa :-)

Parece bastante extraño usar las funciones first y last puramente como sintaxis, en lugar de tener algo que ver con el código real dentro de ellas. Es genial, pero no estoy seguro de que este tipo de cosas deba fomentarse en el ecosistema, ya que puede conducir a enredos extraños. Por ejemplo, si alguna vez quisiste cambiar el nombre de las funciones que se estaban usando como sintaxis, ¿entonces qué? Es cierto que no es nada probable por first y last , pero aún así.

Tengo que decir que, por muy genial que creo que sea esta idea, me recuerda la idea de @mbauman de usar funciones de reducción en la indexación, como en X[mean, :, sum] , creo que es demasiado elegante para una operación tan fundamental. Supongo que las opciones por las que estoy a favor en este momento son:

1. Deje las cosas como están; aunque sean dudosos como lo son "shift" y "unshift", son bastante estándar.
2. Cambie el nombre de shift! y unshift! a popl! y pushl! .
3. Además de 2, cambie el nombre de pop! y push! a popr! y pushr! .
4. Además de 3, crea push! alias pop! y push! para popr! y pushr! .

Estoy mayormente entre 1 y 2, pero también hay algo de atractivo para 3 y 4.

Creo que 1) tiene mucho sentido que aplicar la misma operación (presionar o hacer estallar) al principio y al final de una matriz debería tener al menos nombres relacionados; push! y shift! son un par poco intuitivo; 2) la palabra shift! puede confundirse con el cambio de bits >> , como se puede ver fácilmente buscando en los documentos "shift"; 3) muchos usuarios de Julia no tendrán experiencia en perl / javascript de todos modos.
Por lo tanto, estoy a favor de la opción 2 en la publicación anterior.
Pero, si les cambiamos el nombre, ¿qué hacer con circshift! ?

La opción 2 o 4 de Stefan me parece buena. No creo que circshift! deba cambiar, porque no es una operación similar a pop

Propuesta:

| viejo | nuevo | alias |
| ----: | ----: | ----: |
| push! | pushr! | push! |
| pop! | popr! | pop! |
| unshift! | pushl! | |
| shift! | popl! | |

Debo decir que eso es tentador, especialmente si mantenemos push! y pop! como alias para los casos en los que solo estás usando una estructura como una pila y realmente no te importa si es la izquierda o hacia la derecha está empujando y saliendo.

Imo usando front y back son (significativamente) más claros que abreviar left y right .

Especialmente porque nuestros vectores son verticales (por lo que deberían estar arriba / abajo) 🙂. Otras opciones pueden ser inicio / fin o primero / último.

izquierda / derecha me parece bien; es coherente con nuestra terminología de reducción ( foldl y foldr ), y con la forma en que los vectores normalmente se ingresan [a,b,c,…] y se generan con print .

La otra cosa buena de left / right es que tiene una abreviatura de un carácter bien establecida.

En serio, no sé qué extremo de un vector es el anverso o el reverso. ¿El índice frontal es 1 o es el reverso? Sí, a veces imprimimos nuestros vectores verticalmente, pero también los imprimimos de izquierda a derecha en otros casos. Ya estamos usando sistemáticamente nombres heredados de izquierda / derecha para muchas otras funciones.

¿Qué tal tener nuevos métodos para agregar? y anteponer! donde el segundo argumento es un escalar?

Esta conversación ha vuelto a https://github.com/JuliaLang/julia/issues/23902#issuecomment-332615200, que a su vez vuelve a solicitar https://github.com/JuliaLang/julia/issues/23902#issuecomment-332668546 , es decir, head / tail o first / last terminología? :)

Vaya, perdón por prolongar la discusión. Mi punto era que en lugar de inventar nuevas palabras, deberíamos reutilizar las existentes.

Vaya, perdón por prolongar la discusión. Mi punto era que en lugar de inventar nuevas palabras, deberíamos reutilizar las existentes.

¡Lo siento @phaverty! Simulposamos. Mi respuesta estaba destinada a seguir la de @StefanKarpinski , en lugar de comentar su comentario :). ¡Mejor!

Me gustan más los popfirst! , pushfirst! , poplast! , pushlast! con pop! y push! como alias para los dos último.

donde el segundo argumento es un escalar?

No es posible definir escalar de forma genérica.

"No es posible definir escalar de forma genérica".

Ah, ya veo. Podría especificar, por ejemplo,

añadir! (x :: Vector {T}, y :: T)

, pero realmente quieres que y sea "algo que se pueda convertir en T". Pero, el sistema de tipos no sabe (¿todavía?) Qué conjunto de tipos se pueden convertir. Gorrón.

Hagamos un voto (informativo y no vinculante):

• 👍 por pushr! , popr! , pushl! y popl! con push! y pop! como alias para los dos primeros
• 👎 para mantener las cosas como están
• 😕 para alguna otra opción

Esa elección de emoji es algo sesgada;).

Y: +1: en la sugerencia de OP si te gusta más;)

Tengo algunas ideas sobre cómo cambiar el nombre de estas funciones, así que me disculparé de antemano por posiblemente agregar algo de ruido a esta conversación. Hasta ahora, los nombres de Julia de las funciones push! , pop! , shift! y unshift! son los mismos que los de Perl, Ruby y JavaScript (https: // en .wikipedia.org / wiki / Double-final_queue # Operaciones). Personalmente, no me importan estos nombres, ya que los aprendí originalmente en Perl, pero admito plenamente que el cambio / no cambio no es memorable. También parece haber un grupo que piensa que push / pop es una mala pareja complementaria .

Otra idea: push/pop!(first, x, ...) y push/pop!(last, x, ...) .

Si tuviéramos que ir en esta dirección, sugeriría que usemos enqueue! y dequeue! como los nombres de estas funciones.

Lo que me gusta de los nombres originales es que solo usan una palabra. Tratando de ceñirme a una palabra pero hacer algunas combinaciones más agradables, se me ocurrió push! y pull! para FIFO y push! y pop! para FILO. Esto haría que push / pop funcione al principio de una cola en lugar de al final:

Viejo | Nuevo
------- | -----
¡empujar! | ¡poner!
¡música pop! | ¡jalar!
¡cambio! | ¡empujar!
deshacer el turno! | ¡música pop!

Podríamos dejar push / pop al final y mover put / pull al principio para romper menos, pero creo que eso dejaría las cosas algo confusas.

Otra alternativa es usar append! y prepend! para referirse respectivamente a push! y shift! . Sin embargo, no tengo palabras razonables para quitar la cola y behead y curtail fueron lo mejor que pude encontrar ...

@phaverty Siempre que sea posible tener un Vector{Any} , será ambiguo.

Volveré a publicar esto: https://github.com/JuliaLang/julia/issues/23902#issuecomment -332919287

@omus Cambiar el nombre de shift! a push! parece innecesariamente confuso.

append! opera en dos colecciones, mientras que push! et. Alabama. opera en un elemento, por lo que, en mi opinión, ese nombre simplemente no se puede usar aquí.

Finalmente, siempre podríamos adoptar unicode e ir con algo como:

ASCII | Unicode | Nombre Unicode | Alias
--- | --- | --- | ---
¡empujar! | ⇤ | flecha hacia la izquierda a la barra |
¡música pop! | ↦ | flecha hacia la derecha desde la barra | mapas para
¡cambio! | ⇥ | flecha hacia la derecha a la barra |
deshacer el turno! | ↤ | flecha hacia la derecha desde la barra | mapas de

Piense en la barra en el Unicode como la cola. ~ Desafortunadamente, estos caracteres Unicode no tienen buenos alias en el REPL por lo que puedo decir ~.

Cambiar el nombre de shift! a push! parece innecesariamente confuso.

Honestamente, no estaría contento si realmente tomáramos ese enfoque. Ese enfoque definitivamente está tratando de ser amable con los recién llegados y realmente malo con los usuarios existentes de Julia.

@omus , por ejemplo, ↦ es \mapsto .

Ok, mentí: tengo una cosa más que decir. Como sugerencia más seria, podríamos seguir este enfoque. Pierde el buen push / pop, pero es mucho más claro en cuanto a la operación en curso:

Viejo | Nuevo
- | -
¡empujar! | ¡ultima entrada!
¡música pop! | ¡durar!
¡cambio! | ¡primero en!
deshacer el turno! | ¡primero en salir!

No dude en rechazar la mayoría de estas sugerencias. Después de investigar un poco sobre este tema, la única conclusión verdadera a la que llegué es que los científicos informáticos adoptaron la terminología push / pop y no tenían idea de cómo nombrar shift / unshift.

Ahora que tenemos un plegado constante, los argumentos de palabras clave para esto deberían ser rápidos, ¿correcto? No entiendo por qué tendríamos 4 funciones para esto en lugar de 2, especialmente porque las funciones de varias palabras se desaconsejan específicamente para promover la refactorización.

Por entretenido que sea, parece que no podemos hacerlo mejor que el statu quo aquí.

Por entretenido que sea, parece que no podemos hacerlo mejor que el statu quo aquí.

¿La cantidad de apoyo para el PO parece sustancial? ¿Quizás cerrar este tema es un poco prematuro? :)

Sí, la sugerencia del OP tiene 11 arriba y 0 abajo ...

Los interpreté como apoyo a la noción general de cambio de nombre, no a esa sugerencia específica.

Para mí está claro que después de toda esta discusión no encontramos una alternativa realmente convincente.

FWIW pushfront! sigue siendo mi favorito y un cambio de nombre que vale la pena en mi opinión, pero ese podría ser mi sesgo de C ++.

Me gustan pushfront! y popfront! .

Bueno, hice un PR en # 25100 para usar pushfront! / popfront! ya que creo que es lo mínimo que podemos hacer para cambiar el nombre de unshift! . Realmente lo único que unshift! tiene a su favor es (a) es el status quo, y (b) tiene precedentes en perl / javascript / php / otros lenguajes heredando opciones dudosas de perl

Siéntete libre de derribarlo ;-)

Similar a lo que @ Sacha0 mencionó en el # 25100. Creo que si realmente queremos hacer un cambio de nombre, sugiero ir con:

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

Alternativamente:

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)

También podríamos mantener push! y pop! sin pasar first o last que por defecto serían push!(last, ...) y pop!(last, ...) .