Esiste una frase "quando"? [chiuso]

Esiste una funzione lingua o lingua che può gestire i casi "quando"? Cioè, ogni volta che una condizione diventa vera, in qualsiasi ambito o contesto, quel codice extra può essere specificato per l'esecuzione?

Si noti che questo è diverso da un semplice if, che deve essere in un ambito particolare e scritto esplicitamente. Questo quando la clausola sarebbe quasi come ifquella applicata ad ogni caso nell'esecuzione del programma dopo di esso.

La tua domanda non è chiara ma il modello Observer sembra essere la cosa che stai cercando http://en.wikipedia.org/wiki/Observer_pattern

Per quanto riguarda la sintassi, molte lingue hanno una whenparola chiave, ma non sono a conoscenza di alcuna lingua che la usi come la descrivi.

Il modello "quando si verifica X, esegui Y" è una specie del nucleo della programmazione orientata all'aspetto: invece di definire un flusso lineare, si agganciano i gestori a determinate condizioni (ovvero "sottoscrivendo" a un "evento"). Questo tipo di programmazione è popolare nelle applicazioni GUI, in cui la routine principale del programma è un dispatcher di eventi.

Alcune lingue hanno ampie funzionalità di sintassi per fornire tali meccanismi attraverso costrutti di linguaggio; un esempio potrebbe essere C # con i suoi delegati ed eventi:

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

Altre lingue usano costrutti OOP (modello Observer, listener di eventi, ecc .; un esempio in Java (il mio Java è un po 'arrugginito, quindi sentitevi liberi di modificare):

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

Ancora un altro approccio sta usando semplici vecchi callback. Esempio in JavaScript:

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

Nessuno ha ancora citato INTERCAL s' comefrom :

Inizialmente, COMEFROM veniva visualizzato negli elenchi delle istruzioni del linguaggio di assemblaggio degli scherzi (come "CMFRM"). È stato elaborato in un articolo di Datamation di R. Lawrence Clark nel 1973, scritto in risposta alla lettera Go To Statement Considered Harmful di Edsger Dijkstra. Il COMEFROM fu infine implementato nella variante C-INTERCAL del linguaggio di programmazione esoterico INTERCAL insieme al 'COMEFROM' ancora più oscuro calcolato. C'erano anche proposte Fortran per "assegnato COME FROM" e una parola chiave "DONT" (per integrare il ciclo "DO" esistente).

Il 1 ° aprile 2004, Richie Hindle ha pubblicato un'implementazione di GOTO e COMEFROM per il linguaggio di programmazione Python. Nonostante sia stato rilasciato il primo di aprile e non sia destinato a un uso serio, la sintassi è valida e l'implementazione funziona completamente.

Il linguaggio Tcl ha tracce sulle variabili che consentono l'esecuzione di codice arbitrario ogni volta che una variabile viene impostata (o letta o eliminata, ma qui è meno importante). Quel codice arbitrario può facilmente includere la valutazione di un'espressione e l'esecuzione di un codice se contiene. Il principale vincolo è che mentre puoi farlo per le variabili locali, non è generalmente molto utile perché tendono ad avere una durata molto breve, quindi tali cose sono generalmente limitate alle variabili globali e dello spazio dei nomi. (Tcl non ha chiusure.)

Ma se lo stai facendo, dovresti stare attento. Mentre non hai ufficialmente problemi con il rientro (la traccia è disabilitata per la durata dell'esecuzione del corpo) è ancora un ottimo modo per scrivere codice molto poco chiaro e causare molta confusione. È anche un'idea davvero terribile usarla con una variabile di loop (diversa da quella per il debug) poiché l'hit performance può essere piuttosto significativo.

Un esempio (basato sul codice dalla pagina di manuale collegata sopra) illustra.

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

Da quel momento in poi, ogni volta che uno $fooo $bardiventa un nuovo numero intero, $foobardiventa il prodotto dei due. Automaticamente.

Tcl consente inoltre di eseguire il codice di configurazione su altri tipi di trigger, come l'esecuzione di comandi, la cancellazione di comandi, i timer, i dati che diventano disponibili su socket, ecc. Con l'aggiunta della libreria Tk, questo viene espanso per includere un set molto ampio di eventi GUI pure. È vero che Tcl è in realtà un linguaggio fortemente orientato agli eventi (anche se puoi facilmente scrivere codice che non utilizza mai nessuna di quelle funzionalità).

Qualcosa come la gestione degli eventi?

invece di func () gestisce l'evento

dici quando un evento funziona

O forse una richiamata su una particolare variante?

Sì, esiste una tale parola chiave in Perl, come modificatore di istruzioni:

say 'Well done!'        when 'A';

Fa anche parte dell'istruzione switch:

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

Ha questo ( COMEFROMdichiarazione descritto su Wikipedia) conta?

Sommario:

COMEFROM è all'incirca l'opposto di GOTO in quanto può portare lo stato di esecuzione da qualsiasi punto arbitrario nel codice a un'istruzione COMEFROM. Il punto nel codice in cui si verifica il trasferimento di stato viene generalmente assegnato come parametro a COMEFROM. Se il trasferimento avviene prima o dopo l'istruzione nel punto di trasferimento specificato dipende dalla lingua utilizzata. A seconda della lingua utilizzata, più COMEFROM che fanno riferimento allo stesso punto di partenza possono essere non validi, non deterministici, essere eseguiti in una sorta di priorità definita o persino indurre un'esecuzione parallela o concorrente come si vede in Threaded Intercal.

Stai cercando una lingua con un'istruzione sincrona o asincrona quando?

Mi sembra un modello di evento (/ iscrizione / callback).

Per esempio

conditionOwner.Condition += listener.WhenCondition

Ogni volta che il proprietario della condizione notifica che si è verificata la condizione, il listener farà WhenCondition ().

È possibile utilizzare un modello di associazione con un convertitore che controlla lo stato di diverse variabili di input (al momento della modifica) e calcola la condizione, quindi si associa una proprietà di input del listener all'output e agisce quando tale input viene modificato.

A partire dai linguaggi, ad esempio .NET (ad es. C #) ha incorporato abbonamenti sincroni (eventi) e le sue estensioni reattive (RX) aggiungono abbonamenti asincroni.

La descrizione suona come un trigger di database progettato per attendere un determinato scenario e quindi eseguirlo.

Da Wikipedia:

Un trigger di database è un codice procedurale che viene automaticamente eseguito in risposta a determinati eventi su una determinata tabella o vista in un database. Il trigger viene utilizzato principalmente per mantenere l'integrità delle informazioni nel database. Ad esempio, quando un nuovo record (che rappresenta un nuovo lavoratore) viene aggiunto alla tabella dei dipendenti, i nuovi record dovrebbero essere creati anche nelle tabelle delle imposte, delle ferie e degli stipendi.

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

Quello di cui stai parlando è meno sintassi della struttura . Potresti davvero avere whenun'affermazione come quella in un sistema che esegue una quantità finita di logica, quindi esegue le whenistruzioni, quindi gira intorno ed esegue di nuovo la logica, continuando in un ciclo infinito.

Ad esempio, la programmazione di Windows è in genere "basata sugli eventi". Iscriversi Clickall'evento di un pulsante significa essenzialmente "farlo quando si fa clic". Tuttavia, quello che succede sotto il cofano è un ciclo di elaborazione dei messaggi. Windows invia un messaggio all'applicazione quando l'utente fa clic sul pulsante e il ciclo di elaborazione dei messaggi nell'applicazione esegue il gestore eventi appropriato.

Se usi eventi in, ad esempio, in C #, puoi farlo senza un ciclo di messaggi, ma la limitazione è che devi dichiarare l'evento in anticipo, quindi non puoi scrivere un'istruzione di artibrary whenche controlli qualsiasi tipo di stato. Devi aspettare un evento specifico.

Per ottenere questo comportamento in una Von Neumann Architecture devi eseguire una sorta di ciclo infinito che controlla tutte le condizioni ogni volta attraverso il ciclo che esegue il codice appropriato, se appropriato. Internamente ottieni solo un grande elenco di if/ theno switchdichiarazioni. La maggior parte delle applicazioni desktop e dei programmatori web vomiterebbero se vedessero un tale costrutto, quindi è davvero appetibile solo se lo avvolgi in una sorta di zucchero sintattico come il modello di eventi di Windows (anche se è quello che succede sotto il cofano).

D'altra parte, se si guarda al campo dello sviluppo del firmware incorporato, dei dirigenti in tempo reale o dei controller industriali, questo modello di programmazione è molto comune. Ad esempio, se hai un programma in tempo reale, potresti voler esprimere:

outputA = input1 && input2

Il codice è semplice da capire (perché è dichiarativo). Tuttavia, per farlo funzionare devi eseguirlo in un ciclo stretto. Rivaluta outputAogni volta attraverso il ciclo. Molti programmatori desktop o web non gradirebbero questo perché è inefficiente. Per loro, l'unica volta che dovresti rivalutare outputAè quando input1o input2cambia. Preferirebbero vedere qualcosa di più simile a quello che stai descrivendo:

when input1 changes
    evaluateOutputA()

when input2 changes
    evaluateOutputA()

evaluateOutputA()
    outputA = input1 && input2

Ora, se questo è quello che vuoi (e personalmente non preferisco questa idea), e il tuo obiettivo è l'efficienza, allora devi ancora chiederti cosa sta facendo il processore sotto il cofano. Ovviamente c'è ancora una sorta di ciclo in esecuzione che confronta gli stati di input con i precedenti stati di input ogni volta ed esegue il codice appropriato ogni volta che si cambia. Quindi è davvero meno efficiente ed è più difficile da leggere e più difficile da mantenere.

D'altra parte, se il lavoro che devi fare quando le input1modifiche sono significative, la tua whenclausola potrebbe avere un senso. Nei PLC questo tipo di istruzione è chiamato "rilevamento del fronte di salita". Salva lo stato di input1sull'ultima volta attraverso il ciclo, lo confronta con il valore questa volta ed esegue la logica se l'ultimo stato era falso e questo stato è vero.

Se non hai una Von Neumann Architecture, il gioco cambia. Ad esempio se stai programmando un FPGA in VHDL , quando scrivi:

outputA = input1 && input2

(... o qualunque la sintassi VHDL appropriato sarebbe) allora il FPGA fatto viene cablato tale che input1e input2sono cablati in ingresso ad una porta AND, e l'uscita della porta AND è cablato outputA. Quindi, non solo il codice è facile da capire, è anche eseguito in parallelo con tutte le altre logiche ed è efficiente.

Quando si parla di un controller industriale come un PLC o PAC, programmato in una delle cinque lingue IEC-61131-3, il caso tipico è questo tipo di disposizione:

1. Leggi gli input e memorizza in memoria
2. Eseguire il programma principale
3. Scrivi le uscite dalla memoria alle uscite effettive
4. Vai al passaggio 1

Questo è integrato nell'architettura del sistema, quindi è previsto che tu scriva:

outputA = input1 && input2

... e verrà eseguito in un ciclo continuo.

Esistono anche routine di interruzione in queste macchine. Questi sono più simili al supporto a livello hardware per l' whenoperatore di cui stai parlando. L' interruzione hardware è un mezzo per eseguire del codice su un evento esterno. Ad esempio, quando una scheda di rete indica che i dati sono in attesa, il processore deve normalmente leggerli immediatamente o si esaurisce lo spazio del buffer. Tuttavia, per la quantità di volte che è necessario agganciare un interrupt hardware reale, dubito che sia utile includere una parola chiave in lingua. Saresti limitato ai pin di input della CPU e sembra che tu voglia testare lo stato del programma interno.

Quindi, in un linguaggio tradizionale (senza un circuito chiuso che gira all'infinito) devi porre la domanda "quando viene eseguito il codice di valutazione"?

Se scrivi:

when A do
    launchNukes()

... e supponendo che Asia un'espressione booleana arbitraria, come fai a sapere quando rivalutare quell'espressione? Un'implementazione ingenua significherebbe che è necessario rivalutarla dopo ogni singola scrittura di memoria. Potresti pensare di poterlo restringere, ma considera questo:

when systemTime > actionTime do
    launchNukes()

Nota che systemTimecambia sempre (ogni volta che lo leggi otterrai un numero diverso). Ciò significa che la parte condizionale di tutte le whenclausole deve essere rivalutata continuamente. È quasi impossibile (e considera solo per un secondo cosa succede se la tua espressione condizionale ha effetti collaterali!)

Conclusione

Puoi avere solo whenun'istruzione (come quella che stai descrivendo) in un'architettura basata su un ciclo infinito che esegue il programma principale, quindi esegue le whenistruzioni se le condizioni sono passate da false a true su questo ciclo. Sebbene questa architettura sia comune nei dispositivi embedded e industriali, non è comune nei linguaggi di programmazione generici.

Il linguaggio AspectJ ha un modello Join-Point, che è una soluzione per gestire esattamente questo tipo di situazione.

Un Join-Point in AspectJ è un evento dinamico in un programma Java che si verifica durante l'esecuzione del programma. Esempi di punti di unione sono: (1) Viene chiamato un metodo; (2) Viene eseguito un metodo; (3) Viene chiamato un costruttore; (4) viene eseguito un costruttore; (5) Viene impostato un campo; oppure (6) Un campo è accessibile.

È quindi possibile creare set di questi punti di unione, chiamati punti di taglio. I tagli di punti possono quindi essere uniti, integrati e intersecati nel solito modo teorico impostato. Altri tagli di punti possono essere condizionati sui valori / tipi di variabili (ad es. "Solo quando x è positivo", "solo quando il valore impostato è una sottoclasse di questo tipo") e in base allo stato del programma ("quando questo metodo viene chiamato, ma solo quando questo altro metodo è nello stack di questo thread [che significa che quel metodo lo ha indirettamente chiamato] ").

Una volta che tutti questi punti descrivono gli eventi nel programma, è possibile utilizzare AspectJ per avvisare di questi eventi. Puoi scegliere di fare qualcosa prima che si verifichi l'evento ( beforeavviso), dopo che si verifica l'evento ( afteravviso) o invece che si verifichi l'evento ( aroundavviso).

Aroundi consigli sono particolarmente utili per aggiungere la memorizzazione nella cache ai programmi: quando viene eseguito un metodo, cercare in una tabella per vedere se lo stesso calcolo è già stato eseguito e, in tal caso, utilizzare la versione memorizzata nella cache. Con AspectJ, è così leggero ed espressivo che puoi fare tali esperimenti di memorizzazione nella cache su centinaia di punti diversi nel tuo codice al fine di trovare se e dove la cache aggiunge valori.

Molte persone al di fuori della programmazione orientata all'aspetto credono che AOP riguardi principalmente il "logging". Puoi usare AspectJ per gestire la registrazione, e lo fa abbastanza bene ("registra in questo file di registro quando vengono chiamati tutti i metodi pubblici in questo pacchetto e quali sono stati i loro risultati / risultati dell'errore"). Ma c'è molto di più in AspectJ, incluso un trucco intelligente per simulare l'ambito dinamico chiamato Worm Hole Pattern [vedi slide 23 e seguenti].

Al di fuori di AOP, stai anche parlando di una programmazione basata su eventi, che include [come altri hanno notato] l'Observer Pattern. La differenza tra le soluzioni è: (1) come viene rilevata la condizione; (2) dove viene espressa la condizione; e (3) come il codice da eseguire è legato all'evento.

Come usare Notifica / Attesa sembrerebbe essere vicino a questo:

Abbiamo menzionato che il meccanismo di attesa / notifica di Java è essenzialmente un modo per comunicare tra i thread. In breve, l'idea è la seguente:

• uno o più thread rimangono in attesa di un segnale;
• arriva un altro thread e notifica i thread in attesa (cioè "li sveglia / li" con il segnale).

A seconda del contesto, ci sono alcune strutture che possono essere vicine a questo, ma devi davvero chiarire la tua domanda.

C'è anche un'istruzione "when" in XSLT :

L'elemento viene utilizzato per determinare un corso di azione basato su una serie di test. Ogni test viene eseguito all'interno di un elemento. Se un test ha esito positivo, viene eseguito il corpo dell'elemento. Se nessun test ha esito negativo, è possibile utilizzare un elemento per specificare un'azione predefinita:

L'XSLT "quando" è un'istruzione condizionale, più simile a uno switch che a un if. Tuttavia, il contesto di cosa si intendesse per "quando" nella domanda iniziale non era molto ben chiarito.

Uso gli XSLT abbastanza spesso nel CMS di Sitecore, dove lavoro per presentare i contenuti in modo che possano essere utilizzati in un ambiente GUI in alcuni casi.

Quello che stai chiedendo si chiama Programmazione reattiva .

È un paradigma di programmazione in cui le variabili sono a conoscenza dell'espressione che sono state assegnate e ogni volta che cambia un componente dell'espressione, la variabile reagisce rivalutando l'espressione, eventualmente innescando altre rivalutazioni simili lungo la catena delle dipendenze .

Di solito questo comportamento reattivo si ottiene attraverso un uso intelligente del modello di osservatore, in cui un valore reattivo si registra come un ascoltatore di una serie di eventi che innescano la rivalutazione del valore.

Per quanto ne so, non esiste un linguaggio di programmazione che abbraccerebbe interamente la programmazione reattiva nel suo nucleo, ma ci sono molte librerie in molti linguaggi che offrono vantaggi della programmazione reattiva in un modo o nell'altro.

La maggior parte dei framework di associazione dei dati può essere considerata una implementazione della programmazione reattiva .

C'è un bel documento intitolato " Deprecare il modello di osservatore ", che probabilmente spiegherà molto meglio di quanto potessi mai fare, di cosa tratta la programmazione reattiva e cosa offrirebbe un'implementazione al di là delle tecniche già esistenti.

Lisp (e i suoi numerosi dialetc, incluso Scheme) ha:

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

valuta do-somethinge:

(when nil 'other-thing)

valuta nilo suo equivalente.

Conosco questo tipo di affermazione solo per la gestione degli errori. Ad esempio, BASIC ON ERROR ...o SQL * PLUSWHENEVER SQLERROR ...

Per condizioni arbitrarie, richiederebbe un compilatore estremamente intelligente o un tipo piuttosto costoso di forza bruta (controlla dopo ogni affermazione) per catturare il momento esatto in cui le condizioni diventano vere.

È una caratteristica dei linguaggi del flusso di dati come i linguaggi di descrizione dell'hardware (Verilog e VHDL).

Oltre a questo, posso pensare ad Ada e al suo meccanismo di gestione delle eccezioni: viene attivato whenun gestore di eccezioni viene sollevata un'eccezione.

Sembra che tu stia cercando variabili di condizione , cose che permettono ai thread di dormire fino a quando un predicato diventa realtà.

Boost li implementa per C ++, gli Apache Portable Runtime li implementa per C. In Common Lisp usereste bordeaux-threads' make-condition-variable.

Se consideri Drools una lingua, allora sì.

Un esempio:

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 è in grado di gestire i segnali in modo diretto utilizzando tap:

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

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

mentre Powershell può gestirlo usando un ciclo di esecuzione con un blocco try / finally:

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

come ci si può aspettare usando 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
}

Riferimenti

• Gestire un segnale - Codice Rosetta

• Tabelle decisionali - Codice Rosetta

È da tanto che non li guardo, quindi potrei sbagliarmi.

Per quanto ricordo, PL / I e BASIC avevano entrambi dichiarazioni "ON". In PL / I, il concetto era "ON DO". In BASIC, era "ON", dove la dichiarazione era di solito un GOSUB. In entrambe le lingue, ogni volta che la condizione specificata diventa vera, le istruzioni associate vengono eseguite.

Non vorrai farlo oggi. Il compilatore deve sostanzialmente fare un sacco di lavoro, per capire dove / quando la condizione potrebbe diventare vera, in modo da poter generare un test a quel punto. Una volta che sei nel gestore associato, non sai davvero da dove vieni, quindi devi capire cosa è successo per portarti lì, e probabilmente non vuoi tornare da dove sei venuto.

Potresti dare un'occhiata al linguaggio OPS5 . I suoi programmi sono scritti come un insieme di condizioni. Quando viene soddisfatta una condizione, viene eseguita l'azione corrispondente. Le azioni possono modificare lo stato, che può causare il soddisfacimento di altre condizioni. Sebbene non utilizzi la whenparola chiave, funziona essenzialmente eseguendo azioni "quando" viene soddisfatta una condizione. Da qui :

Un programma OPS5 è costituito da una sezione di dichiarazione in cui sono definiti costrutti di dati di base seguiti da una sezione di produzione in cui le regole per la manipolazione dei dati.

I programmi OPS5 eseguono abbinando gli elementi della memoria di lavoro con le regole nella memoria di produzione e attivando (eseguendo) la regola più dominante che viene abbinata. Il ciclo Match-Select-Execute continua fino a quando il programma si arresta in modo esplicito o fino a quando non è possibile abbinare regole alla memoria di lavoro.

Ho dovuto scrivere una semplice avventura testuale in questa lingua quando ero all'università nei primi anni '90. È stato interessante, ma non sono sicuro di quanto sarebbe utile per la maggior parte delle attività desktop o mobili. Tuttavia, potrebbe avere senso in un ambiente di backend.

Haskell ne ha uno. Ma non è un costrutto speciale, solo un'altra funzione http://hackage.haskell.org/packages/archive/base/latest/doc/html/Control-Monad.html#v:when

Nella maggior parte dei linguaggi OOP sarebbe possibile generare un thread aggiuntivo, con questo come contesto:

    while (!value)
{
}

//Execute code

Bene, potresti scrivere un sacco di thread paralleli, ognuno dei quali sondaggi per le rispettive condizioni. Suppongo che sarebbe un'applicazione piuttosto performante, ma è possibile.