Julia: Ganti nama `shift!` dan `unshift!` ?

Kita bisa melakukan penggantian nama grosir dari fungsi-fungsi ini:

| tua | baru |
|-----|-----|
| push! | rpush! |
| pop! | rpop! |
| unshift! | lpush! |
| shift! | lpop! |

Atau kata kunci kiri/kanan (mulai/akhir? pertama/terakhir?) jika masalah kinerja dapat diselesaikan

Kiri dan kanan tampak agak ambigu; mungkin @c42f 's depan/belakang atau yang serupa akan lebih jelas?

Saya tidak yakin bahwa depan dan belakang lebih jelas daripada kiri dan kanan. Tentu saja, untuk terminologi kiri/kanan, agak disayangkan bahwa kami mencetak vektor secara vertikal, tetapi depan/belakang tidak lebih baik dalam hal itu.

Oh, dan kita sudah menggunakan l dan r untuk reduksi kiri dan kanan, jadi ada preseden – kecuali jika kita ingin mengubahnya juga.

Saya tidak yakin bahwa depan dan belakang lebih jelas daripada kiri dan kanan.

Saya juga tidak yakin. front mengasosiasikan dengan indeks yang lebih rendah (seperti Base.front ) dan back dengan indeks yang lebih tinggi dalam pikiran saya, tetapi saya yakin asosiasi semacam itu bervariasi.

Mungkin ide yang lebih baik: head - tail dan first - last tampak jelas kurang ambigu mengingat makna yang sudah ada sebelumnya?

Nama hpush! , hpop! , tpush! dan tpop! tidak buruk. Namun kita sudah mengaitkan kiri dan kanan dengan urutan array di foldl dan foldr , dll. Sebenarnya, karena mereka memiliki l dan r di akhir, nama analognya adalah pushl! , popl! , pushr! dan popr! yang saya nikmati :)

Dari opsi sejauh ini untuk mengganti nama keempat fungsi, versi sufiks pushl! , popl! , pushr! dan popr! terlihat paling baik bagi saya.

Saya memiliki beberapa keraguan tentang mengganti nama push! dan pop! . Misalnya, pertimbangkan untuk mendorong dan muncul ke antrian prioritas. Dalam hal ini tidak ada "kanan" dan "kiri", hanya ada pengurutan alami dan struktur data yang mengembalikan elemen terkecil/terbesar. Ada juga versi pop! yang menggunakan kunci untuk digunakan dengan kamus seperti struktur data, dan popr! juga tidak masuk akal sebagai kata kerja dalam kasus itu.

Saya pikir push! dan pop! dapat tetap dan digunakan oleh PriorityQueues. Mereka juga bisa hanya alias pushr! dan popr! untuk Array.

Saya suka shift! & unshift! , itu sama dengan javascript. silahkan pesan ini!

Sejauh ini, saya paling suka saran posting pertama.

Saya pikir itu baik untuk menggunakan nama push*! dan pop*! untuk menekankan kesamaan antara varian, dan agar varian dapat ditemukan dengan mudah dengan penyelesaian tab. (Saya suka saran sufiks r dan l .)

-2 ke r dan l terminologi. Nama-namanya agak jelek, dan ada 4 di antaranya. Saya lebih suka hanya mengganti nama shift dan unshift seperti yang disarankan OP. Tapi saya juga merasa shift dan unshift digunakan cukup luas sehingga sebaiknya kita simpan saja. Akan sangat disayangkan untuk memperkenalkan istilah yang tidak digunakan

@JeffBezanson C++ vektor menggunakan push_front , jadi ada beberapa preseden untuk ini.

Saya berasumsi nama yang ada dapat dilacak kembali ke shift builtin di sh , dan mungkin Perl mengambil ini dan menemukan unshift (http://www.perlmonks.org /?node_id=613144) Bahasa lain (php, javascript, ...?) mengikuti jadi ada banyak preseden.

Saya lebih suka kata-kata bahasa Inggris yang tepat... :) ( unshift ada di OED sejak tahun 1972.)

atau setidaknya sebutkan shift! & unshift! di pop! & push! 's doc:

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. 

Ide lain: push/pop!(first, x, ...) dan push/pop!(last, x, ...) .

Secara teoritis, sintaks ini digeneralisasi dengan baik untuk hal-hal seperti pop!(min, x) .

atau setidaknya sebutkan shift! & unshift! di pop! & push! 's doc:

Terkait dengan #23789

Ide keren, @TotalVerb!

Atau gabungkan dengan splice! / insert! , dengan first dan last sebagai indeks semu?

Ide lain: push/pop!(pertama, x, ...)

Ah apa? Ok ini ide yang sangat kreatif :-)

Tampaknya cukup aneh untuk menggunakan fungsi first dan last murni sebagai sintaks, daripada ada hubungannya dengan kode aktual di dalamnya. Ini agak bagus, tapi saya tidak yakin hal semacam ini harus didorong dalam ekosistem karena dapat menyebabkan keterikatan yang aneh? Misalnya, jika Anda ingin mengganti nama fungsi yang digunakan sebagai sintaks, lalu apa? Diakui sama sekali tidak mungkin untuk first dan last , tapi tetap saja.

Saya harus mengatakan, sekeren yang saya pikir ide ini – ini mengingatkan saya pada ide @mbauman untuk menggunakan fungsi reduksi dalam pengindeksan, seperti pada X[mean, :, sum] – Saya pikir itu terlalu mewah untuk operasi mendasar seperti itu. Saya kira opsi yang saya sukai saat ini adalah:

1. Biarkan hal-hal apa adanya – rapuh seperti "shift" dan "unshift", mereka cukup standar.
2. Ganti nama shift! dan unshift! menjadi popl! dan pushl! .
3. Selain 2, ganti nama pop! dan push! menjadi popr! dan pushr! .
4. Selain 3, buat alias pop! dan push! untuk popr! dan pushr! .

Saya sebagian besar antara 1 dan 2 tetapi ada beberapa daya tarik untuk 3 dan 4 juga.

Saya pikir 1) sangat masuk akal bahwa menerapkan operasi yang sama (push atau popping) ke awal dan akhir array harus memiliki setidaknya nama terkait; push! dan shift! adalah pasangan yang tidak intuitif; 2) kata shift! dapat dikacaukan dengan pergeseran bit >> , seperti yang dapat dengan mudah dilihat dengan mencari "shift" di dokumen; 3) banyak pengguna Julia tidak akan memiliki latar belakang perl/javascript.
Dengan demikian saya mendukung opsi 2 di posting di atas.
Tapi, jika kita mengganti nama mereka, apa yang harus dilakukan tentang circshift! ?

Opsi Stefan 2 atau 4 tampak bagus bagi saya. Saya tidak berpikir circshift! perlu diubah, karena ini bukan operasi seperti pop -

Usul:

| tua | baru | alias |
|----:|----:|----:|
| push! | pushr! | push! |
| pop! | popr! | pop! |
| unshift! | pushl! | |
| shift! | popl! | |

Saya harus mengatakan itu menggoda, terutama jika kita menyimpan push! dan pop! sebagai alias untuk kasus di mana Anda hanya menggunakan struktur sebagai tumpukan dan tidak terlalu peduli apakah itu kiri atau kanan Anda mendorong ke dan muncul dari.

Saya menggunakan front dan back (secara signifikan) lebih jelas daripada menyingkat left dan right .

Terutama karena vektor kita vertikal (sehingga harus atas/bawah) . Pilihan lain mungkin mulai/akhir atau pertama/terakhir.

kiri/kanan tampaknya baik-baik saja bagi saya; itu konsisten dengan terminologi pengurangan kami ( foldl dan foldr ), dan dengan cara vektor biasanya dimasukkan [a,b,c,…] dan dikeluarkan oleh print .

Hal baik lainnya tentang kiri/kanan adalah bahwa ia memiliki singkatan satu karakter yang mapan.

Serius, saya tidak tahu ujung vektor mana yang depan atau belakang. indeks depan 1 atau belakang? Ya, terkadang kami mencetak vektor kami secara vertikal, tetapi kami juga mencetaknya dari kiri ke kanan dalam kasus lain. Kami sudah secara konsisten menggunakan nama kiri/kanan yang diwariskan untuk banyak fungsi lainnya.

Bagaimana kalau hanya memiliki metode baru untuk menambahkan! dan tambahkan! di mana argumen kedua adalah skalar?

Percakapan ini telah berputar kembali ke https://github.com/JuliaLang/julia/issues/23902#issuecomment-332615200, yang pada gilirannya kembali meminta https://github.com/JuliaLang/julia/issues/23902#issuecomment-332668546 , yaitu head / tail atau first / last terminologi? :)

Ups, maaf memperpanjang diskusi. Maksud saya adalah bahwa daripada menciptakan kata-kata baru, kita harus menggunakan kembali kata-kata yang sudah ada.

Ups, maaf memperpanjang diskusi. Maksud saya adalah bahwa daripada menciptakan kata-kata baru, kita harus menggunakan kembali kata-kata yang sudah ada.

Maaf @phaverty! Kami melakukan simulasi. Tanggapan saya dimaksudkan untuk mengikuti @StefanKarpinski , daripada mengomentari komentar Anda :). Terbaik!

Saya paling suka popfirst! , pushfirst! , poplast! , pushlast! dengan pop! dan push! sebagai alias untuk keduanya yang terakhir.

di mana argumen kedua adalah skalar?

Tidak mungkin mendefinisikan skalar secara umum.

"Tidak mungkin mendefinisikan skalar secara umum."

Aku mengerti. Anda dapat menentukan, katakanlah,

tambahkan!( x::Vektor{T}, y::T )

, tetapi Anda benar-benar ingin y menjadi "sesuatu yang dapat diubah menjadi T". Namun, sistem tipe tidak (belum?) mengetahui kumpulan tipe apa yang dapat dikonversi. Kekecewaan.

Mari kita memberikan suara (tidak mengikat, informatif):

• 👍 untuk pushr! , popr! , pushl! dan popl! dengan push! dan pop! sebagai alias untuk dua yang pertama
• untuk menjaga hal-hal sebagaimana adanya
• untuk beberapa opsi lain

Pilihan emoji itu agak bias ;).

Dan :+1: pada saran OP jika Anda paling menyukainya;)

Saya memiliki beberapa pemikiran untuk mengganti nama fungsi-fungsi ini, jadi saya hanya akan meminta maaf sebelumnya karena mungkin menambahkan beberapa kebisingan ke dalam percakapan ini. Sejauh ini nama Julia dari fungsi push! , pop! , shift! , dan unshift! sama dengan Perl, Ruby, dan JavaScript (https://en .wikipedia.org/wiki/Double-ended_queue#Operations). Secara pribadi saya tidak keberatan dengan nama-nama ini karena saya awalnya mempelajarinya di Perl tetapi saya sepenuhnya mengakui bahwa shift/unshift tidak mudah diingat. Tampaknya juga ada kubu yang menganggap push/pop adalah pasangan pelengkap yang buruk .

Ide lain: push/pop!(first, x, ...) dan push/pop!(last, x, ...) .

Jika kita pergi ke arah ini, saya sarankan kita menggunakan enqueue! dan dequeue! sebagai nama fungsi-fungsi ini.

Yang saya suka dari nama aslinya adalah mereka hanya menggunakan satu kata. Mencoba untuk menjaga satu kata tetapi membuat beberapa pasangan yang lebih baik saya datang dengan push! dan pull! untuk FIFO dan push! dan pop! untuk FILO. Ini akan membuat Push/pop berfungsi di awal antrian alih-alih di akhir:

Tua | Baru
-------|-----
dorongan! | taruh!
pop! | menarik!
menggeser! | dorongan!
tidak bergeser! | pop!

Kita bisa membiarkan push/pop di akhir dan memindahkan put/pull ke awal agar tidak terlalu putus, tetapi saya pikir itu akan membuat segalanya agak membingungkan.

Alternatif lain adalah menggunakan append! dan prepend! untuk masing-masing merujuk ke push! dan shift! . Namun saya tidak memiliki kata-kata yang masuk akal untuk dequeuing dan behead dan curtail adalah yang terbaik yang bisa saya buat...

@phaverty Selama mungkin untuk memiliki Vector{Any} , itu akan menjadi ambigu.

Saya akan memposting ulang ini: https://github.com/JuliaLang/julia/issues/23902#issuecomment -332919287

@omus Mengganti nama shift! menjadi push! tampaknya sangat membingungkan.

append! beroperasi pada dua koleksi, sedangkan push! et. Al. beroperasi pada satu elemen, jadi IMO nama itu tidak dapat digunakan di sini.

Akhirnya, kami selalu dapat merangkul unicode dan menggunakan sesuatu seperti:

ASCII | Unicode | Nama Unicode | Alias
---|---|---|---
dorongan! | | panah kiri ke bilah |
pop! | | panah ke kanan dari bilah | peta
menggeser! | | panah ke kanan ke bilah |
tidak bergeser! | | panah ke kanan dari bilah | petadari

Pikirkan bilah di unicode sebagai antrian. ~Sayangnya karakter unicode ini tidak memiliki alias yang bagus di REPL dari apa yang saya tahu~.

Mengganti nama shift! menjadi push! tampaknya sangat membingungkan.

Sejujurnya, saya tidak akan senang jika kami benar-benar mengambil pendekatan itu. Pendekatan itu pasti mencoba bersikap baik kepada pendatang baru dan benar-benar jahat kepada pengguna Julia yang sudah ada.

@omus , misalnya adalah \mapsto .

Oke, saya berbohong: Saya punya satu hal lagi untuk dikatakan. Sebagai saran yang lebih serius adalah kita bisa menggunakan pendekatan ini. Itu kehilangan Push/pop yang bagus tetapi jauh lebih jelas tentang operasi yang sedang berlangsung:

Tua | Baru
-- | --
dorongan! | terakhir!
pop! | terakhir!
menggeser! | pertama!
tidak bergeser! | pertama keluar!

Jangan ragu untuk memilih sebagian besar saran ini. Setelah melakukan penggalian tentang topik ini, satu-satunya kesimpulan benar yang saya dapatkan adalah bahwa ilmuwan komputer menganut terminologi push/pop dan tidak tahu apa yang harus diberi nama shift/unshift.

Sekarang kita memiliki lipatan konstan, argumen kata kunci untuk ini harus cepat, benar? Saya tidak mengerti mengapa kami memiliki 4 fungsi untuk ini alih-alih 2, terutama karena fungsi multi-kata secara khusus tidak disarankan untuk mempromosikan refactoring.

Menghibur seperti ini, tampaknya kita tidak bisa berbuat lebih baik daripada status quo di sini.

Menghibur seperti ini, tampaknya kita tidak bisa berbuat lebih baik daripada status quo di sini.

Jumlah dukungan untuk OP tampaknya substansial? Mungkin menutup masalah ini agak prematur? :)

Ya, saran OP memiliki 11 naik dan 0 turun ...

Saya menafsirkan itu sebagai dukungan untuk gagasan umum tentang penggantian nama, bukan untuk saran khusus itu.

Jelas bagi saya bahwa setelah semua diskusi ini kami tidak menemukan alternatif yang benar-benar menarik.

FWIW pushfront! masih menjadi favorit saya dan penamaan ulang yang berharga menurut saya, tapi itu mungkin hanya bias C++ saya.

Saya suka pushfront! dan popfront! .

Yah, saya membuat PR di #25100 untuk menggunakan pushfront! / popfront! karena menurut saya itu adalah hal minimal yang bisa kita lakukan untuk mengganti nama unshift! . Benar-benar satu-satunya hal yang dilakukan unshift! untuk itu adalah (a) status quo, dan (b) memiliki preseden dalam perl/javascript/php/bahasa lain yang mewarisi pilihan yang meragukan dari perl

Jangan ragu untuk menembaknya ;-)

Mirip dengan apa yang @Sacha0 sebutkan di #25100. Saya pikir jika kita benar-benar ingin mengubah nama, saya sarankan pergi dengan:

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

Kalau tidak:

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)

Kita juga dapat menyimpan push! dan pop! tanpa melewatkan first atau last yang akan default ke push!(last, ...) dan pop!(last, ...) .