Quais estruturas de controle alternativas úteis você conhece? [fechadas]

Pergunta semelhante foi encerrada no SO.

Às vezes, quando estamos programando, descobrimos que alguma estrutura de controle específica seria muito útil para nós, mas não está diretamente disponível em nossa linguagem de programação.

Quais estruturas de controle alternativas você acha que são uma maneira útil de organizar a computação?

O objetivo aqui é obter novas formas de pensar sobre a estruturação do código, a fim de melhorar o chunking e o raciocínio.

Você pode criar uma sintaxe / semântica desejada agora não disponível ou citar uma estrutura de controle menos conhecida em uma linguagem de programação existente.

As respostas devem fornecer idéias para uma nova linguagem de programação ou aprimorar uma linguagem real.

Pense nisso como um debate de ideias, então publique algo que você acha que é uma ideia maluca, mas que pode ser viável em alguns cenários.

É sobre programação imperativa.

OK, esta é uma pergunta divertida.

Eu também gostaria de ter um general elsepor enquanto e por loops, para quando a condição não for verdadeira no primeiro teste:

while (condition) {
    // process
}
else {
    // condition was never true
}

Isso evita o recálculo incômodo da condição ou o armazenamento em uma variável.

Por que não misturar algumas respostas em uma?

while (expr) {

    // Executed every iteration, unless first{} is present.
    // May be explicitly called rest{} if you like first{} to come first.

    // Blocks may return results, and consequently be used in expressions.
    return expr;

} first {

    // Executed only on the first iteration.

} pre {

    // Executed before every iteration.

} post {

    // Executed after every iteration.

} catch (oops) {

    // All blocks are implicitly try{}ed if followed by a catch{}.

} finally {

    // Executes after the block completes, regardless of exceptions.

} else {

    // Executed if the loop body or rest{} never executes.

} never {

    // Executes only when a client is present.

} drop (bad, worse), // Explicitly ignore certain exceptions.
  until (expr);      // Here, have a post-body condition, too.

Uma sintaxe de construção de controle de fluxo generalizada e extensível em uma linguagem imperativa seria bastante útil e divertida. Até que isso apareça, acho que vou usar o Lisp ou algo assim.

Estruturas de controle como funções.

Quero for, if, else, while, etc, para ser funções, e não estruturas especiais.

Eu quero return, try/excepte gotoser derivado de continuações.

É claro que isso tem menos a ver com uma estrutura de controle específica e mais com a forma como você vê as estruturas de controle em geral, a meta das estruturas de controle.

O artigo vinculado definitivamente esclarece os N + 1/2 Loops de Donald Knuth . Expressado em C / C ++ / Java:

for (;;) {
  get next element;
  if (at the end) break;
  process the element;
}

Isso é útil para ler linhas ou caracteres de um arquivo, testar se você atingiu o EOF e depois processá-lo. Estou tão acostumado a ver o padrão for(;;)..if(..)break;aparecer que é idiomático para mim. (Antes de ler o artigo de Knuth, reimpresso no livro Literate Programming , este costumava ser um "wtf?".)

Knuth sugeriu as palavras loop/while/repeat- chave :

loop:
  S;
while C:
  T;
repeat

Onde Se Tsão espaços reservados para uma série de zero ou mais instruções e Cé uma condição booleana. Se não houvesse uma Sinstrução, seria um loop while e, se não houvesse uma Tinstrução, seria um loop do.

Essa construção em si poderia ser generalizada, permitindo zero ou mais while Ccláusulas, tornando-a perfeita para expressar loops infinitos e, em seguida, algumas condições mais raras que precisariam de duas verificações.

No mesmo artigo, Knuth sugeriu um mecanismo de sinalização que seria uma versão local de exceções de lançamento / captura (como uma alternativa ao uso de goto).

Para mim? Desejo que a Java suporte a otimização de chamada de cauda, ​​para que eu possa expressar qualquer estrutura de controle geral, conforme necessário.

Atualização: esqueci de mencionar que muitos programadores de C / C ++ / Java resolvem esse problema usando uma atribuição incorporada na condição de while:

while ((c = getc(f)) != -1) {
   T;
}

Usando os termos da construção de Knuth, isso é permitido quando Se Cpode ser combinado em uma única expressão. Algumas pessoas odeiam ver a atribuição incorporado acima, enquanto outros odeiam ver o breakno for (;;)acima. Mas quando Se Cnão pode ser combinado, como quando Spossui várias instruções, for (;;)é a única alternativa sem repetir o código. A outra alternativa é simplesmente duplicar o Scódigo:

S;
while (C) {
  T;
  S;
}

A loop/while/repeatalternativa de Knuth parece muito melhor.

A linguagem BCPL tinha uma valueofexpressão que poderia ser usada para transformar uma sequência de instruções em uma única expressão:

foo(a, b, valueof {some series of statements; resultis v});

Onde some series of statementspode haver qualquer coisa e o todo é valueofavaliado v.

Isso pode ser útil em Java para quando você precisar calcular um argumento para chamar um this()ou super()(que requer que nada aconteça antes dele). Obviamente, você pode simplesmente escrever um método separado, mas isso pode ser um problema se você precisar passar muitos valores locais para o contexto.

Se você puder usar as finalvariáveis ​​necessárias, já poderá fazer um valueofem Java usando classes internas anônimas:

foo(a, b, new Object(){String valueof(){
    String v ...; some series of statements; return v;}}.valueof());

unless(condition) {
  // ...
}

faz o mesmo que:

if(!condition) {
  // ...
}

repeat {
  // ...
} until(condition)

faz o mesmo que:

do {
  // ...
} while(!condition)

Em uma nota diferente, eu gostaria de ver um melhor suporte para iteradores nas linguagens de programação. Em particular, para quando você quiser descer duas coleções em pares :

for (String s, Integer i : stringsSet, integersSet) {
    // use the pair (s, i)
}

Algumas linguagens dinâmicas já podem ter isso, ou suportam facilmente via bibliotecas e macros, mas acho que isso está no espírito da sua pergunta.

Se os dois conjuntos não tiverem o mesmo tamanho, isso poderá gerar uma exceção ou um elseloop após o sinalizar que houve uma diferença nos tamanhos.

Naturalmente, você pode generalizar isso ao descer três ou mais listas.

Atualização: Também seria útil fazer o produto cartesiano entre iteráveis:

for (String s, Integer i : stringsSet * integersSet) {
    // use the pair (s, i), each s with each i
}

que seria nada mais que loops aninhados:

for (String s : stringsSet) {
    for (Integer i : integersSet) {
        // use the pair (s, i), each s with each i
    }
}

Estou um pouco preocupado que, entre as duas notações que forneço aqui, exista uma diferença de O (n) e O (n ^ 2) no número de pares, apenas com a alteração de um único caractere.

Existe o chamado "Dijkstra's Loop" (também chamado "Dijkstra's Guarded Loop"). Foi definido na The Guarded Command Language (GCL) . Você pode encontrar algumas informações sobre a sintaxe e a semântica no artigo da Wikipedia acima, na seção 6 Repetição: do .

Atualmente, conheço uma linguagem de programação que suporta diretamente essa estrutura de controle. É Oberon-07 (PDF, 70 KB). E suporta "Loop de Dijkstra" na sua forma de declaração while. Veja a seção 9.6. Declarações While no PDF acima.

WHILE m > n DO m := m – n 
ELSIF n > m DO n := n – m 
END

PS Esta é uma cópia da minha resposta SO .

Expressões em estilo de ícone com retorno interno.

O Python obtém muitos dos benefícios do gerador de ícones - e faz um trabalho melhor deles em geral, a IMO. E, em princípio, o retorno era apenas um tipo de exceção, mas era a simplicidade das expressões o equivalente aproximado de ...

x = (a / b) else c;

para lidar com casos de falha, como divisão por zero.

Onde Icon ficou louco - não há operadores de comparação com retorno booleano. As comparações sempre foram bem-sucedidas ou desencadearam o retorno, e havia outra questão semântica que agora estou tentando desesperadamente lembrar que ... bem, digamos que provavelmente seja mais reprimida do que esquecida.

Eu sempre pensei que eles deveriam ter uma ifexpressão sem outra parte - if (condition, success-value)tipo de coisa, voltando atrás se a condição retornar falsa - e descartar as comparações estranhas.

EDIT Lembro-me - óbvio realmente. Uma comparação com dois argumentos é bem-sucedida ou falha - ela não calcula um novo valor para retornar. Então, quando for bem-sucedido, o que ele retornará? Resposta - um dos argumentos. Mas se você escrever a > b, qual é o argumento lógico para retornar - aou b? E se você escrever b < a? Eu acho que sempre retornou o argumento certo, o que faz tanto sentido quanto qualquer outra coisa, mas ainda assim normalmente parecia o argumento errado para mim.

Esta é apenas uma ideia e sintaxe gerais:

if (cond)
   //do something
else (cond)
   //do something
also (cond)
   //do something
else
   //do something
end

A condição TAMBÉM é sempre avaliada. ELSE funciona como de costume.

Também funciona para o caso. Provavelmente, é uma boa maneira de eliminar a declaração de quebra:

case (exp)
   also (const)
      //do something
   else (const)
      //do something
   also (const)
      //do something
   else
      //do something
end

pode ser lido como:

switch (exp)
   case (const)
      //do something
   case (const)
      //do something
      break
   case (const)
      //do something
   default
      //do something
end

Não sei se isso é útil ou simples de ler, mas é um exemplo.

O estilo de passagem de continuação vem à mente. Então, é claro, você também gostaria de ter a Otimização de chamada de cauda .

Ramificação de encadeamento sem costura, possui sintaxe como uma função, mas é executada em um encadeamento separado e não pode acessar dados que não foram passados ​​inicialmente para ele.

branch foo(data, to, be, processed){
    //code
    return [resulting, data]
}

Quando um ramo é chamado, ele retornará imediatamente um identificador.

handle=foo(here, is, some, data)

O identificador pode ser usado para verificar se a tarefa está concluída.

handle.finished() //True if the execution is complete

Se o resultado for solicitado antes que a execução seja concluída, o encadeamento principal simplesmente aguardará.

[result, storage]=handle.result()

Isso não cobriria os cenários de multithreading mais avançados, mas forneceria uma maneira facilmente acessível de começar a utilizar vários núcleos.

if (cond)
   //do something
else (cond)
   //do something
else (cond)
   //do something
first
   //do something
then
   //do something
else (cond)
   //do something
else
   //do something
end

O PRIMEIRO e o THEN são executados se qualquer um dos três condicionais for avaliado como verdadeiro. O PRIMEIRO bloco é executado antes do bloco condicional e, em seguida, depois do bloco condicional.

A gravação condicional ou final ELSE após a instrução FIRST e THEN é independente desses blocos.

Pode ler-se como:

if (cond)
   first()
   //do something
   then()
else (cond)
   first()
   //do something
   then()
else (cond)
   first()
   //do something
   then()
else (cond)
   //do something
else
   //do something
end


function first()
   //do something
return
function then()
   //do something
return

Essas funções são apenas um formulário para ler. Eles não criariam escopo. É mais como um gosub / return do Basic.

Utilidade e legibilidade como assunto de discussão.

Às vezes me pego escrevendo um loop que precisa fazer algo diferente durante a primeira iteração. Por exemplo, exibindo tags <th> em vez de <td>.

Eu lido com essa situação com uma bandeira booleana. Algo assim:

first = true

while (some_condition)
    if (first)
        do_something
        first = false
    else
        do_something_else

Parece bobagem verificar o valor de firsttodas as iterações quando elas serão falsas na maioria das vezes.

Eu gostaria de ter uma opção de loop para especificar um corpo de loop diferente na primeira iteração. Não haveria necessidade de uma variável separada. O código compilado também não precisaria de um, porque o código gerado teria dois corpos, um para a primeira iteração e outro para o restante.

[copiado da minha própria resposta no stackoverflow]

ignoring - Ignorar exceções que ocorrem em um determinado bloco de código.

try {
  foo()
} catch {
  case ex: SomeException => /* ignore */
  case ex: SomeOtherException => /* ignore */
}

Com uma construção de controle de ignorância, você pode escrevê-la de forma mais concisa e mais fácil como:

ignoring(classOf[SomeException], classOf[SomeOtherException]) {
  foo()
}

[Scala fornece isso (e muitas outras construções de controle de manipulação de exceção) em sua biblioteca padrão, no pacote util.control. ]

Ao invés de:

switch(myEnum) {
  case MyEnum.Val1: do1(); ...
  case MyEnum.Val2: do2(); ...
....

Faça o Python, ou agora também o C #:

action = val2func[myEnum]
action()

Scala tem muitos novos recursos.

Finalmente, idiomas como o Clojure podem ser estendidos para fornecer a funcionalidade extra.

Eu tenho duas idéias

Muitas vezes, acho que estou me repetindo em catchblocos. Isso pode ser um pouco ajudado através da extração de métodos, mas isso pode causar confusão desnecessária se os métodos forem muito curtos ou não forem dignos de um método. Então, seria bom aninhar catchblocos:

try {
    // Save something
} catch (Exception e) {
    // Something we do for all Exceptions
    catch (ProcessingException e) {
        // Something we do for all Processing exceptions
        catch (DBExcpetion e) {
            // DBExceptions are a subclass of ProcessingException
        }
        catch (BusinessRuleException e) {
            // BusinessRuleExceptions are also a subclass of ProcessingException
        }
    }
    // Something we do after specific sub class Exceptions
 }

Na programação da web, também me vejo frequentemente fazendo algo assim (este não é um exemplo real, portanto não analise casos de ficção):

Account a = getSavedAccount();
if (a == null) {
    a = getAccountFromSessionId();
}
if (a == null) {
    a = getAccountFromCookieId();
}
if (a == null) {
    a = createNewAccount();
}

Em Javascript (bem, ECMAScript e talvez outros que eu não conheça), já que qualquer valor pode ser avaliado como uma condição, ||pode ajudar.

var a = getAFromLocation1() || getAFromLocation2() || default;

Eu realmente gosto da aparência e desejo que mais idiomas, especialmente alguns do lado do servidor, tenham suporte para isso. (O PHP pode avaliar qualquer coisa como uma condição, mas converte toda a expressão condicional em um booleano em vez de preservar o valor. Não sei sobre Python ou Ruby.) Ele pode ficar complicado depois de três casos, mas se você tiver mais Em três casos, você também pode ter um design de software ruim.

O interruptor generalizado disse acima:

 switch(x){
  predicate1:
     dosomething();
  predicate2:
     dosomethingelse();
 }

Em Haskell:

  switch' :: a -> [(a -> Bool, b)] -> b
  switch' a [] = undefined
  switch' a (f,b):xs = if f a
                     then b
                      else switch' a xs

Em C #, eu gostaria de usar simples switch () { ... }, mas extensível com essas expressões:

switch (value)
{
  // string-based operators:
  case begins "Maria": // to catch Maria Carey
    break;
  case ends "Washington": // to catch George Washington
    break;
  case like "ph": // to catch Phil, Phillip, Sophie
    break;
  case between "Aaron" and "April": // to catch all names between
    break;

  // use non-static variables in case expression:
  case Dao.GetDefaultBabyName():
    break;

  // continuable cases without breaking
  case "John":
    bonus = 25;
  case "Peter":
    salary = 500;
    break;

  // jumps between cases
  case "Aleron":
    // do something
    break;
  case "Bella":
    // do something
    jump "Aleron";
    break;

}

E assim por diante. O mesmo com números ou outros tipos (que suportes IComparable, IConvertible...)

Isso pode tornar meu código mais lacônico e legível.

É uma pergunta divertida, como @Macneil disse.

Minha estrutura de controle incomum favorita, que eu (tosse humilde) descobri, é a execução diferencial .

Tem certos usos. Para mim, o uso predominante está na programação de interfaces de usuário, que é uma instância do problema mais geral de manter dados redundantes em correspondência. Por um lado, existem dados do aplicativo e, por outro, há controles da interface do usuário que precisam ser mantidos em concordância. Isso soa como "vinculativo", mas na verdade há muito mais.

Geralmente eu o implico por macros em C ou C ++. Em C #, eu tenho que fazer isso com instruções de expansão manual. Isso é uma dor, mas funciona.

Uma vez eu o implementei em termos de macros Lisp e ficou muito limpo. Não exigiu cuidado por parte do programador. Eu poderia ter feito a mesma coisa em qualquer outra linguagem estruturada se tivesse o cuidado de escrever um analisador completo e depois gerar as coisas certas. Esse é um grande projeto, e eu não o fiz.

Estruturas de controle "tradicionais", como foro controle do trabalhador, o mantêm subserviente às ideologias corruptas da elite capitalista dominante. É por isso que eu uso estruturas de controle alternativas ph0r. É como for, mas mais radical: você não vai pegar ph0rterno e gravata, jorrando alguns BS corporativos. ph0rmantém real, cara.

Combate o Poder!

forLoop mais simples

for(100)
{
    //Will run for 100 times
}


for(i)
{
    //Will run for i times while i must be a positive integer
}


for(i as a)
{
    //Will run for i times while i must be a positive integer
    //and a is the incremental loop variable starting from 0 and 
    //scoped within the loop
}


for(i as a=2)
{
    //Will run for i times while i must be a positive integer
    //and a is the incremental loop variable starting from 2 and 
    //scoped within the loop
}