¿Existe tal cosa como una declaración de "cuándo"? [cerrado]

¿Existe un idioma o una función de idioma que pueda manejar casos "cuando"? Es decir, cada vez que se cumple alguna condición, en cualquier ámbito o contexto, ¿se podría especificar que se ejecute código adicional?

Tenga en cuenta que esto es diferente de un simple if, que debe estar en un ámbito particular y escrito explícitamente. Esta cláusula when casi sería como la ifque se aplica a todos los casos en la ejecución del programa posterior.

Su pregunta no está clara, pero el patrón de Observador parece ser lo que está buscando http://en.wikipedia.org/wiki/Observer_pattern

En cuanto a la sintaxis, muchos idiomas tienen una whenpalabra clave, pero no conozco ningún idioma que la use de la manera que usted describe.

El patrón 'cuando ocurre X, hacer Y' es una especie de núcleo de la programación orientada a aspectos: en lugar de definir un flujo lineal, conecta los controladores en ciertas condiciones (también conocido como 'suscribirse' a un 'evento'). Este tipo de programación es popular en aplicaciones GUI, donde la rutina central del programa es un despachador de eventos.

Algunos idiomas tienen amplias características de sintaxis para proporcionar tales mecanismos a través de construcciones de lenguaje; un ejemplo sería C # con sus delegados y eventos:

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

Otros lenguajes utilizan construcciones OOP (patrón de observador, oyentes de eventos, etc., un ejemplo en Java (mi Java está un poco oxidado, así que siéntase libre de editar):

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

Sin embargo, otro enfoque es utilizar las antiguas devoluciones de llamada. Ejemplo en javascript:

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

Nadie ha mencionado aún el COMEFROM de INTERCAL :

COMEFROM se vio inicialmente en listas de instrucciones en lenguaje ensamblador de broma (como 'CMFRM'). Fue elaborado en un artículo de Datamation por R. Lawrence Clark en 1973, escrito en respuesta a la carta de Edsger Dijkstra Ir a la declaración considerada perjudicial. COMEFROM finalmente se implementó en la variante C-INTERCAL del lenguaje de programación esotérico INTERCAL junto con el aún más oscuro 'COMEFROM computarizado'. También hubo propuestas de Fortran para 'asignado VENIDO DE' y una palabra clave 'NO' (para complementar el bucle 'DO' existente).

El 1 de abril de 2004, Richie Hindle publicó una implementación de GOTO y COMEFROM para el lenguaje de programación Python. A pesar de que se lanzó el Día de los Inocentes y no está destinado a un uso serio, la sintaxis es válida y la implementación funciona por completo.

El lenguaje Tcl tiene trazas en las variables que permiten ejecutar código arbitrario cada vez que se establece una variable (o lectura o eliminación, pero eso es menos importante aquí). Ese código arbitrario puede incluir fácilmente la evaluación de una expresión y la ejecución de algún código si es válido. La restricción principal es que si bien puede hacer esto para las variables locales, generalmente no es muy útil porque tienden a tener una vida útil muy corta, por lo que estas cosas generalmente están restringidas a variables globales y de espacio de nombres. (Tcl no tiene cierres).

Pero si estás haciendo esto, debes tener cuidado. Si bien oficialmente no tiene problemas con la reentrada (el seguimiento está deshabilitado durante la ejecución del cuerpo) sigue siendo una excelente manera de escribir código muy poco claro y causar mucha confusión. También es una idea realmente terrible usarlo con una variable de bucle (que no sea para la depuración) ya que el impacto en el rendimiento puede ser bastante significativo.

Se ilustra un ejemplo (basado en el código de la página del manual vinculada anterior).

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

A partir de ese momento, cada vez que $fooo se $barconvierte en un nuevo número entero, se $foobarconvierte en el producto de los dos. Automáticamente.

Tcl también permite configurar el código para que se ejecute en otros tipos de disparadores, como la ejecución de comandos, la eliminación de comandos, temporizadores, la disponibilidad de datos en sockets, etc. Con la biblioteca Tk agregada, esto se expande para incluir un conjunto completo grande de eventos GUI también. Es cierto que Tcl es en realidad un lenguaje muy orientado a eventos (incluso si puede escribir fácilmente código que nunca usa ninguna de esas características).

Algo como el manejo de eventos?

en lugar de func () maneja el evento

dices cuando el evento funciona

¿O tal vez una devolución de llamada en una variable en particular?

Sí, existe una palabra clave en Perl, como un modificador de declaración:

say 'Well done!'        when 'A';

También es parte de la declaración de cambio:

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

¿Cuenta esto ( COMEFROMdeclaración descrita en Wikipedia) ?

Resumen:

COMEFROM es más o menos lo contrario de GOTO en que puede llevar el estado de ejecución desde cualquier punto arbitrario del código a una declaración COMEFROM. El punto en el código donde ocurre la transferencia de estado generalmente se da como un parámetro para COMEFROM. Si la transferencia se realiza antes o después de la instrucción en el punto de transferencia especificado depende del idioma utilizado. Dependiendo del lenguaje utilizado, varios COMEFROM que hacen referencia al mismo punto de partida pueden no ser válidos, ser no deterministas, ejecutarse en algún tipo de prioridad definida o incluso inducir una ejecución paralela o concurrente de otro modo, como se ve en la Intercal roscada.

¿Está buscando un lenguaje con una declaración when síncrona o asíncrona?

Suena como un patrón de evento (/ suscripción / devolución de llamada) para mí.

P.ej

conditionOwner.Condition += listener.WhenCondition

Siempre que el propietario de la condición notifique que la condición ha tenido lugar, el oyente hará WhenCondition ().

Podría usar un patrón de enlace con un convertidor que verifique el estado de varias variables de entrada (en el cambio) y calcule la condición, luego haga que una propiedad de entrada del oyente se vincule a la salida y actúe cuando se cambie esa entrada.

En cuanto a los lenguajes, .NET, por ejemplo (es decir, C #) ha incorporado suscripciones síncronas (eventos) y sus Extensiones Reactivas (RX) agrega suscripciones asíncronas.

La descripción suena como un disparador de base de datos que está diseñado para esperar un escenario determinado y luego ejecutarse.

De Wikipedia:

Un desencadenador de base de datos es un código de procedimiento que se ejecuta automáticamente en respuesta a ciertos eventos en una tabla o vista en particular en una base de datos. El disparador se utiliza principalmente para mantener la integridad de la información en la base de datos. Por ejemplo, cuando se agrega un nuevo registro (que representa a un nuevo trabajador) a la tabla de empleados, también se deben crear nuevos registros en las tablas de impuestos, vacaciones y salarios.

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

De lo que estás hablando es de menos sintaxis que estructura . Realmente solo podría tener una whendeclaración como esa en un sistema que ejecute una cantidad finita de lógica, luego ejecute las whendeclaraciones, luego repita y ejecute la lógica nuevamente, continuando en un bucle infinito.

Por ejemplo, la programación de Windows suele estar "basada en eventos". Suscribirse al Clickevento de un botón significa esencialmente "hacer esto cuando se hace clic". Sin embargo, lo que sucede debajo del capó es un bucle de procesamiento de mensajes. Windows envía un mensaje a la aplicación cuando el usuario hace clic en el botón y el bucle de procesamiento de mensajes en la aplicación ejecuta el controlador de eventos apropiado.

Si usa eventos en, por ejemplo, C #, puede hacerlo sin un bucle de mensajes, pero la limitación es que tiene que declarar el evento con anticipación, por lo que no puede escribir una whendeclaración de biblioteca que vigile cualquier tipo de estado. Tienes que esperar un evento específico.

Para obtener este comportamiento en una arquitectura de Von Neumann, debe ejecutar algún tipo de bucle infinito que verifique todas las condiciones cada vez a través del bucle que ejecuta el código apropiado, si corresponde. Internamente solo obtienes una gran lista de if/ theno switchdeclaraciones. La mayoría de los programadores web y de aplicaciones de escritorio vomitarían si vieran tal construcción, por lo que en realidad solo es aceptable si lo envuelves en algún tipo de azúcar sintáctica como el modelo de evento de Windows (aunque eso es lo que está sucediendo).

Por otro lado, si observa el campo del desarrollo de firmware incorporado, los ejecutivos en tiempo real o los controladores industriales, este modelo de programación es muy común. Por ejemplo, si tiene un programa en tiempo real, es posible que desee expresar:

outputA = input1 && input2

El código es fácil de entender (porque es declarativo). Sin embargo, para que funcione, debe ejecutarlo en un ciclo cerrado. Reevalúa outputAcada vez a través del ciclo. A muchos programadores de escritorio o web no les gustaría esto porque es ineficiente. Para ellos, el único momento en que debe volver a evaluar outputAes cuándo input1o input2cambios. Prefieren ver algo más como lo que estás describiendo:

when input1 changes
    evaluateOutputA()

when input2 changes
    evaluateOutputA()

evaluateOutputA()
    outputA = input1 && input2

Ahora bien, si esto es lo que quieres (y personalmente no prefiero esta idea), y tu objetivo es la eficiencia, entonces todavía tienes que preguntarte qué está haciendo el procesador bajo el capó. Obviamente, todavía hay algún tipo de ciclo en ejecución que compara los estados de entrada con los estados de entrada anteriores cada vez, y ejecuta el código apropiado cada vez que uno cambia. Entonces, realmente es menos eficiente y es más difícil de leer y más difícil de mantener.

Por otro lado, si el trabajo que tiene que hacer cuando los input1cambios son significativos, entonces su whencláusula podría tener sentido. En los PLC, este tipo de instrucción se denomina "detección de flanco ascendente". Guarda el estado de input1la última vez a través del bucle, lo compara con el valor esta vez y ejecuta la lógica si el último estado fue falso y este estado es verdadero.

Si no tienes una arquitectura de Von Neumann, entonces el juego cambia. Por ejemplo, si estás programando un FPGA en VHDL , cuando escribes:

outputA = input1 && input2

(... o lo que sea la sintaxis VHDL apropiada sería), entonces la FPGA realidad se cablea tal que input1y input2están conectados a la entrada de una puerta AND, y la salida de la puerta AND está conectada a outputA. Por lo tanto, el código no solo es fácil de entender, sino que también se ejecuta en paralelo con todas las demás lógicas y es eficiente.

Cuando habla de un controlador industrial como un PLC o PAC, programado en uno de los cinco idiomas IEC-61131-3, el caso típico es este tipo de disposición:

1. Leer entradas y almacenar en memoria
2. Ejecutar programa principal
3. Escribir salidas de memoria a salidas reales
4. Ir al paso 1

Esto está integrado en la arquitectura del sistema, por lo que se espera que solo escriba:

outputA = input1 && input2

... y se ejecutará en un bucle continuo.

También hay rutinas de interrupción en estas máquinas. Estos son más como soporte de nivel de hardware para el whenoperador del que estás hablando. La interrupción de hardware es un medio de ejecutar algún código en un evento externo. Por ejemplo, cuando una tarjeta de red dice que tiene datos en espera, el procesador normalmente tiene que leer esos datos inmediatamente o se quedará sin espacio en el búfer. Sin embargo, por la cantidad de veces que necesita conectar una interrupción de hardware real, dudo que valga la pena incluir una palabra clave de idioma. Estaría limitado a pines de entrada de CPU, y parece que desea probar el estado interno del programa.

Entonces, en un lenguaje tradicional (sin un ciclo cerrado que se ejecuta infinitamente), debe hacer la pregunta, "¿cuándo se ejecuta el código de evaluación"?

Si tú escribes:

when A do
    launchNukes()

... y suponiendo que Aes una expresión booleana arbitraria, ¿cómo sabe cuándo volver a evaluar esa expresión? Una implementación ingenua significaría que debe volver a evaluarla después de cada escritura de memoria. Puede pensar que puede reducirlo, pero considere esto:

when systemTime > actionTime do
    launchNukes()

Tenga en cuenta que systemTimesiempre está cambiando (cada vez que lo lea, obtendrá un número diferente). Esto significa que la parte condicional de todas sus whencláusulas debe ser reevaluada continuamente. Eso es casi imposible (¡y solo considera por un segundo lo que sucede si tu expresión condicional tiene efectos secundarios!)

Conclusión

Solo puede tener una whendeclaración (como la que está describiendo) en una arquitectura basada en un bucle infinito que ejecuta el programa principal, luego ejecuta las whendeclaraciones si las condiciones pasaron de falso a verdadero en este bucle. Si bien esta arquitectura es común en dispositivos integrados e industriales, no es común en lenguajes de programación de uso general.

El lenguaje AspectJ tiene un modelo de punto de unión, que es una solución para manejar exactamente este tipo de situación.

Un punto de unión en AspectJ es un evento dinámico en un programa Java que ocurre cuando el programa se está ejecutando. Los puntos de unión de ejemplo son: (1) Se llama a un método; (2) Se ejecuta un método; (3) Se llama un constructor; (4) Se ejecuta un constructor; (5) Se establece un campo; o (6) Se accede a un campo.

Luego puede crear conjuntos de estos puntos de unión, llamados puntos de corte. Los recortes de puntos se pueden unir, complementar e intersectar de la forma habitual de la teoría de conjuntos. Otros puntos de corte pueden estar condicionados a los valores / tipos de variables (por ejemplo, "solo cuando x es positivo", "solo cuando el valor que se establece es una subclase de este tipo") y en función del estado del programa ("cuando se llama a este método, pero solo cuando este otro método está en la pila de este hilo [lo que significa que ese método lo llamó indirectamente] ").

Una vez que tenga todos estos puntos de corte que describan eventos en el programa, puede usar AspectJ para informar estos eventos. Puede elegir hacer algo antes de que ocurra el evento ( beforeconsejo), después de que ocurra el evento ( afterconsejo) o en lugar de que ocurra el evento ( aroundconsejo).

AroundEl consejo es particularmente útil para agregar almacenamiento en caché a sus programas: cuando se ejecuta algún método, busque en una tabla para ver si ya se realizó el mismo cálculo y, de ser así, use la versión en caché. Con AspectJ, es tan ligero y expresivo que puede hacer tales experimentos de almacenamiento en caché en cientos de puntos diferentes en su código para encontrar si el almacenamiento en caché agrega valores.

Muchas personas fuera de la programación orientada a aspectos creen que AOP se trata principalmente de "registro". Puede usar AspectJ para manejar el registro, y lo hace bastante bien ("registre en este archivo de registro cuándo se invocan todos los métodos públicos en este paquete y cuáles fueron sus resultados / resultados de error"). Pero hay mucho más en AspectJ, incluido un truco inteligente para simular el alcance dinámico llamado Patrón de agujeros de gusano [ver diapositiva 23 y siguientes].

Fuera de AOP, también está hablando de programación basada en eventos, que incluye [como otros han notado] el Patrón de Observador. La diferencia entre las soluciones es: (1) cómo se detecta la condición; (2) donde se expresa la condición; y (3) cómo el código de ejecución está vinculado al evento.

Cómo usar Notify / Wait parece estar cerca de esto:

Hemos mencionado que el mecanismo de espera / notificación de Java es esencialmente una forma de comunicarse entre hilos. En pocas palabras, la idea es la siguiente:

• uno o más hilos se sienta esperando una señal;
• aparece otro hilo y notifica a los hilos en espera (es decir, "los despierta" con la señal).

Dependiendo del contexto, hay algunas estructuras que pueden estar cerca de esto, pero realmente tiene que aclarar su pregunta.

También hay una declaración "when" en XSLT :

El elemento se usa para determinar un curso de acción basado en una serie de pruebas. Cada prueba se realiza dentro de un elemento. Si una prueba tiene éxito, se ejecuta el cuerpo del elemento. Si no fallan las pruebas, se puede usar un elemento para especificar una acción predeterminada:

El XSLT "cuándo" es una declaración condicional, más como un interruptor que como un if. Sin embargo, el contexto de lo que se entiende por un "cuándo" en la pregunta inicial no estaba realmente bien aclarado.

Utilizo XSLT con bastante frecuencia en Sitecore CMS, donde trabajo para presentar contenido para que pueda usarse en un entorno GUI en algunos casos.

Lo que está pidiendo se llama Programación Reactiva .

Es un paradigma de programación donde las variables son conscientes de la expresión que se les ha asignado y cada vez que cambia un componente de la expresión, la variable reacciona reevaluando la expresión, posiblemente desencadenando otras reevaluaciones similares en la cadena de dependencias. .

Por lo general, este comportamiento reactivo se logra mediante el uso inteligente del patrón de observación, donde un valor reactivo se registra a sí mismo como un oyente de un conjunto de eventos que desencadenan la reevaluación del valor.

Que yo sepa, no existe un lenguaje de programación que abarque por completo la programación reactiva en su núcleo, pero hay muchas bibliotecas en muchos lenguajes que ofrecen los beneficios de la programación reactiva de una forma u otra.

La mayoría de los marcos de enlace de datos pueden considerarse implementaciones de programación reactiva .

Hay un buen artículo sobre " Depreciar el patrón de observador ", que probablemente explicará mucho mejor que nunca, de qué se trata la programación reactiva y qué ofrecería una implementación de la misma más allá de las técnicas ya existentes.

Lisp (y sus muchos dialetcs, incluido Scheme) lo tiene:

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

evalúa do-somethingy:

(when nil 'other-thing)

evalúa nilao su equivalente.

Conozco un tipo de declaración solo para el manejo de errores. Por ejemplo, BASIC ON ERROR ...o SQL * PLUSWHENEVER SQLERROR ...

Para condiciones arbitrarias, requeriría un compilador extremadamente inteligente o un tipo de fuerza bruta bastante costosa (verifique después de cada declaración) para captar el momento exacto en que las condiciones se vuelven verdaderas.

Es una característica de los lenguajes de flujo de datos, como los lenguajes de descripción de hardware (Verilog y VHDL).

Aparte de eso, puedo pensar en Ada y su mecanismo de manejo de excepciones: se desencadena whenun controlador de excepciones. Se genera una excepción.

Parece que está buscando variables de condición , cosas que permiten que los subprocesos duerman hasta que algún predicado se haga realidad.

Boost los implementa para C ++, el Apache Portable Runtime los implementa para C. En Common Lisp usarías bordeaux-threadlos de make-condition-variable.

Si consideras que Drools es un idioma, entonces sí.

Un ejemplo:

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 puede manejar señales de manera directa usando tap:

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

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

mientras que Powershell puede manejarlo usando un ciclo de ejecución con un bloque 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
}

como puede esperar 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
}

Referencias

• Manejar una señal - Código Rosetta

• Tablas de decisión - Código Rosetta

Ha pasado MUCHO tiempo desde que los vi, así que podría estar equivocado.

Según recuerdo, PL / I y BASIC tenían declaraciones "ON". En PL / I, el concepto era "ON DO". En BASIC, estaba "ENCENDIDO", donde la declaración generalmente era un GOSUB. En ambos idiomas, cuando la condición especificada se convirtió en verdadera, se ejecutaron las declaraciones asociadas.

No querrías hacer esto hoy. El compilador básicamente tiene que hacer un montón de trabajo, para descubrir dónde / cuándo la condición podría volverse verdadera, para que pueda generar una prueba en ese punto. Una vez que está en el controlador asociado, no sabe realmente de dónde viene, por lo que tiene que averiguar qué sucedió para llegar allí, y probablemente no quiera volver a su lugar de origen.

Puede echar un vistazo al lenguaje OPS5 . Sus programas están escritos como un conjunto de condiciones. Cuando se cumple una condición, se realiza la acción correspondiente. Las acciones pueden modificar el estado, lo que puede hacer que se cumplan otras condiciones. Si bien no utiliza la whenpalabra clave, funciona esencialmente realizando acciones "cuando" se cumple una condición. Desde aquí :

Un programa OPS5 consiste en una sección de declaración donde se definen las construcciones de datos básicos seguidos de una sección de producción donde las reglas para la manipulación de los datos.

Los programas OPS5 se ejecutan haciendo coincidir los elementos de la memoria de trabajo con las reglas en la memoria de producción y disparando (ejecutando) la regla más dominante que se corresponde. El ciclo Match-Select-Execute continúa hasta que el programa se detiene explícitamente o hasta que no se puedan hacer coincidir las reglas con la memoria de trabajo.

Tuve que escribir una aventura de texto simple en este idioma cuando estaba en la universidad a principios de los 90. Fue interesante, pero no estoy seguro de lo útil que sería para la mayoría de las tareas de escritorio o móviles. Sin embargo, podría tener sentido en un entorno de back-end.

Haskell tiene uno. Pero no es una construcción especial, solo otra función http://hackage.haskell.org/packages/archive/base/latest/doc/html/Control-Monad.html#v:when

En la mayoría de los lenguajes OOP sería posible generar un hilo adicional, tenga esto como contexto:

    while (!value)
{
}

//Execute code

Bueno, podría escribir un montón de hilos paralelos, cada uno de los cuales sondea su respectiva condición. Supongo que sería una aplicación de bajo rendimiento, pero es posible.