Existe algo como uma declaração "quando"? [fechadas]

Existe um idioma ou recurso de idioma que possa lidar com casos "quando"? Ou seja, sempre que alguma condição se torna verdadeira, em qualquer escopo ou contexto, esse código extra pode ser especificado para execução?

Observe que isso é diferente de um simples if, que deve estar em um escopo específico e explicitamente escrito. Essa cláusula when seria quase como uma ifque se aplica a todos os casos na execução do programa após ele.

Sua pergunta não está clara, mas o padrão Observador parece ser o que você está procurando http://en.wikipedia.org/wiki/Observer_pattern

Em termos de sintaxe, várias línguas têm uma whenpalavra - chave, mas não conheço nenhuma linguagem que a use da maneira que você descreve.

O padrão 'quando X ocorre, faça Y' é o núcleo da programação orientada a aspectos: em vez de definir um fluxo linear, você conecta os manipuladores a determinadas condições (também conhecido como 'assinando' um 'evento'). Esse tipo de programação é popular nos aplicativos GUI, onde a rotina principal do programa é um distribuidor de eventos.

Algumas linguagens possuem amplos recursos de sintaxe para fornecer tais mecanismos através de construções de linguagem; um exemplo seria C # com seus delegados e eventos:

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

Outras linguagens usam construções OOP (padrão de observador, ouvintes de eventos, etc .; um exemplo em Java (meu Java é um pouco enferrujado, fique à vontade para editar):

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

Ainda outra abordagem está usando retornos de chamada antigos simples. Exemplo em javascript:

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

Ninguém mencionou o COMEFROM da INTERCAL :

O COMEFROM foi visto inicialmente nas listas de instruções da linguagem assembly de piada (como 'CMFRM'). Foi elaborado em um artigo da Datamation por R. Lawrence Clark em 1973, escrito em resposta à carta de Edsger Dijkstra, Ir para a declaração considerada prejudicial. O COMEFROM foi finalmente implementado na variante C-INTERCAL da linguagem de programação esotérica INTERCAL juntamente com o ainda mais obscuro 'COMEFROM computado'. Havia também propostas de Fortran para 'atribuído COME FROM' e uma palavra-chave 'NÃO' (para complementar o loop 'DO' existente).

Em 1 de abril de 2004, Richie Hindle publicou uma implementação do GOTO e do COMEFROM para a linguagem de programação Python. Apesar de ter sido lançada no dia da mentira e não ter a intenção de ser usada com seriedade, a sintaxe é válida e a implementação funciona totalmente.

A linguagem Tcl possui traços em variáveis que permitem a execução de código arbitrário sempre que uma variável é definida (ou lida ou excluída, mas isso é menos importante aqui). Esse código arbitrário pode facilmente incluir a avaliação de uma expressão e a execução de algum código, se houver. A principal restrição é que, embora você possa fazer isso para variáveis ​​locais, geralmente não é muito útil, pois elas tendem a ter uma vida útil muito curta; portanto, essas coisas geralmente são restritas a variáveis ​​globais e de namespace. (Tcl não tem fechamentos.)

Mas se você estiver fazendo isso, tenha cuidado. Embora você não tenha oficialmente problemas com a reentrada (o rastreamento fica desativado durante a execução do corpo), ainda é uma ótima maneira de escrever código muito pouco claro e causar muita confusão. Também é uma péssima idéia usá-lo com uma variável de loop (que não seja para depuração), pois o desempenho pode ser bastante significativo.

Um exemplo (baseado no código da página de manual vinculada acima) ilustra.

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 desse momento, a qualquer momento que um $fooou $barse torne um novo número inteiro, $foobarse torne o produto dos dois. Automaticamente.

O Tcl também permite que o código de configuração seja executado em outros tipos de gatilhos, como execução de comandos, exclusão de comandos, timers, dados disponíveis em soquetes, etc. Com a biblioteca Tk adicionada, isso é expandido para incluir um conjunto grande de eventos da GUI também. É verdade que o Tcl é realmente uma linguagem fortemente orientada a eventos (mesmo que você possa escrever facilmente um código que nunca use nenhum desses recursos).

Algo como manipulação de eventos?

em vez de func () manipula evento

você diz quando o evento funciona

Ou talvez um retorno de chamada em uma variável específica?

Sim, existe uma palavra-chave no Perl, como um modificador de instrução:

say 'Well done!'        when 'A';

Também faz parte da instrução switch:

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

Isso ( COMEFROMdeclaração descrita na Wikipedia) conta?

Resumo:

COMEFROM é aproximadamente o oposto de GOTO, pois ele pode levar o estado de execução de qualquer ponto arbitrário no código para uma instrução COMEFROM. O ponto no código em que a transferência de estado ocorre geralmente é fornecido como parâmetro para o COMEFROM. Se a transferência ocorre antes ou depois da instrução no ponto de transferência especificado depende do idioma usado. Dependendo do idioma usado, vários COMEFROMs que referenciam o mesmo ponto de partida podem ser inválidos, não determinísticos, executados em algum tipo de prioridade definida ou até induzir a execução paralela ou simultânea, como visto no Threaded Intercal.

Você está procurando um idioma com uma declaração síncrona ou assíncrona?

Parece um padrão de evento (/ subscription / callback) para mim.

Por exemplo

conditionOwner.Condition += listener.WhenCondition

Sempre que o proprietário da condição notificar que a condição ocorreu, o ouvinte fará WhenCondition ().

Você pode usar um padrão de ligação com um conversor que verifica o estado de várias variáveis ​​de entrada (em mudança) e calcula a condição, em seguida, tem uma propriedade de entrada do listener ligada à saída e age quando essa entrada é alterada.

Nas linguagens, o .NET, por exemplo (por exemplo, C #), criou assinaturas síncronas (eventos) e suas Extensões Reativas (RX) adicionam assinaturas assíncronas.

A descrição soa como um gatilho de banco de dados, projetado para aguardar um determinado cenário e depois ser executado.

Da Wikipedia:

Um acionador de banco de dados é um código de procedimento que é executado automaticamente em resposta a determinados eventos em uma tabela ou exibição específica em um banco de dados. O gatilho é usado principalmente para manter a integridade das informações no banco de dados. Por exemplo, quando um novo registro (representando um novo trabalhador) é adicionado à tabela de funcionários, novos registros também devem ser criados nas tabelas de impostos, férias e salários.

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

O que você está falando é menos sintaxe que estrutura . Você poderia realmente ter apenas uma whendeclaração como essa em um sistema que executa uma quantidade finita de lógica, depois executa as wheninstruções, circula e executa a lógica novamente, continuando em um loop infinito.

Por exemplo, a programação do Windows é tipicamente "baseada em eventos". A inscrição no Clickevento de um botão significa essencialmente "faça isso quando clicado". No entanto, o que está acontecendo sob o capô é um loop de processamento de mensagens. O Windows envia uma mensagem para o aplicativo quando o usuário clica no botão e o loop de processamento de mensagens no aplicativo executa o manipulador de eventos apropriado.

Se você usar eventos em, por exemplo, C #, poderá fazer isso sem um loop de mensagem, mas a limitação é que você deve declarar o evento antes do tempo, para não poder escrever uma whendeclaração da biblioteca de arte que preste atenção a qualquer tipo de Estado. Você tem que esperar por um evento específico.

Para obter esse comportamento em uma arquitetura Von Neumann, é necessário executar algum tipo de loop infinito que verifica todas as condições todas as vezes no loop executando o código apropriado, se apropriado. Internamente você acabou de obter uma grande lista de if/ thenou switchdeclarações. A maioria dos programadores de aplicativos de área de trabalho e da Web vomitaria se vislumbrem essa construção, então é realmente apenas palatável se você a envolver em algum tipo de açúcar sintático, como o modelo de evento do Windows (mesmo que seja o que está acontecendo sob o capô).

Por outro lado, se você observar o campo do desenvolvimento de firmware incorporado, executivos em tempo real ou controladores industriais, esse modelo de programação é muito comum. Por exemplo, se você possui um programa em tempo real, pode querer expressar:

outputA = input1 && input2

O código é simples de entender (porque é declarativo). No entanto, para fazê-lo funcionar, você deve executá-lo em um circuito fechado. Você reavalia outputAtodas as vezes através do loop. Muitos programadores de desktop ou web não gostariam disso porque é ineficiente. Para eles, o único momento em que você deve reavaliar outputAé quando input1ou input2muda. Eles preferem ver algo mais como você está descrevendo:

when input1 changes
    evaluateOutputA()

when input2 changes
    evaluateOutputA()

evaluateOutputA()
    outputA = input1 && input2

Agora, se é isso que você deseja (e pessoalmente não prefiro essa ideia), e seu objetivo é a eficiência, você ainda precisa se perguntar o que o processador está fazendo sob o capô. Obviamente, ainda existe algum tipo de loop em execução que compara os estados de entrada com os estados de entrada anteriores toda vez e executa o código apropriado sempre que alguém muda. Então, na verdade, é menos eficiente e é mais difícil de ler e mais difícil de manter.

Por outro lado, se o trabalho que você tiver que fazer quando as input1alterações forem significativas, sua whencláusula poderá fazer sentido. Nos CLPs, esse tipo de instrução é chamado de "detecção de borda ascendente". Ele salva o estado da input1última vez através do loop, compara-o com o valor dessa vez e executa a lógica se o último estado for falso e esse estado for verdadeiro.

Se você não possui uma arquitetura Von Neumann, o jogo muda. Por exemplo, se você estiver programando um FPGA em VHDL , quando escrever:

outputA = input1 && input2

(... ou o que a sintaxe VHDL apropriado seria), então o FPGA realmente obtém com fio de tal forma que input1e input2são conectados à entrada de uma porta AND, ea saída da porta AND é ligado a outputA. Portanto, o código não é apenas fácil de entender, ele também é executado em paralelo com todas as outras lógicas e é eficiente.

Quando se fala de um controlador industrial como um CLP ou PAC, programado em um dos cinco idiomas IEC-61131-3, o caso típico é esse tipo de arranjo:

1. Leia entradas e armazene na memória
2. Executar programa principal
3. Gravar saídas da memória para saídas reais
4. Avance para o passo 1

Isso está embutido na arquitetura do sistema, portanto, é esperado que você escreva:

outputA = input1 && input2

... e será executado em um loop contínuo.

Também existem rotinas de interrupção nessas máquinas. São mais como o suporte de nível de hardware para o whenoperador que você está falando. A interrupção do hardware é um meio de executar algum código em um evento externo. Por exemplo, quando uma placa de rede diz que possui dados em espera, o processador normalmente precisa ler esses dados imediatamente ou você ficará sem espaço no buffer. No entanto, pela quantidade de vezes que você precisa conectar uma interrupção real de hardware, duvido que inclua uma palavra-chave no idioma, pois vale a pena. Você estaria limitado aos pinos de entrada da CPU e parece que deseja testar o estado interno do programa.

Então, em uma linguagem tradicional (sem um loop apertado que é executado infinitamente), você precisa fazer a pergunta "quando o código de avaliação é executado"?

Se você escrever:

when A do
    launchNukes()

... e assumindo que Aé uma expressão booleana arbitrária, como você sabe quando reavaliar essa expressão? Uma implementação ingênua significaria que você deveria reavaliar após cada gravação na memória. Você pode pensar que pode reduzi-lo, mas considere o seguinte:

when systemTime > actionTime do
    launchNukes()

Observe que systemTimeestá sempre mudando (toda vez que você lê, você obtém um número diferente). Isso significa que a parte condicional de todas as suas whencláusulas deve ser reavaliada continuamente. Isso é quase impossível (e considere por um segundo o que acontece se sua expressão condicional tiver efeitos colaterais!)

Conclusão

Você só pode ter uma wheninstrução (como você está descrevendo) em uma arquitetura baseada em um loop infinito que executa o programa principal e, em seguida, executa as wheninstruções se as condições forem de falsa para verdadeira nesse loop. Embora essa arquitetura seja comum em dispositivos embarcados e industriais, não é comum em linguagens de programação de uso geral.

A linguagem AspectJ possui um modelo de ponto de junção, que é uma solução para lidar exatamente com esse tipo de situação.

Um ponto de junção no AspectJ é um evento dinâmico em um programa Java que ocorre quando o programa está em execução. Exemplos de pontos de junção são: (1) Um método é chamado; (2) um método é executado; (3) Um construtor é chamado; (4) Um construtor é executado; (5) um campo está definido; ou (6) Um campo é acessado.

Você pode criar conjuntos desses pontos de junção, chamados cortes de pontos. Os cortes de pontos podem então ser unidos, complementados e cruzados da maneira usual da teoria dos conjuntos. Outros cortes de pontos podem ser condicionados aos valores / tipos de variáveis ​​(por exemplo, "somente quando x é positivo", "somente quando o valor que está sendo definido é uma subclasse desse tipo") e com base no estado do programa ("quando esse método é chamado, mas somente quando esse outro método está na pilha desse encadeamento [o que significa que esse método o chamou indiretamente] ").

Depois que todos esses apontamentos descrevem eventos no programa, você pode usar o AspectJ para aconselhá- los. Você pode optar por fazer algo antes que o evento aconteça ( beforeconselhos), depois que o evento aconteça ( afterconselhos) ou em vez de o evento acontecer ( aroundconselhos).

Aroundeste conselho é particularmente útil para adicionar armazenamento em cache aos seus programas: Quando algum método for executado, consulte uma tabela para ver se a mesma computação já foi executada e, se houver, use a versão em cache. Com o AspectJ, é tão leve e expressivo que você pode fazer essas experiências de cache em centenas de pontos diferentes no seu código para descobrir se e onde o cache agrega valores.

Muitas pessoas fora da programação orientada a aspectos acreditam que a AOP é principalmente sobre "registro". Você pode usar o AspectJ para lidar com o log, e ele o faz muito bem ("registre neste arquivo de log quando todos os métodos públicos neste pacote forem chamados e quais foram os resultados / erros"). Mas há muito mais no AspectJ, incluindo um truque inteligente para simular escopo dinâmico chamado Worm Hole Pattern [veja slide 23 e seguintes].

Fora da AOP, você também está falando sobre programação baseada em eventos, que inclui [como outros observaram] o Padrão do Observador. A diferença entre as soluções é: (1) como a condição é detectada; (2) quando a condição é expressa; e (3) como o código a ser executado está vinculado ao evento.

Como usar o Notify / Wait parece estar perto disso:

Mencionamos que o mecanismo de espera / notificação do Java é essencialmente uma maneira de se comunicar entre os encadeamentos. Em poucas palavras, a ideia é a seguinte:

• um ou mais threads aguardam por um sinal;
• outro encadeamento aparece e notifica os encadeamentos em espera (ou seja, "acorda / eles" com o sinal).

Dependendo do contexto, existem algumas estruturas que podem estar próximas disso, mas você realmente precisa esclarecer sua pergunta.

Há também uma instrução "when" no XSLT :

O elemento é usado para determinar um curso de ação com base em uma série de testes. Cada teste é feito dentro de um elemento. Se um teste for bem-sucedido, o corpo do elemento é executado. Se nenhum teste falhar, um elemento poderá ser usado para especificar uma ação padrão:

O XSLT "quando" é uma instrução condicional, mais como uma opção do que se. No entanto, o contexto do significado de "quando" na pergunta inicial não foi muito bem esclarecido.

Uso XSLTs com bastante frequência no Sitecore CMS, onde trabalho para apresentar conteúdo, para que ele possa ser usado em um ambiente de GUI em alguns casos.

O que você está pedindo é chamado de Programação Reativa .

É um paradigma de programação em que as variáveis ​​estão cientes da expressão que foram atribuídas e, sempre que um componente da expressão muda, a variável reage reavaliando a expressão, possivelmente desencadeando outras reavaliações semelhantes ao longo da cadeia de dependências .

Normalmente, esse comportamento reativo é alcançado através do uso inteligente do padrão observador, em que um valor reativo se registra como ouvinte de um conjunto de eventos que acionam a reavaliação do valor.

Que eu saiba, não existe uma linguagem de programação que abranja inteiramente a programação reativa em seu núcleo, mas há muitas bibliotecas em muitas linguagens que oferecem benefícios da programação reativa de uma maneira ou de outra.

A maioria das estruturas de ligação de dados pode ser considerada implementação de programação reativa .

Existe um belo artigo chamado " Descontinuando o padrão de observador ", que provavelmente explicará muito melhor do que eu jamais pude, sobre o que é a programação reativa e o que uma implementação dela ofereceria além das técnicas já existentes.

O Lisp (e seus muitos dialetos, incluindo o Scheme) possui:

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

avalia do-somethinge:

(when nil 'other-thing)

avalia nilou seu equivalente.

Conheço esse tipo de declaração apenas para tratamento de erros. Por exemplo, BASIC ON ERROR ...ou SQL * PLUSWHENEVER SQLERROR ...

Para condições arbitrárias, seria necessário um compilador extremamente inteligente ou um tipo de força bruta bastante caro (verifique após cada instrução) para capturar o momento exato em que as condições se tornam verdadeiras.

É um recurso das linguagens de fluxo de dados, como as linguagens de descrição de hardware (Verilog e VHDL).

Fora isso, posso pensar no Ada e seu mecanismo de tratamento de exceções: um manipulador de exceções é acionado; whenalgumas exceções são geradas.

Parece que você está procurando por variáveis ​​de condição , coisas que permitem que os threads durem até que algum predicado se torne verdadeiro.

Impulsionar as implementa para C ++, os Apache Portable Runtime implementa para C. Em Common Lisp você usaria bordeaux-thread's make-condition-variable.

Se você considera Drools um idioma, então sim.

Um exemplo:

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

O Perl 6 pode manipular sinais de maneira direta usando tap:

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

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

enquanto o Powershell pode lidar com isso usando um loop de execução com um bloco try / finalmente:

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

Referências

• Manipular um sinal - Código Rosetta

• Tabelas de decisão - Código Rosetta

Faz muito tempo desde que olhei para eles, para que eu pudesse estar enganado.

Pelo que me lembro, PL / I e BASIC tinham declarações "ON". Em PL / I, o conceito era "ON DO". No BASIC, estava "ON", onde a declaração era geralmente um GOSUB. Nos dois idiomas, sempre que a condição especificada se tornou verdadeira, as instruções associadas foram executadas.

Você não gostaria de fazer isso hoje. O compilador basicamente tem que fazer um monte de trabalho, para descobrir onde / quando a condição pode se tornar verdadeira, para que possa gerar um teste nesse ponto. Uma vez que você está no manipulador associado, você realmente não sabe de onde você veio, então você precisa descobrir o que aconteceu para chegar lá, e provavelmente não deseja voltar para onde você veio.

Você pode dar uma olhada no idioma do OPS5 . Seus programas são escritos como um conjunto de condições. Quando uma condição é atendida, a ação correspondente é executada. As ações podem modificar o estado, o que pode fazer com que outras condições sejam atendidas. Embora não use a whenpalavra-chave, funciona essencialmente executando ações "quando" uma condição é atendida. A partir daqui :

Um programa OPS5 consiste em uma seção de declaração em que construções básicas de dados são definidas, seguidas por uma seção de produção em que regras para manipulação dos dados.

Os programas OPS5 são executados combinando elementos da memória de trabalho com as regras da memória de produção e disparando (executando) a regra mais dominante correspondente. O ciclo Match-Select-Execute continua até que o programa pare explicitamente ou até que nenhuma regra possa ser correspondida à memória de trabalho.

Eu tive que escrever uma aventura de texto simples nesse idioma quando estava na Universidade no início dos anos 90. Foi interessante, mas não tenho certeza de quão útil seria para a maioria das tarefas de desktop ou móveis. No entanto, pode fazer sentido em um ambiente de back-end.

Haskell tem um. Mas não é uma construção especial, apenas outra função http://hackage.haskell.org/packages/archive/base/latest/doc/html/Control-Monad.html#v:when

Na maioria das linguagens OOP, seria possível gerar um thread extra, tendo isso como contexto:

    while (!value)
{
}

//Execute code

Bem, você pode escrever um monte de threads paralelos, cada um pesquisando suas respectivas condições. Suponho que esse seria um aplicativo de baixo desempenho, mas é possível.