“Ne zaman” ifadesi diye bir şey var mı? [kapalı]

"Ne zaman" vakalarını işleyebilecek bir dil veya dil özelliği var mı? Yani, herhangi bir koşul veya bağlamda, herhangi bir koşul gerçekleştiğinde, çalıştırılacak ek kod belirtilebilir mi?

Bunun ifbelirli bir kapsamda olması ve açık bir şekilde yazılması gereken bir basitten farklı olduğuna dikkat edin. Bu cümle neredeyse if, programın yürütülmesinden sonraki her durum için geçerli olana benzer olacaktır.

Sorunuz net değil, ancak Gözlemci deseni aradığınız şey gibi görünüyor http://en.wikipedia.org/wiki/Observer_pattern

Sözdizimi açısından, birkaç dilde bir whenanahtar kelime var, ancak bunu tarif ettiğiniz şekilde kullanan herhangi bir dilden habersizim.

'X meydana geldiğinde, Y yapın' deseni, yön odaklı programlamanın çekirdeğidir: doğrusal bir akış tanımlamak yerine, işleyicileri belirli koşullara bağlarsınız (bir 'olaya' '' abone olmak '). Bu tür programlama, programın temel rutininin bir olay dağıtıcısı olduğu GUI uygulamalarında popülerdir.

Bazı diller, dil yapıları aracılığıyla bu tür mekanizmaları sağlamak için kapsamlı sözdizimi özelliklerine sahiptir; bir örnek, delegeleri ve etkinlikleri ile C # olacaktır:

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

Diğer diller OOP yapılarını kullanır (Gözlemci deseni, olay dinleyicileri vb.); Java'da bir örnek (Java'm biraz paslı, bu yüzden düzenlemekten çekinmeyin):

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

Yine başka bir yaklaşım, basit eski geri aramalar kullanmaktır. Javascript örneği:

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

Henüz kimse söz vardır INTERCAL 'ın derzlerinde :

COMEFROM başlangıçta şaka montaj dili talimatları listelerinde görüldü ('CMFRM' olarak). 1973 yılında R. Lawrence Clark tarafından Edsger Dijkstra'nın Zarar Gördüğü Beyanına Git yazısına yanıt olarak yazılan bir Datamation makalesinde ele alınmıştır. COMEFROM sonunda ezoterik programlama dili INTERCAL'in C-INTERCAL varyantında ve daha da belirsiz olan 'hesaplanmış COMEFROM' ile birlikte uygulandı. Ayrıca 'atanmış COME FROM' ve 'DONT' anahtar kelimesi (mevcut 'DO' döngüsünü tamamlamak için) için Fortran önerileri de vardı.

1 Nisan 2004'te Richie Hindle, Python programlama dili için hem GOTO'nun hem de COMEFROM'un bir uygulamasını yayınladı. April Fools 'Day'de yayınlanmasına ve ciddi kullanım için tasarlanmamasına rağmen, sözdizimi geçerlidir ve uygulama tamamen çalışır.

Tcl dili, bir değişken ayarlandığında (veya okuma veya silme işlemi yapıldığında rastgele kod yürütülmesine izin veren değişkenler üzerinde izlere sahiptir , ancak bu burada daha az önemlidir). Bu rastgele kod, bir ifadenin değerlendirilmesini ve varsa bazı kodların yürütülmesini kolayca içerebilir. Ana kısıtlama, yerel değişkenler için bunu yapabilmenize rağmen, genellikle çok yararlı olmadığı için çok kısa ömürlü olma eğilimindedir, bu nedenle bu tür şeyler genellikle küresel ve ad alanı değişkenleriyle sınırlıdır. (Tcl'nin kapanışı yok.)

Ama bunu yapıyorsanız, dikkatli olmalısınız. Resmi olarak reentrancy ile ilgili sorunlarınız olmasa da (iz, vücudun yürütülmesi sırasında devre dışı bırakılır) hala çok net olmayan bir kod yazmak ve çok karışıklığa neden olmak için harika bir yoldur. Performans isabeti oldukça önemli olabileceğinden, bir hata değişkeniyle (hata ayıklama dışında) kullanmak gerçekten de korkunç bir fikirdir.

Bir örnek (yukarıdaki bağlantılı kılavuz sayfasındaki koda dayalı olarak) göstermektedir.

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

Bu noktadan sonra, yeni bir tamsayı olan $fooveya $baryeni bir tam sayı olan her zaman, ikisinin $foobarürünü olur. Otomatik olarak.

Tcl ayrıca, kodların komutların yürütülmesi, komutların silinmesi, zamanlayıcılar, soketlerde kullanılabilir hale gelmesi vb. Gibi diğer tetikleyiciler üzerinde çalıştırılmasına da izin verir. GUI olayları. Tcl'nin aslında çok güçlü bir olaya yönelik dil olduğunu söylemek doğrudur (bu özelliklerin hiçbirini hiç kullanmayan bir kodu kolayca yazabilseniz bile).

Olay işleme gibi bir şey mi?

func () handles olayı yerine

olay ne zaman işliyor diyorsun

Ya da, belki belirli bir değişkene geri arama?

Evet, Perl'de ifade değiştirici olarak böyle bir anahtar kelime var:

say 'Well done!'        when 'A';

Ayrıca switch ifadesinin bir parçasıdır:

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

Does bu ( COMEFROMWikipedia'da açıklanan tablosu) saymak?

Özet:

COMEFROM, yürütme durumunu koddaki herhangi bir keyfi noktadan bir COMEFROM deyimine götürebileceği için GOTO'nın kabaca tersidir. Durum aktarımının gerçekleştiği koddaki nokta genellikle COMEFROM'a bir parametre olarak verilir. Aktarımın, belirtilen aktarım noktasındaki talimattan önce veya sonra gerçekleşip gerçekleşmediği kullanılan dile bağlıdır. Kullanılan dile bağlı olarak, aynı kalkış noktasına gönderme yapan birden fazla COMEFROM, geçersiz olabilir, deterministik olmayabilir, belirli bir tür öncelikte yürütülebilir, hatta Dişli Aralıklı'da görüldüğü gibi paralel veya başka bir şekilde eşzamanlı yürütme indükleyebilir.

Senkronize veya zaman uyumsuz bir zaman ifadesi olan bir dil mi arıyorsunuz?

Bana bir olay (/ abonelik / geri arama) modeli gibi geliyor.

Örneğin

conditionOwner.Condition += listener.WhenCondition

Koşul sahibi koşulun gerçekleştiğini bildirdiğinde, dinleyici WhenCondition () işlevini yapar.

Birkaç giriş değişkeninin durumunu (değişiklik sırasında) kontrol eden ve koşulu hesaplayan, daha sonra çıkışa bağlanan dinleyicinin bir girdi özelliğine sahip olan ve bu girdi değiştirildiğinde harekete geçen bir dönüştürücü ile bir ciltleme deseni kullanabilirsiniz.

Diller itibariyle, .NET (örneğin C #) senkronize abonelikler (olaylar) oluşturmuştur ve Reaktif Uzantıları (RX) asenkron abonelikler ekler.

Açıklama , belirli bir senaryoyu beklemek ve ardından yürütmek için tasarlanmış bir veritabanı tetikleyicisi gibi geliyor .

Wikipedia'dan:

Veritabanı tetikleyicisi, belirli bir tablodaki veya veritabanındaki görünümdeki belirli olaylara yanıt olarak otomatik olarak yürütülen yordamsal koddur. Tetikleyici çoğunlukla bilgilerin veritabanındaki bütünlüğünü korumak için kullanılır. Örneğin, çalışanlar tablosuna yeni bir kayıt (yeni bir çalışanı temsil eden) eklendiğinde, vergiler, tatiller ve maaşlar tablolarında da yeni kayıtlar oluşturulmalıdır.

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

Ne konuşuyorsun yaklaşık azdır sözdizimi daha yapısına . whenSonlu miktarda mantık yürüten when, sonra ifadeleri yürüten , sonra döngülere girip sonsuz döngüye devam ederek mantığı yeniden yürüten bir sistemde böyle bir ifadeye gerçekten sahip olabilirsiniz .

Örneğin, Windows programlama genellikle "olay tabanlıdır". Bir düğmenin Clicketkinliğine abone olmak, temelde "tıklandığında bunu yapın" anlamına gelir. Ancak, başlık altında olup bitenler bir mesaj işleme döngüsüdür. Kullanıcı düğmeyi tıklattığında Windows uygulamaya bir ileti gönderir ve uygulamadaki ileti işleme döngüsü uygun olay işleyiciyi çalıştırır.

Örneğin, C # 'daki olayları kullanırsanız, bunu bir ileti döngüsü olmadan yapabilirsiniz, ancak sınırlama, olayı önceden bildirmeniz gerektiğinden, whenherhangi bir türü izleyen bir artibrary deyimi yazamazsınız . durum. Belirli bir etkinliği beklemeniz gerekir.

Bir Von Neumann Mimarisinde bu davranışı elde etmek için, uygunsa, uygun kodu çalıştıran döngü boyunca her zaman tüm koşulları kontrol eden bir tür sonsuz döngü çalıştırmanız gerekir. Dahili olarak if/ thenveya switchifadelerin büyük bir listesini alırsınız . Çoğu masaüstü uygulaması ve web programcısı böyle bir yapı gördüklerinde kusarlar, bu yüzden Windows olay modeli gibi bir tür sözdizimsel şekere sarırsanız gerçekten lezzetli olur (kaputun altında olan şey bu olsa da).

Öte yandan, gömülü ürün yazılımı geliştirme, gerçek zamanlı yöneticiler veya endüstriyel denetleyiciler alanına bakarsanız, bu programlama modeli çok yaygındır. Örneğin, gerçek zamanlı bir programınız varsa, şunu ifade etmek isteyebilirsiniz:

outputA = input1 && input2

Kodun anlaşılması kolaydır (çünkü bildirimseldir). Ancak, çalışmasını sağlamak için sıkı bir döngüde yürütmeniz gerekir. outputADöngü boyunca her seferinde yeniden değerlendirirsiniz . Birçok masaüstü veya web programcısı bunu istemez çünkü verimsizdir. Onlara göre, yeniden değerlendirmeniz gereken tek zaman ne outputAzaman input1veya input2değişir. Sizin tarif ettiğiniz gibi bir şey görmeyi tercih ederler:

when input1 changes
    evaluateOutputA()

when input2 changes
    evaluateOutputA()

evaluateOutputA()
    outputA = input1 && input2

Şimdi bu istediğiniz şeyse (ve kişisel olarak bu fikri tercih etmiyorum) ve hedefiniz verimlilikse, o zaman hala işlemcinin kaputun altında ne yaptığını kendinize sormanız gerekir. Açıkçası, her seferinde giriş durumlarını önceki giriş durumlarıyla karşılaştıran ve her değiştiğinde uygun kodu yürüten bir tür döngü çalışıyor. Bu yüzden gerçekten daha az verimli ve okunması daha zor ve bakımı daha zor.

Öte yandan, input1değişiklikler sırasında yapmanız gereken iş whenönemliyse , yan tümceniz mantıklı olabilir. PLC'lerde bu tür talimatlara "yükselen kenar algılama" denir. Durumunu input1son döngüde kaydeder, bu sefer değerle karşılaştırır ve son durum yanlışsa ve bu durum doğruysa mantığı yürütür.

Von Neumann Mimarisi yoksa oyun değişir. Örneğin, VHDL'de bir FPGA programlıyorsanız , şunları yazarken:

outputA = input1 && input2

(... veya uygun VHDL sözdizimi olacaktır ne olursa olsun) daha sonra FPGA aslında yukarı öyle ki kablolu alır input1ve input2bir VE kapısının girişine bağlanmış ve Kapının çıkışı için kablolu outputA. Yani, sadece kodun anlaşılması kolay değil, aynı zamanda diğer tüm mantığa paralel olarak yürütülür ve etkilidir.

Beş IEC-61131-3 dilinden birinde programlanmış PLC veya PAC gibi endüstriyel bir denetleyiciden bahsederken, tipik durum bu tür bir düzenlemedir:

1. Girişleri okuyun ve bellekte saklayın
2. Ana programı yürüt
3. Çıkışları bellekten gerçek çıkışlara yazma
4. 1. adıma gidin

Bu, sistemin mimarisinde yerleşiktir, bu yüzden sadece şunları yazmanız beklenir:

outputA = input1 && input2

... ve sürekli bir döngüde yürütülür.

Bu makinelerde ayrıca kesme rutinleri vardır. Bunlar daha whençok bahsettiğiniz operatör için donanım seviyesi desteğine benzer . Donanım kesme harici olay hakkında, kod uygulanması için bir yöntemdir. Örneğin, bir ağ kartı veri beklettiğini söylediğinde, işlemci normalde bu verileri derhal okumalıdır, yoksa arabellek alanınız tükenir. Ancak, gerçek bir donanım kesintisi takmanız gereken miktar için, bir dil anahtar kelimesi eklemeye değer olduğundan şüphe duyuyorum. CPU giriş pinleri ile sınırlı olacaksınız ve dahili program durumunu test etmek istediğiniz anlaşılıyor.

Yani, geleneksel bir dilde (sonsuz çalışan sıkı bir döngü olmadan), "değerlendirme kodu ne zaman çalışır" sorusunu sormanız gerekir?

Eğer yazarsanız:

when A do
    launchNukes()

... ve Akeyfi bir boole ifadesi olduğunu varsayarsak , bu ifadeyi ne zaman yeniden değerlendireceğinizi nereden biliyorsunuz? Saf bir uygulama, her bellek yazıldıktan sonra yeniden değerlendirmeniz gerektiği anlamına gelir. Onu daraltabileceğinizi düşünebilirsiniz, ancak şunu düşünün:

when systemTime > actionTime do
    launchNukes()

systemTimeHer zaman değiştiğine dikkat edin (her okuduğunuzda farklı bir sayı alırsınız). Bu, tüm whenmaddelerinizin koşullu kısmının sürekli olarak yeniden değerlendirilmesi gerektiği anlamına gelir . Bu neredeyse imkansız (ve koşullu ifadenizin yan etkileri varsa ne olacağını bir saniye düşünün!)

Sonuç

whenBir mimaride yalnızca ana programı çalıştıran sonsuz bir döngüye dayalı bir deyim (tanımladığınız gibi) olabilir, ardından whenkoşullar bu döngüde false'dan true'ya giderse ifadeleri çalıştırırsınız . Bu mimari gömülü ve endüstriyel cihazlarda yaygın olsa da, genel amaçlı programlama dillerinde yaygın değildir.

AspectJ dil durumun tam olarak bu tür işlemek için bir çözümdür bir katıl Noktaya Modeli vardır.

AspectJ'deki Join-Point, bir Java programında, program yürütülürken oluşan dinamik bir olaydır. Örnek birleşim noktaları şunlardır: (1) Bir yöntem denir; (2) Bir yöntem yürütülür; (3) Bir kurucu denir; (4) Bir kurucu yürütülür; (5) Bir alan ayarlanmıştır; veya (6) Bir alana erişilir.

Daha sonra pointcuts adı verilen bu birleşme noktaları kümeleri oluşturabilirsiniz. Nokta kesimler daha sonra olağan küme teorisi biçiminde birleştirilebilir, tamamlanabilir ve kesişebilir. Diğer nokta kesimleri, değişkenlerin değerlerine / türlerine (örn., "Yalnızca x pozitif olduğunda", "yalnızca ayarlanan değer bu türden bir alt sınıf olduğunda") ve programın durumuna (" bu yöntem çağrılır, ancak yalnızca bu diğer yöntem bu iş parçacığının yığınındayken [bu yöntem dolaylı olarak adlandırılır] ").

Bu nokta kesimlerinin tümü programdaki olayları açıkladıktan sonra, bu olayları bildirmek için AspectJ kullanabilirsiniz . Etkinlik gerçekleşmeden önce ( beforetavsiye), etkinlik gerçekleştikten sonra ( aftertavsiye) veya gerçekleşen etkinlik yerine ( tavsiye) bir şey yapmayı seçebilirsiniz around.

Aroundtavsiye özellikle programlarınıza önbellek eklemek için yararlıdır: Bazı yöntem yürütüldüğünde, aynı hesaplamanın önceden yapılıp yapılmadığını görmek için bir tabloya bakın ve önbelleğe alınmış sürümü kullanın. AspectJ ile, önbelleğe almanın değer ekleyip eklemediğini bulmak için kodunuzdaki yüzlerce farklı noktada bu tür önbellek denemeleri yapabilirsiniz.

Açı yönelimli programlama dışındaki pek çok kişi AOP'nin çoğunlukla "günlük kaydı" ile ilgili olduğuna inanıyor. Günlüğü işlemek için AspectJ kullanabilirsiniz ve bunu oldukça iyi yapar ("bu paketteki tüm genel yöntemler çağrıldığında ve sonuçlarının / hata sonuçlarının ne olduğu" bu günlük dosyasına kaydet "). Ancak, AspectJ'de, Solucan Deliği Deseni adı verilen dinamik kapsamı simüle etmek için akıllı bir numara da dahil olmak üzere çok daha fazlası var [bkz. Slayt 23 ve aşağıdaki].

AOP dışında, [diğerleri tarafından belirtildiği gibi] Gözlemci Deseni içeren olay tabanlı programlama hakkında da konuşuyorsunuz. Çözeltiler arasındaki fark: (1) durumun nasıl tespit edildiği; (2) durumun ifade edildiği; ve (3) yürütülecek kodun olaya nasıl bağlı olduğu.

Nasıl / Bekle bildir kullanmak yakın Buna olacak gibi görünüyor:

Java bekleme / bildirme mekanizmasının aslında iş parçacıkları arasında iletişim kurmanın bir yolu olduğunu belirttik. Özetle, fikir aşağıdaki gibidir:

• bir veya daha fazla iplik bir sinyal bekler;
• başka bir evre gelir ve bekleyen evreleri bildirir (yani sinyal ile "uyandırır").

Bağlama bağlı olarak, buna yakın olabilecek bazı yapılar vardır, ancak gerçekten sorunuzu netleştirmeniz gerekir.

XSLT'de bir "when" ifadesi de var :

Öğe, bir dizi teste dayanarak bir hareket tarzını belirlemek için kullanılır. Her test bir elemanın içinde yapılır. Bir test başarılı olursa, elemanın gövdesi yürütülür. Hiçbir test başarısız olursa, varsayılan bir eylem belirtmek için bir öğe kullanılabilir:

XSLT "when" bir koşuldan çok bir anahtar gibi koşullu bir ifadedir . Ancak, ilk sorudaki "ne zaman" ile kastedilenin bağlamı tam olarak açıklığa kavuşmamıştır.

XSLT'leri, içeriği sunmak için çalıştığım bazı durumlarda GUI ortamında kullanılabilecek şekilde Sitecore CMS'de sıklıkla kullanıyorum.

İstediğinize Reaktif Programlama denir .

Değişkenlerin atandıkları ifadenin farkında olduğu bir programlama paradigmasıdır ve ifadenin bir bileşeni değiştiğinde, değişken ifadeyi yeniden değerlendirerek tepki verir , muhtemelen diğer benzer yeniden değerlendirmeleri bağımlılıklar zincirinde tetikler .

Genellikle bu reaktif davranış, reaktif bir değerin kendisini değerin yeniden değerlendirilmesini tetikleyen bir dizi olaya dinleyici olarak kaydettiği gözlemci modelinin akıllıca kullanılmasıyla elde edilir.

Bildiğim kadarıyla, çekirdeğinde reaktif programlamayı tamamen kucaklayacak bir programlama dili yoktur, ancak birçok dilde reaktif programlamanın şu veya bu şekilde faydaları sunan çok sayıda kütüphane vardır.

Veri bağlama çerçevelerinin çoğu, reaktif programlama uygulamaları olarak düşünülebilir .

Muhtemelen benden çok daha iyi, reaktif programlamanın ne hakkında olduğunu ve bir uygulamasının zaten mevcut tekniklerin üstünde ve üstünde ne sunacağını açıklayan " Gözlemci modelini reddetmek " adlı güzel bir makale var.

Lisp (ve Scheme dahil olmak üzere birçok dialetc'leri):

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

değerlendirir do-somethingve:

(when nil 'other-thing)

nilya da eşdeğerini değerlendirir .

Ben sadece hata işleme için böyle bir ifade biliyorum. Örneğin, BASIC'ler ON ERROR ...veya SQL * PLUS'larWHENEVER SQLERROR ...

Arbitraty koşulları için, koşulların gerçekleştiği anı yakalamak için son derece zeki bir derleyici veya oldukça pahalı bir kaba kuvvet (her ifadeden sonra kontrol edin) gerekir.

Donanım açıklama dilleri (Verilog ve VHDL) gibi veri akışı dillerinin bir özelliğidir.

Bunun dışında Ada ve istisna yönetim mekanizmasını düşünebilirim: Bir istisna işleyici tetiklenir, whenbir istisna ortaya çıkar.

Durum değişkenleri , kulağa bir yüklem gerçekleşene kadar iş parçacıklarının uyumasını sağlayan şeyler gibi geliyor.

Boost C uygular bunları ++, Apache Taşınabilir C. In Common Lisp için uygular bunları kullanmak istiyorum bordeaux-thread's make-condition-variable.

Drools'u bir dil olarak görüyorsanız, evet.

Bir örnek:

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, sinyalleri doğrudan kullanarak tapşunları yapabilir:

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

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

Powershell bunu bir try / nihayet bloğuyla bir çalışma döngüsü kullanarak işleyebilir:

$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
}

kullanarak Bekleyebilirsiniz 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
}

Referanslar

• Sinyal işleme - Rosetta Kodu

• Karar tabloları - Rosetta Kodu

Bunlara baktığımdan beri UZUN bir zaman oldu, bu yüzden yanılmış olabilirim.

Hatırladığım gibi, PL / I ve BASIC'in her ikisinin de "ON" ifadeleri vardı. PL / I'de konsept "ON DO" idi. BASIC dilinde, ifadenin genellikle bir GOSUB olduğu "ON" idi. Her iki dilde de, belirtilen koşul her gerçekleştiğinde, ilişkili ifadeler yürütüldü.

Bugün bunu yapmak istemezsiniz. Derleyici, koşulun nerede / ne zaman gerçekleşebileceğini anlamak için bir sürü iş yapmak zorundadır, böylece o noktada bir test oluşturabilir. İlişkili işleyiciye girdikten sonra, nereden geldiğinizi gerçekten bilmiyorsunuz, bu yüzden sizi oraya götürmek için neler olduğunu anlamanız gerekiyor ve muhtemelen nereden geldiğinize geri dönmek istemiyorsunuz.

OPS5 diline bir göz atabilirsiniz . Programları bir dizi koşul olarak yazılmıştır. Bir koşul karşılandığında, ilgili eylem gerçekleştirilir. Eylemler, durumu değiştirerek başka koşulların karşılanmasına neden olabilir. whenAnahtar kelimeyi kullanmasa da , temel olarak bir koşul karşılandığında "gerçekleştiğinde" eylemler gerçekleştirerek çalışır. Gönderen burada :

Bir OPS5 programı, temel veri yapılarının tanımlandığı bir bildirim bölümü ve ardından verilerin manipülasyonu için kuralların bulunduğu bir üretim bölümünden oluşur.

OPS5 programları, çalışan bellek öğelerini üretim belleğindeki kurallarla eşleştirerek ve eşleşen en baskın kuralı tetikleyerek (yürüterek) çalışır. Eşleştirme-Seçme-Yürütme döngüsü, program açıkça duruncaya kadar veya çalışan bellekle hiçbir kural eşleştirilinceye kadar devam eder.

90'ların başında Üniversite'deyken bu dilde basit bir metin macerası yazmak zorunda kaldım. İlginçti, ancak çoğu masaüstü veya mobil görev için ne kadar yararlı olacağından emin değilim. Gerçi bir arka uç ortamında mantıklı olabilir.

Haskell'de bir tane var. Ancak bu özel bir yapı değil, başka bir işlev http://hackage.haskell.org/packages/archive/base/latest/doc/html/Control-Monad.html#v:when

Çoğu OOP dilinde ekstra bir iş parçacığı oluşturmak mümkün olacaktır, bunu bağlam olarak yapın:

    while (!value)
{
}

//Execute code

Eh, her biri kendi durumu için anket yapan bir grup paralel iplik yazabilirsiniz. Bunun oldukça düşük performanslı bir uygulama olacağını düşünüyorum, ancak mümkün.