Struktur kontrol alternatif mana yang berguna yang Anda ketahui? [Tutup]

Pertanyaan serupa ditutup pada SO.

Terkadang ketika kita sedang pemrograman, kita menemukan bahwa beberapa struktur kontrol tertentu akan sangat berguna bagi kita, tetapi tidak secara langsung tersedia dalam bahasa pemrograman kita.

Struktur kontrol alternatif apa yang menurut Anda merupakan cara yang berguna untuk mengatur komputasi?

Tujuannya di sini adalah untuk mendapatkan cara berpikir baru tentang penataan kode, dalam rangka meningkatkan chunking dan penalaran.

Anda dapat membuat sintaksis semantik / semantik yang tidak tersedia sekarang atau mengutip struktur kontrol yang kurang dikenal pada bahasa pemrograman yang ada.

Jawaban harus memberikan ide untuk bahasa pemrograman baru atau meningkatkan bahasa yang sebenarnya.

Anggap ini sebagai brainstorming, jadi posting sesuatu yang Anda anggap gila, tetapi bisa dilakukan dalam beberapa skenario.

Ini tentang pemrograman imperatif.

Oke, ini pertanyaan yang menyenangkan.

Saya juga ingin memiliki jenderal elseuntuk sementara dan untuk loop, karena ketika kondisi tidak benar pada tes pertama :

while (condition) {
    // process
}
else {
    // condition was never true
}

Ini menghindari komputasi ulang yang canggung dari kondisi atau menyimpannya dalam variabel.

Mengapa tidak tumbuk beberapa jawaban menjadi satu?

while (expr) {

    // Executed every iteration, unless first{} is present.
    // May be explicitly called rest{} if you like first{} to come first.

    // Blocks may return results, and consequently be used in expressions.
    return expr;

} first {

    // Executed only on the first iteration.

} pre {

    // Executed before every iteration.

} post {

    // Executed after every iteration.

} catch (oops) {

    // All blocks are implicitly try{}ed if followed by a catch{}.

} finally {

    // Executes after the block completes, regardless of exceptions.

} else {

    // Executed if the loop body or rest{} never executes.

} never {

    // Executes only when a client is present.

} drop (bad, worse), // Explicitly ignore certain exceptions.
  until (expr);      // Here, have a post-body condition, too.

Sintaksis konstruk kontrol aliran yang dapat diperluas dan disamaratakan dalam bahasa imperatif akan lebih bermanfaat dan menghibur. Sampai itu muncul, kira saya akan menggunakan Lisp atau sesuatu.

Kontrol struktur sebagai fungsi.

Saya ingin for, if, else, while, dll menjadi fungsi, bukan struktur khusus.

Saya ingin return, try/exceptdan gotomenjadi turunan dari kelanjutan.

Ini tentu saja kurang berkaitan dengan struktur kontrol tertentu dan lebih berkaitan dengan bagaimana Anda melihat struktur kontrol secara umum, meta struktur kontrol.

Artikel yang ditautkan pasti benar tentang Loop N + 1/2 Donald Knuth . Dinyatakan dalam C / C ++ / Java:

for (;;) {
  get next element;
  if (at the end) break;
  process the element;
}

Ini berguna untuk membaca baris atau karakter dari file, menguji apakah Anda telah mencapai EOF, dan kemudian memprosesnya. Saya sudah terbiasa melihat polanya for(;;)..if(..)break;muncul sehingga itu idiomatis bagi saya. (Sebelum saya membaca artikel Knuth, dicetak ulang dalam buku Literate Programming , artikel ini dulunya adalah "wtf?".)

Knuth menyarankan kata kunci loop/while/repeat:

loop:
  S;
while C:
  T;
repeat

Di mana Sdan Tadalah pemegang tempat untuk serangkaian pernyataan nol atau lebih, dan Cmerupakan kondisi boolean. Jika tidak ada Spernyataan maka itu akan menjadi loop sementara, dan jika tidak ada Tpernyataan maka itu akan menjadi loop lakukan.

Konstruk ini sendiri dapat digeneralisasikan dengan mengizinkan nol atau lebih while Cklausa, membuatnya sempurna untuk mengekspresikan loop tak terbatas dan kemudian beberapa kondisi langka yang membutuhkan dua pemeriksaan.

Dalam artikel yang sama, Knuth menyarankan mekanisme pensinyalan yang akan menjadi versi lokal dari pengecualian melempar / menangkap (sebagai alternatif untuk menggunakan goto).

Untuk saya? Saya berharap Java mendukung pengoptimalan tail-call, sehingga saya dapat mengekspresikan struktur kontrol umum apa pun yang diperlukan.

Pembaruan: Saya lupa menyebutkan bahwa banyak programmer C / C ++ / Java menyiasati yang satu ini dengan menggunakan tugas yang disematkan dalam kondisi while:

while ((c = getc(f)) != -1) {
   T;
}

Menggunakan istilah-istilah dari konstruk Knuth, ini diizinkan kapan Sdan Cdapat digabungkan menjadi satu ekspresi. Beberapa orang benci melihat tugas yang disematkan di atas, sementara yang lain benci melihat yang breakdi for (;;)atas. Tetapi ketika Sdan Ctidak dapat digabungkan, seperti ketika Smemiliki beberapa pernyataan, itu for (;;)adalah satu-satunya alternatif tanpa kode berulang. Alternatif lain adalah dengan hanya menggandakan Skode:

S;
while (C) {
  T;
  S;
}

loop/while/repeatAlternatif Knuth tampaknya jauh lebih baik.

Bahasa BCPL memiliki valueofekspresi yang dapat digunakan untuk mengubah urutan pernyataan menjadi ekspresi tunggal:

foo(a, b, valueof {some series of statements; resultis v});

Di mana some series of statementsbisa apa saja dan keseluruhannya valueofdievaluasi v.

Ini bisa berguna di Jawa ketika Anda perlu menghitung argumen untuk memanggil this()atau super()(yang mengharuskan tidak ada yang terjadi sebelum itu). Tentu saja, Anda bisa saja menulis metode terpisah, tetapi itu mungkin menyebalkan jika Anda perlu memasukkan banyak nilai lokal untuk konteks.

Jika Anda dapat menggunakan finaluntuk variabel yang diperlukan, Anda sudah bisa melakukan valueofdi Java menggunakan kelas dalam anonim:

foo(a, b, new Object(){String valueof(){
    String v ...; some series of statements; return v;}}.valueof());

unless(condition) {
  // ...
}

melakukan hal yang sama seperti:

if(!condition) {
  // ...
}

repeat {
  // ...
} until(condition)

melakukan hal yang sama seperti:

do {
  // ...
} while(!condition)

Pada catatan yang berbeda, saya ingin melihat dukungan yang lebih baik untuk iterator dalam bahasa pemrograman. Khususnya, untuk saat Anda ingin turun dua koleksi berpasangan :

for (String s, Integer i : stringsSet, integersSet) {
    // use the pair (s, i)
}

Beberapa bahasa dinamis mungkin sudah memiliki ini, atau dengan mudah mendukung melalui perpustakaan dan makro, tetapi saya pikir ini adalah semangat pertanyaan Anda.

Jika kedua set ukurannya tidak sama, maka bisa melempar pengecualian atau Anda bisa memiliki elsesetelah loop untuk memberi sinyal ada perbedaan ukuran.

Secara alami, Anda bisa menggeneralisasi ini untuk turun tiga atau lebih daftar.

Pembaruan: Berguna juga untuk melakukan produk Cartesian antar iterables:

for (String s, Integer i : stringsSet * integersSet) {
    // use the pair (s, i), each s with each i
}

yang tidak lebih dari loop bersarang:

for (String s : stringsSet) {
    for (Integer i : integersSet) {
        // use the pair (s, i), each s with each i
    }
}

Saya sedikit khawatir bahwa antara dua notasi yang saya berikan di sini bahwa ada perbedaan O (n) dan O (n ^ 2) dalam jumlah pasangan, dengan hanya perubahan satu karakter.

Ada yang disebut "Dijkstra's Loop" (juga disebut "Dijkstra's Guarded Loop"). Itu didefinisikan dalam The Guarded Command Language (GCL) . Anda dapat menemukan beberapa informasi tentang sintaks dan semantik di artikel Wikipedia di atas di bagian 6 Pengulangan: lakukan .

Saat ini saya benar-benar tahu satu bahasa pemrograman yang mendukung struture kontrol ini secara langsung. Ini adalah Oberon-07 (PDF, 70 KB). Dan itu mendukung "Dijkstra's Loop" dalam bentuk pernyataan sementara. Lihatlah bagian 9.6. Sedangkan pernyataan dalam PDF di atas.

WHILE m > n DO m := m – n 
ELSIF n > m DO n := n – m 
END

PS Ini adalah salinan jawaban SO saya .

Ekspresi gaya ikon dengan backtracking bawaan.

Python mendapatkan banyak manfaat generator Ikon - dan melakukan pekerjaan yang lebih baik secara umum, IMO. Dan pada prinsipnya backtracking itu hanya semacam lemparan pengecualian, tapi itu adalah kesederhanaan dari ekspresi yang setara dengan ...

x = (a / b) else c;

untuk menangani kasus gagal seperti pembagian dengan nol.

Di mana Icon menjadi gila - tidak ada operator pembanding yang mengembalikan boolean. Perbandingan selalu berhasil atau memicu kemunduran, dan ada beberapa masalah semantik lain yang sekarang saya dengan susah payah mencoba untuk mengingat bahwa ... well, anggap saja itu mungkin lebih ditekan daripada terlupakan.

Saya selalu berpikir mereka harus memiliki ifekspresi tanpa bagian lain - if (condition, success-value)semacam itu, mundur jika kondisinya kembali salah - dan jatuhkan perbandingan aneh.

EDIT saya ingat - jelas banget. Perbandingan dengan dua argumen berhasil atau gagal - tidak menghitung nilai baru untuk kembali. Jadi ketika itu berhasil, apa yang itu kembali? Jawab - salah satu argumen. Tetapi jika Anda menulis a > b, yang merupakan argumen logis untuk kembali - aatau b? Dan bagaimana jika Anda menulis b < a? Saya pikir itu selalu mengembalikan argumen yang benar, yang masuk akal seperti apa pun, tetapi biasanya masih tampak seperti argumen yang salah bagi saya.

Ini hanya ide dan sintaksis umum:

if (cond)
   //do something
else (cond)
   //do something
also (cond)
   //do something
else
   //do something
end

Kondisi JUGA selalu dievaluasi. ELSE bekerja seperti biasa.

Ini berfungsi untuk kasus juga. Mungkin itu adalah cara yang baik untuk menghilangkan pernyataan break:

case (exp)
   also (const)
      //do something
   else (const)
      //do something
   also (const)
      //do something
   else
      //do something
end

dapat dibaca sebagai:

switch (exp)
   case (const)
      //do something
   case (const)
      //do something
      break
   case (const)
      //do something
   default
      //do something
end

Saya tidak tahu apakah ini berguna atau mudah dibaca tetapi ini adalah contoh.

Continuation Passing Style muncul di pikiran. Kemudian, tentu saja, Anda juga ingin memiliki Optimasi Panggilan Ekor .

Percabangan utas yang mulus, memiliki sintaksis seperti fungsi, tetapi dijalankan dalam utas yang terpisah dan tidak dapat mengakses data yang pada awalnya tidak diteruskan.

branch foo(data, to, be, processed){
    //code
    return [resulting, data]
}

Ketika cabang dipanggil, ia akan segera mengembalikan pegangan.

handle=foo(here, is, some, data)

Pegangan dapat digunakan untuk memeriksa apakah tugas sudah selesai.

handle.finished() //True if the execution is complete

Jika hasilnya diminta sebelum eksekusi selesai, utas utama hanya akan menunggu.

[result, storage]=handle.result()

Ini tidak akan mencakup skenario multithreading yang lebih maju, melainkan menyediakan cara awal yang mudah diakses untuk memanfaatkan beberapa core.

if (cond)
   //do something
else (cond)
   //do something
else (cond)
   //do something
first
   //do something
then
   //do something
else (cond)
   //do something
else
   //do something
end

Blok FIRST dan THEN berjalan jika salah satu dari 3 kondisi dievaluasi menjadi true. Blok PERTAMA berjalan sebelum blok bersyarat dan LALU berjalan setelah blok bersyarat telah berjalan.

Bersyarat atau penulisan akhir ELSE berikut pernyataan PERTAMA dan KEMUDIAN independen dari blok ini.

Itu bisa dibaca sebagai:

if (cond)
   first()
   //do something
   then()
else (cond)
   first()
   //do something
   then()
else (cond)
   first()
   //do something
   then()
else (cond)
   //do something
else
   //do something
end


function first()
   //do something
return
function then()
   //do something
return

Fungsi-fungsi ini hanyalah sebuah formulir untuk dibaca. Mereka tidak akan menciptakan ruang lingkup. Ini lebih seperti gosub / kembali dari Basic.

Kegunaan dan keterbacaan sebagai bahan diskusi.

Terkadang saya menemukan diri saya menulis sebuah loop yang perlu melakukan sesuatu yang berbeda selama iterasi pertama. Misalnya, menampilkan tag <th> alih-alih tag <td>.

Saya menangani situasi ini dengan bendera boolean. Sesuatu seperti ini:

first = true

while (some_condition)
    if (first)
        do_something
        first = false
    else
        do_something_else

Tampaknya konyol untuk memeriksa nilai firstsetiap iterasi ketika itu sebagian besar salah.

Saya ingin memiliki opsi pengulangan untuk menentukan badan pengulangan yang berbeda pada iterasi pertama. Tidak perlu untuk variabel yang terpisah. Kode yang dikompilasi tidak perlu satu, juga, karena kode yang dihasilkan akan memiliki dua tubuh, satu untuk iterasi pertama dan satu untuk sisanya.

[disalin dari jawaban saya sendiri di stackoverflow]

ignoring - Untuk mengabaikan pengecualian yang terjadi pada blok kode tertentu.

try {
  foo()
} catch {
  case ex: SomeException => /* ignore */
  case ex: SomeOtherException => /* ignore */
}

Dengan konstruk kontrol pengabaian, Anda bisa menulisnya lebih ringkas dan lebih mudah dibaca sebagai:

ignoring(classOf[SomeException], classOf[SomeOtherException]) {
  foo()
}

[Scala menyediakan ini (dan banyak konstruksi kontrol penanganan Pengecualian lainnya) di perpustakaan standarnya, dalam paket util.control. ]

Dari pada:

switch(myEnum) {
  case MyEnum.Val1: do1(); ...
  case MyEnum.Val2: do2(); ...
....

Lakukan dengan Python, atau sekarang dengan cara C # juga:

action = val2func[myEnum]
action()

Scala memiliki banyak fitur baru.

Akhirnya, bahasa seperti Clojure dapat diperluas untuk menyediakan fungsionalitas tambahan.

Saya punya dua ide.

Seringkali saya menemukan bahwa saya mengulangi diri saya dalam catchbalok-balok. Ini dapat sedikit dibantu melalui metode ekstraksi, tetapi itu dapat menyebabkan kekacauan yang tidak perlu jika metode ini sangat singkat atau tidak layak metode. Jadi, akan lebih baik untuk membuat sarang catch:

try {
    // Save something
} catch (Exception e) {
    // Something we do for all Exceptions
    catch (ProcessingException e) {
        // Something we do for all Processing exceptions
        catch (DBExcpetion e) {
            // DBExceptions are a subclass of ProcessingException
        }
        catch (BusinessRuleException e) {
            // BusinessRuleExceptions are also a subclass of ProcessingException
        }
    }
    // Something we do after specific sub class Exceptions
 }

Dalam pemrograman web saya juga sering menemukan diri saya sering melakukan sesuatu seperti ini (ini bukan contoh nyata jadi jangan menganalisis kasus fiksi):

Account a = getSavedAccount();
if (a == null) {
    a = getAccountFromSessionId();
}
if (a == null) {
    a = getAccountFromCookieId();
}
if (a == null) {
    a = createNewAccount();
}

Dalam Javascript (well, ECMAScript, dan mungkin orang lain yang saya tidak kenal), karena nilai apa pun dapat dievaluasi sebagai suatu kondisi, ||dapat membantu.

var a = getAFromLocation1() || getAFromLocation2() || default;

Saya sangat suka tampilannya, dan saya berharap lebih banyak bahasa, khususnya beberapa di sisi server, memiliki dukungan untuk itu. (PHP dapat mengevaluasi apa pun sebagai suatu kondisi, tetapi mengubah seluruh ekspresi kondisional menjadi boolean alih-alih mempertahankan nilai. Saya tidak tahu tentang Python atau Ruby.) Ini bisa menjadi berat setelah tiga kasus atau lebih, tetapi jika Anda memiliki lebih banyak dari tiga kasus, Anda mungkin juga memiliki desain perangkat lunak yang buruk.

Switch umum telah mengatakan di atas:

 switch(x){
  predicate1:
     dosomething();
  predicate2:
     dosomethingelse();
 }

Dalam Haskell:

  switch' :: a -> [(a -> Bool, b)] -> b
  switch' a [] = undefined
  switch' a (f,b):xs = if f a
                     then b
                      else switch' a xs

Dalam C # saya ingin menggunakan yang sederhana switch () { ... }, tetapi dapat diperluas dengan ekspresi seperti:

switch (value)
{
  // string-based operators:
  case begins "Maria": // to catch Maria Carey
    break;
  case ends "Washington": // to catch George Washington
    break;
  case like "ph": // to catch Phil, Phillip, Sophie
    break;
  case between "Aaron" and "April": // to catch all names between
    break;

  // use non-static variables in case expression:
  case Dao.GetDefaultBabyName():
    break;

  // continuable cases without breaking
  case "John":
    bonus = 25;
  case "Peter":
    salary = 500;
    break;

  // jumps between cases
  case "Aleron":
    // do something
    break;
  case "Bella":
    // do something
    jump "Aleron";
    break;

}

Dan seterusnya. Sama dengan angka atau jenis lain (yang mendukung IComparable, IConvertible, ...)

Ini mungkin membuat kode saya lebih singkat dan mudah dibaca.

Ini adalah pertanyaan yang menyenangkan, seperti yang dikatakan @Macneil.

Struktur kontrol favorit saya yang tidak biasa, yang saya (batuk sederhana) temukan, adalah eksekusi diferensial .

Ini memiliki kegunaan tertentu. Bagi saya, penggunaan yang luar biasa dalam pemrograman antarmuka pengguna, yang merupakan contoh dari masalah yang lebih umum dari mempertahankan data yang berlebihan dalam korespondensi. Di satu sisi, ada data aplikasi, dan di sisi lain, ada kontrol UI, yang harus disimpan dalam perjanjian. Ini kedengarannya seperti "mengikat" tetapi sebenarnya ada lebih banyak untuk itu.

Biasanya saya mengimplementasikannya dengan macro di C atau C ++. Dalam C # saya harus melakukannya dengan pernyataan yang mengembang. Itu menyakitkan, tetapi berhasil.

Setelah saya menerapkannya dalam hal Lisp macro, dan kemudian itu sangat bersih. Itu tidak memerlukan kehati-hatian dari pihak programmer. Saya bisa melakukan hal yang sama dalam bahasa terstruktur lain jika saya mengambil kesulitan untuk menulis parser lengkap dan kemudian menghasilkan semua hal yang benar. Itu proyek besar, dan saya belum melakukannya.

Struktur kontrol "tradisional" seperti fortentang mengendalikan orang yang bekerja, membuatnya tunduk pada ideologi korup dari elit kapitalis yang berkuasa. Itu sebabnya saya menggunakan struktur kontrol alternatif seperti ph0rsebagai gantinya. Ini seperti for, tetapi lebih radikal: Anda tidak akan ketahuan ph0rmengenakan jas dan dasi, semburkan BS perusahaan. ph0rtetap nyata, bung.

Perangi kekuatan!

forLoop paling sederhana-

for(100)
{
    //Will run for 100 times
}


for(i)
{
    //Will run for i times while i must be a positive integer
}


for(i as a)
{
    //Will run for i times while i must be a positive integer
    //and a is the incremental loop variable starting from 0 and 
    //scoped within the loop
}


for(i as a=2)
{
    //Will run for i times while i must be a positive integer
    //and a is the incremental loop variable starting from 2 and 
    //scoped within the loop
}