Apakah ada yang namanya pernyataan "kapan"? [Tutup]

Apakah ada fitur bahasa atau bahasa yang dapat menangani kasus "kapan"? Artinya, setiap kali kondisi menjadi benar, dalam lingkup atau konteks apa pun, kode tambahan itu dapat ditentukan untuk dieksekusi?

Perhatikan bahwa ini berbeda dari yang sederhana if, yang harus dalam ruang lingkup tertentu dan ditulis secara eksplisit. Klausa ketika ini akan hampir seperti ifyang diterapkan pada setiap kasus dalam pelaksanaan program setelahnya.

Pertanyaan Anda tidak jelas tetapi pola Pengamat tampaknya menjadi hal yang Anda cari http://en.wikipedia.org/wiki/Observer_pattern

Secara sintaksis, beberapa bahasa memiliki whenkata kunci, tetapi saya tidak mengetahui bahasa apa pun yang menggunakannya seperti yang Anda gambarkan.

Pola 'ketika X terjadi, lakukan Y' adalah jenis inti dari pemrograman berorientasi aspek: alih-alih mendefinisikan aliran linier, Anda menghubungkan penangan ke kondisi tertentu (alias 'berlangganan' ke 'acara'). Pemrograman semacam ini populer di aplikasi GUI, di mana inti rutin dari program ini adalah pengirim acara.

Beberapa bahasa memiliki fitur sintaksis yang luas untuk menyediakan mekanisme seperti itu melalui konstruksi bahasa; contohnya adalah C # dengan delegasi dan acara:

// 'when btnOK is clicked, run HandleOKClick'
btnOK.Clicked += this.HandleOKClick;

Bahasa lain menggunakan konstruksi OOP (pola Observer, pendengar acara, dll.; Contoh di Jawa (Java saya agak berkarat, jadi silakan diedit):

Foobar f = this;
btnOK.registerClickHandler(
    new ClickHandler {
        public void handleClick(Event e) {
            f.handleOKClick(e);
        }
    });

Namun pendekatan lain menggunakan callback tua biasa. Contoh dalam javascript:

var btnOK = $('btnOK');
btnOK.click(handleOKClick);

Tidak ada yang belum telah disebutkan INTERCAL 's comefrom :

COMEFROM awalnya terlihat dalam daftar instruksi bahasa joke assembly (sebagai 'CMFRM'). Itu diuraikan dalam sebuah artikel Datamation oleh R. Lawrence Clark pada tahun 1973, ditulis dalam menanggapi surat Edsger Dijkstra, Go To Statement Dianggap Berbahaya. COMEFROM akhirnya diimplementasikan dalam varian C-INTERCAL dari bahasa pemrograman esoterik INTERCAL bersama dengan 'COMEFROM terkomputasi' yang bahkan lebih tidak jelas. Ada juga proposal Fortran untuk 'ditugaskan COME FROM' dan kata kunci 'DONT' (untuk melengkapi loop 'DO' yang ada).

Pada 1 April 2004, Richie Hindle menerbitkan implementasi GOTO dan COMEFROM untuk bahasa pemrograman Python. Meskipun dirilis pada Hari April Mop dan tidak dimaksudkan untuk penggunaan serius, sintaksnya valid dan implementasinya berfungsi penuh.

Bahasa Tcl memiliki jejak pada variabel yang memungkinkan kode arbitrase dieksekusi setiap kali variabel diatur (atau membaca atau menghapus, tapi itu kurang penting di sini). Kode arbitrer itu dapat dengan mudah memasukkan evaluasi ekspresi dan mengeksekusi beberapa kode jika ada. Kendala utama adalah bahwa sementara Anda dapat melakukan ini untuk variabel lokal, itu umumnya tidak sangat berguna karena mereka cenderung memiliki rentang hidup yang sangat pendek, sehingga hal-hal seperti itu biasanya terbatas pada variabel global dan namespace. (Tcl tidak memiliki penutupan.)

Tetapi jika Anda melakukan ini, Anda harus berhati-hati. Meskipun Anda tidak secara resmi memiliki masalah dengan reentrancy (jejak dinonaktifkan selama eksekusi tubuh) itu masih merupakan cara yang bagus untuk menulis kode yang sangat tidak jelas dan menyebabkan banyak kebingungan. Ini juga merupakan ide yang sangat buruk untuk menggunakannya dengan variabel loop (selain untuk debugging) karena hit kinerja bisa sangat signifikan.

Contoh (berdasarkan kode dari halaman manual tertaut di atas) menggambarkan.

set foo 1
set bar 2
proc doMult args {
    global foo bar foobar
    set foobar [expr {$foo * $bar}]
}
trace add variable foo write doMult
trace add variable bar write doMult
doMult

Sejak saat itu dan seterusnya, setiap saat baik yang menjadi $fooatau $barmenjadi bilangan bulat baru, $foobarmenjadi produk keduanya. Secara otomatis.

Tcl juga memungkinkan pengaturan kode untuk dijalankan pada jenis pemicu lain, seperti eksekusi perintah, penghapusan perintah, timer, data menjadi tersedia di soket, dll. Dengan perpustakaan Tk ditambahkan, ini diperluas untuk mencakup seluruh rangkaian besar acara GUI juga. Memang benar untuk mengatakan bahwa Tcl sebenarnya bahasa yang sangat berorientasi pada peristiwa (bahkan jika Anda dapat dengan mudah menulis kode yang tidak pernah menggunakan salah satu dari fitur itu juga).

Sesuatu seperti penanganan acara?

bukannya func () menangani acara

Anda mengatakan ketika acara melakukan func

Atau, mungkin panggilan balik pada variabel tertentu?

Ya, ada kata kunci di Perl, sebagai pengubah pernyataan:

say 'Well done!'        when 'A';

Itu juga bagian dari pernyataan pergantian:

given ($foo) {
    when (/^abc/) { $abc = 1; }
    when (/^def/) { $def = 1; }
    when (/^xyz/) { $xyz = 1; }
    default { $nothing = 1; }
}

Apakah ini ( COMEFROMpernyataan yang dijelaskan di Wikipedia) dihitung?

Ringkasan:

COMEFROM kira-kira kebalikan dari GOTO dalam hal itu dapat mengambil status eksekusi dari titik sembarang dalam kode ke pernyataan COMEFROM. Titik dalam kode tempat transfer status terjadi biasanya diberikan sebagai parameter ke COMEFROM. Apakah transfer terjadi sebelum atau setelah instruksi pada titik transfer yang ditentukan tergantung pada bahasa yang digunakan. Bergantung pada bahasa yang digunakan, beberapa COMEFROM yang merujuk pada titik keberangkatan yang sama mungkin tidak valid, tidak deterministik, dieksekusi dalam semacam prioritas yang ditentukan, atau bahkan mendorong eksekusi paralel atau sebaliknya seperti yang terlihat pada Threaded Intercal.

Apakah Anda mencari bahasa dengan pernyataan sinkron atau asinkron saat?

Kedengarannya seperti pola acara (/ berlangganan / panggil balik) bagi saya.

Misalnya

conditionOwner.Condition += listener.WhenCondition

Setiap kali pemilik kondisi memberitahukan bahwa kondisi telah terjadi, pendengar akan melakukan WhenCondition ().

Anda dapat menggunakan pola penjilidan dengan konverter yang memeriksa keadaan beberapa variabel input (saat perubahan) dan menghitung kondisinya, kemudian meminta properti input dari pendengar terikat ke output dan bertindak ketika input tersebut diubah.

Sebagai bahasa, .NET misalnya (yaitu C #) telah dibangun di langganan sinkron (peristiwa) dan Ekstensi Reaktif (RX) menambahkan langganan asinkron.

Deskripsi terdengar seperti pemicu basis data yang dirancang untuk menunggu skenario tertentu dan kemudian mengeksekusi.

Dari Wikipedia:

Pemicu basis data adalah kode prosedural yang secara otomatis dieksekusi sebagai respons terhadap peristiwa tertentu pada tabel tertentu atau tampilan dalam database. Pemicunya sebagian besar digunakan untuk menjaga integritas informasi pada database. Misalnya, ketika catatan baru (mewakili pekerja baru) ditambahkan ke tabel karyawan, catatan baru harus dibuat juga dalam tabel pajak, liburan, dan gaji.

http://en.wikipedia.org/wiki/Database_trigger

Apa yang Anda bicarakan kurang sintaksis daripada struktur . Anda benar-benar hanya dapat memiliki whenpernyataan seperti itu dalam sistem yang mengeksekusi jumlah logika yang terbatas, kemudian mengeksekusi whenpernyataan, kemudian memutar dan mengeksekusi logika lagi, melanjutkan dalam loop yang tak terbatas.

Misalnya pemrograman Windows biasanya "berbasis acara". Berlangganan acara tombol pada Clickdasarnya berarti "lakukan ini saat diklik". Namun, apa yang terjadi di bawah tenda adalah loop pemrosesan pesan. Windows mengirim pesan ke aplikasi ketika pengguna mengklik tombol, dan loop pemrosesan pesan di aplikasi menjalankan pengendali acara yang sesuai.

Jika Anda menggunakan acara di, misalnya, C #, Anda dapat melakukan ini tanpa loop pesan, tetapi batasannya adalah Anda harus mendeklarasikan acara sebelumnya, jadi Anda tidak dapat menulis whenpernyataan artibrary yang mengawasi segala jenis negara. Anda harus menunggu acara tertentu.

Untuk mendapatkan perilaku ini dalam Arsitektur Von Neumann Anda harus menjalankan semacam infinite loop yang memeriksa semua kondisi setiap kali melalui loop menjalankan kode yang sesuai jika sesuai. Internal Anda hanya mendapatkan daftar besar if/ thenatau switchpernyataan. Sebagian besar aplikasi desktop dan pemrogram web akan muntah jika mereka melihat konstruksi seperti itu sehingga benar-benar hanya enak jika Anda membungkusnya dengan semacam gula sintaksis seperti model acara Windows (meskipun itulah yang terjadi di bawah tenda).

Di sisi lain, jika Anda melihat bidang pengembangan firmware tertanam, eksekutif waktu nyata, atau pengontrol industri, model pemrograman ini sangat umum. Misalnya, jika Anda memiliki program waktu nyata, Anda mungkin ingin mengungkapkan:

outputA = input1 && input2

Kode ini mudah dipahami (karena bersifat deklaratif). Namun, untuk membuatnya bekerja, Anda harus menjalankannya dalam lingkaran yang ketat. Anda mengevaluasi kembali outputAsetiap kali melalui loop. Banyak pemrogram desktop atau web tidak akan menyukai ini karena tidak efisien. Bagi mereka, satu-satunya waktu Anda harus mengevaluasi kembali outputAadalah kapan input1atau input2berubah. Mereka lebih suka melihat sesuatu yang lebih seperti Anda gambarkan:

when input1 changes
    evaluateOutputA()

when input2 changes
    evaluateOutputA()

evaluateOutputA()
    outputA = input1 && input2

Sekarang jika ini yang Anda inginkan (dan secara pribadi saya tidak suka ide ini), dan tujuan Anda adalah efisiensi, maka Anda masih harus bertanya pada diri sendiri apa yang sedang dilakukan prosesor di bawah tenda. Jelas masih ada semacam loop berjalan yang membandingkan status input ke status input sebelumnya setiap kali, dan mengeksekusi kode yang sesuai setiap kali ada perubahan. Jadi sebenarnya ini kurang efisien dan lebih sulit untuk dibaca dan lebih sulit untuk dipertahankan.

Di sisi lain, jika pekerjaan yang harus Anda lakukan ketika input1perubahan signifikan, maka whenklausa Anda mungkin masuk akal. Dalam PLC jenis instruksi ini disebut "deteksi tepi naik". Ini menyimpan keadaan input1pada saat terakhir melalui loop, membandingkannya dengan nilai saat ini, dan mengeksekusi logika jika keadaan terakhir salah dan keadaan ini benar.

Jika Anda tidak memiliki Arsitektur Von Neumann, maka gamenya berubah. Misalnya jika Anda memprogram FPGA dalam VHDL , maka saat Anda menulis:

outputA = input1 && input2

(... Atau apa pun sintaks VHDL yang sesuai akan) maka FPGA benar-benar akan ditransfer sedemikian rupa input1dan input2ditransfer ke input gerbang AND, dan output dari gerbang AND ditransfer ke outputA. Jadi, kode ini tidak hanya mudah dimengerti, tetapi juga dijalankan secara paralel dengan semua logika lainnya, dan juga efisien.

Saat Anda berbicara tentang pengontrol industri seperti PLC atau PAC, yang diprogram dalam salah satu dari lima bahasa IEC-61131-3, kasus umumnya adalah pengaturan seperti ini:

1. Baca input dan simpan di memori
2. Jalankan program utama
3. Tulis output dari memori ke output aktual
4. Lanjutkan ke langkah 1

Ini dibangun ke dalam arsitektur sistem, jadi diharapkan Anda hanya akan menulis:

outputA = input1 && input2

... dan itu akan dieksekusi dalam satu loop berkelanjutan

Ada juga interupsi rutin di mesin ini. Ini lebih seperti dukungan tingkat perangkat keras untuk whenoperator yang sedang Anda bicarakan. The interrupt hardware merupakan sarana mengeksekusi beberapa kode pada sebuah peristiwa eksternal. Misalnya, ketika kartu jaringan mengatakan bahwa ia memiliki data yang menunggu, prosesor biasanya harus segera membaca data itu atau Anda akan kehabisan ruang buffer. Namun, untuk berapa kali Anda perlu mengaitkan interupsi perangkat keras yang sebenarnya, saya ragu memasukkan kata kunci bahasa untuk itu bermanfaat. Anda akan terbatas pada pin input CPU, dan sepertinya Anda ingin menguji status program internal.

Jadi, dalam bahasa tradisional (tanpa loop ketat yang berjalan tanpa batas) Anda harus mengajukan pertanyaan, "kapan kode evaluasi berjalan"?

Jika Anda menulis:

when A do
    launchNukes()

... dan dengan asumsi Aadalah ekspresi boolean yang sewenang-wenang, bagaimana Anda tahu kapan harus mengevaluasi kembali ekspresi itu? Implementasi yang naif berarti Anda harus mengevaluasi kembali setelah setiap memori tunggal ditulis. Anda mungkin berpikir bahwa Anda dapat mempersempitnya, tetapi pertimbangkan ini:

when systemTime > actionTime do
    launchNukes()

Perhatikan bahwa systemTimeselalu berubah (setiap kali Anda membacanya, Anda akan mendapatkan nomor yang berbeda). Ini berarti bahwa bagian bersyarat dari semua whenklausa Anda harus dievaluasi ulang secara terus menerus. Itu hampir mustahil (dan pertimbangkan sejenak apa yang terjadi jika ekspresi kondisional Anda memiliki efek samping!)

Kesimpulan

Anda hanya dapat memiliki whenpernyataan (seperti yang Anda gambarkan) dalam arsitektur berbasis di sekitar loop tak terbatas yang menjalankan program utama, lalu jalankan whenpernyataan jika kondisinya berubah dari false menjadi true pada loop ini. Meskipun arsitektur ini umum di perangkat yang disematkan dan industri, itu tidak umum dalam bahasa pemrograman tujuan umum.

Bahasa AspectJ memiliki Model Join-Point, yang merupakan salah satu solusi untuk menangani situasi semacam ini.

Join-Point di AspectJ adalah peristiwa dinamis dalam program Java yang terjadi saat program dijalankan. Contoh titik-bergabung adalah: (1) Suatu metode disebut; (2) Suatu metode dijalankan; (3) Konstruktor disebut; (4) Konstruktor dieksekusi; (5) Bidang diatur; atau (6) Bidang diakses.

Anda kemudian dapat membuat set poin-poin bergabung ini, yang disebut pointcuts. Pointcuts kemudian dapat digabungkan, dilengkapi, dan berpotongan dengan cara teori himpunan yang biasa. Pemotongan poin lain dapat dikondisikan pada nilai / tipe variabel (mis., "Hanya ketika x positif", "hanya ketika nilai yang ditetapkan adalah subkelas dari tipe ini") dan berdasarkan pada keadaan program ("ketika metode ini dipanggil, tetapi hanya ketika metode lain ini ada di tumpukan utas ini [artinya metode itu secara tidak langsung memanggilnya] ").

Setelah semua pointcuts ini menjelaskan peristiwa dalam program, Anda dapat menggunakan AspectJ untuk menyarankan acara ini. Anda dapat memilih untuk melakukan sesuatu sebelum acara terjadi ( beforesaran), setelah acara terjadi ( aftersaran), atau alih-alih acara terjadi ( aroundsaran).

Aroundsaran sangat membantu untuk menambahkan caching ke program Anda: Ketika beberapa metode dijalankan, cari di tabel untuk melihat apakah perhitungan yang sama telah dilakukan dan, jika demikian, gunakan versi cache. Dengan AspectJ, ini sangat ringan dan ekspresif sehingga Anda dapat melakukan percobaan caching seperti itu pada ratusan titik berbeda dalam kode Anda untuk menemukan apakah dan di mana caching menambah nilai.

Banyak orang di luar pemrograman berorientasi aspek percaya AOP kebanyakan tentang "logging." Anda dapat menggunakan AspectJ untuk menangani pencatatan, dan melakukannya dengan sangat baik ("catat dalam file log ini ketika semua metode publik dalam paket ini dipanggil, dan apa hasil / kesalahannya"). Tetapi ada banyak hal lain untuk AspectJ, termasuk trik cerdas untuk mensimulasikan lingkup dinamis yang disebut Pola Lubang Cacing [lihat slide 23 dan berikut].

Di luar AOP, Anda juga berbicara tentang pemrograman berbasis acara, yang mencakup [seperti yang telah dicatat orang lain] Pola Observer. Perbedaan antara solusi adalah: (1) bagaimana kondisi terdeteksi; (2) di mana kondisi diungkapkan; dan (3) bagaimana-kode-untuk-mengeksekusi terikat ke acara.

Cara menggunakan Notify / Wait sepertinya dekat dengan ini:

Kami telah menyebutkan bahwa mekanisme menunggu / memberi tahu Java pada dasarnya adalah cara untuk berkomunikasi antar utas. Singkatnya, idenya adalah sebagai berikut:

• satu atau lebih utas duduk menunggu sinyal;
• utas lainnya datang dan memberi tahu utas yang menunggu (yaitu "membangunkannya" dengan sinyal).

Tergantung pada konteksnya ada beberapa struktur yang bisa dekat dengan ini tetapi Anda benar-benar harus mengklarifikasi pertanyaan Anda.

Ada juga pernyataan "kapan" di XSLT :

Elemen ini digunakan untuk menentukan satu tindakan berdasarkan serangkaian tes. Setiap tes dilakukan di dalam suatu elemen. Jika tes berhasil, badan elemen dieksekusi. Jika tidak ada tes gagal maka elemen dapat digunakan untuk menentukan tindakan default:

XSLT "kapan" adalah pernyataan kondisional, lebih mirip saklar daripada if. Namun, konteks apa yang dimaksud dengan "kapan" dalam pertanyaan awal tidak diklarifikasi dengan baik.

Saya menggunakan XSLT cukup sering di CMS Sitecore tempat saya bekerja untuk menyajikan konten sehingga dapat digunakan dalam lingkungan GUI dalam beberapa kasus.

Apa yang Anda minta disebut Pemrograman Reaktif .

Ini adalah paradigma pemrograman di mana variabel menyadari ekspresi yang telah mereka tetapkan dan setiap kali komponen ekspresi berubah, variabel bereaksi dengan mengevaluasi kembali ekspresi, mungkin memicu re-evaluasi serupa lainnya di rantai ketergantungan. .

Biasanya perilaku reaktif ini dicapai melalui penggunaan pola pengamat yang cerdas, di mana nilai reaktif mendaftarkan dirinya sebagai pendengar serangkaian peristiwa yang memicu evaluasi ulang nilai.

Sepengetahuan saya, tidak ada bahasa pemrograman yang sepenuhnya merangkul pemrograman reaktif dalam intinya, tetapi ada banyak perpustakaan dalam banyak bahasa yang menawarkan manfaat pemrograman reaktif dengan satu atau lain cara.

Sebagian besar kerangka kerja pengikatan data dapat dianggap sebagai implementasi dari pemrograman reaktif .

Ada sebuah makalah yang bagus tentang " Deprecating the observer pattern ", yang mungkin akan menjelaskan jauh lebih baik daripada yang pernah saya bisa, tentang apa itu pemrograman reaktif dan apa yang akan ditawarkan oleh implementasi dari itu di atas teknik yang sudah ada.

Lisp (dan banyak dialetnya, termasuk Skema) memilikinya:

(when (> 2 1) 'do-something)

mengevaluasi ke do-somethingdan:

(when nil 'other-thing)

mengevaluasi nilatau setara.

Saya tahu pernyataan semacam itu hanya untuk penanganan kesalahan. Misalnya, BASIC ON ERROR ...atau SQL * PLUSWHENEVER SQLERROR ...

Untuk kondisi arbitrase, diperlukan kompiler yang sangat pintar atau kekuatan kasar yang agak mahal (periksa setelah setiap pernyataan) untuk menangkap momen tepat ketika kondisi menjadi benar.

Ini adalah fitur bahasa aliran data seperti bahasa deskripsi perangkat keras (Verilog dan VHDL).

Selain itu, saya bisa memikirkan Ada dan mekanisme penanganan pengecualiannya: Handler pengecualian dipicu whenbeberapa pengecualian muncul.

Sepertinya Anda sedang mencari variabel kondisi , hal-hal yang memungkinkan utas untuk tidur sampai beberapa predikat menjadi kenyataan.

Dorongan alat mereka untuk C ++, yang Apache Portabel Runtime alat mereka untuk C. Dalam Common Lisp Anda akan menggunakan bordeaux-thread's make-condition-variable.

Jika Anda menganggap Drools sebagai bahasa, maka ya.

Sebuah contoh:

rule "Rule 08 - Debit"
when
    AccountingPeriod( $start : start, $end : end )
    $cashflow : AllocatedCashflow( $account : account, $date : date <= $end, $amount : amount, type==TypedCashflow.DEBIT )
    not AccountingPeriod( start < $start)
then 
    $account.setBalance($account.getBalance()-$amount);
    retract($cashflow);
end

Perl 6 dapat menangani sinyal secara langsung menggunakan tap:

signal(SIGINT).tap: {
    note "Took { now - INIT now } seconds.";
    exit;
}

for 0, 1, *+* ... * {
    sleep 0.5;
    .say;
}

sedangkan Powershell dapat menanganinya menggunakan run loop dengan blok coba / akhirnya:

$Start_Time = (Get-date).second
Write-Host "Type CTRL-C to Terminate..."
$n = 1
Try
{
    While($true)
    {
        Write-Host $n
        $n ++
        Start-Sleep -m 500
    }
}
Finally
{
    $End_Time = (Get-date).second
    $Time_Diff = $End_Time - $Start_Time
    Write-Host "Total time in seconds"$Time_Diff
}

seperti yang bisa Harapkan menggunakan trap:

package require Expect

proc sigint_handler {} {
    puts "elapsed time: [expr {[clock seconds] - $::start_time}] seconds"
    set ::looping false
}

trap sigint_handler SIGINT

set start_time [clock seconds]
set n 0
set looping true
while {$looping} {
    puts [incr n]
    after 500
}

Referensi

• Menangani sinyal - Kode Rosetta

• Tabel keputusan - Kode Rosetta

Sudah lama sejak saya melihat ini, jadi saya bisa saja salah.

Seingat saya, PL / I dan BASIC keduanya memiliki pernyataan "ON". Dalam PL / I, konsepnya adalah "ON DO". Dalam BASIC, itu "ON", di mana pernyataan biasanya GOSUB. Dalam kedua bahasa, setiap kali kondisi yang ditentukan menjadi benar, pernyataan terkait dieksekusi.

Anda tidak akan mau melakukan ini hari ini. Compiler pada dasarnya harus melakukan banyak pekerjaan, untuk mencari tahu di mana / kapan kondisinya dapat menjadi kenyataan, sehingga dapat menghasilkan tes pada saat itu. Begitu Anda berada di handler terkait, Anda tidak benar-benar tahu dari mana Anda berasal, jadi Anda harus mencari tahu apa yang terjadi untuk membawa Anda ke sana, dan Anda mungkin tidak ingin kembali ke tempat asal Anda.

Anda mungkin melihat bahasa OPS5 . Program-programnya ditulis sebagai serangkaian kondisi. Ketika suatu kondisi terpenuhi, tindakan yang sesuai dilakukan. Tindakan dapat mengubah keadaan, yang dapat menyebabkan kondisi lain terpenuhi. Meskipun tidak menggunakan whenkata kunci, itu pada dasarnya bekerja dengan melakukan tindakan "ketika" suatu kondisi terpenuhi. Dari sini :

Program OPS5 terdiri dari bagian deklarasi di mana konstruksi data dasar didefinisikan diikuti oleh bagian produksi di mana aturan untuk manipulasi data.

Program OPS5 dijalankan dengan mencocokkan elemen memori yang berfungsi dengan aturan dalam memori produksi dan menembakkan (mengeksekusi) aturan yang paling dominan yang cocok. Siklus Match-Select-Execute berlanjut hingga program berhenti secara eksplisit atau sampai tidak ada aturan yang dapat dicocokkan dengan memori yang bekerja.

Saya harus menulis petualangan teks sederhana dalam bahasa ini ketika saya berada di Universitas pada awal 90-an. Itu menarik, tapi saya tidak yakin seberapa berguna untuk sebagian besar tugas desktop atau seluler. Mungkin masuk akal di lingkungan backend.

Haskell memilikinya. Tapi itu bukan konstruksi khusus, hanya fungsi lain http://hackage.haskell.org/packages/archive/base/latest/doc/html/Control-Monad.html#v:when

Dalam sebagian besar bahasa OOP, dimungkinkan untuk menelurkan utas tambahan, buat ini sebagai konteksnya:

    while (!value)
{
}

//Execute code

Nah, Anda bisa menulis banyak utas paralel, masing-masing jajak pendapat untuk kondisi masing-masing. Saya kira itu akan menjadi aplikasi yang agak berkinerja rendah, tetapi itu mungkin.