¿Qué estructuras de control alternativas útiles conoces? [cerrado]

Pregunta similar se cerró en SO.

A veces, cuando estamos programando, encontramos que alguna estructura de control particular sería muy útil para nosotros, pero no está directamente disponible en nuestro lenguaje de programación.

¿Qué estructuras de control alternativas crees que son una forma útil de organizar la computación?

El objetivo aquí es obtener nuevas formas de pensar sobre la estructuración del código, a fin de mejorar la fragmentación y el razonamiento.

Puede crear una sintaxis / semántica deseable que no esté disponible ahora o citar una estructura de control menos conocida en un lenguaje de programación existente.

Las respuestas deben dar ideas para un nuevo lenguaje de programación o mejorar un lenguaje real.

Piense en esto como una lluvia de ideas, así que publique algo que piense que es una idea loca pero que puede ser viable en algún escenario.

Se trata de una programación imperativa.

OK, esta es una pregunta divertida.

También me gustaría tener un general elsepara while y para bucles, para cuando la condición no es cierta en la primera prueba:

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

Esto evita el recálculo incómodo de la condición o el almacenamiento en una variable.

¿Por qué no mezclar algunas respuestas en una?

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.

Una sintaxis de construcción de control de flujo generalizada y extensible en un lenguaje imperativo sería bastante útil y entretenida. Hasta que aparezca, supongo que solo usaré Lisp o algo así.

Estructuras de control como funciones.

Quiero for, if, else, while, etc que son funciones, no estructuras especiales.

Quiero return, try/excepty gotoser derivados de continuaciones.

Por supuesto, esto tiene menos que ver con una estructura de control particular y más con la forma en que ve las estructuras de control en general, las estructuras meta de control.

El artículo vinculado definitivamente lo hace bien sobre los N + 1/2 Loops de Donald Knuth . Expresado en C / C ++ / Java:

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

Esto es útil para leer líneas o caracteres de un archivo, probar si ha alcanzado EOF y luego procesarlo. Estoy tan acostumbrado a ver for(;;)..if(..)break;aparecer el patrón que es idiomático para mí. (Antes de leer el artículo de Knuth, reimpreso en el libro Literate Programming , este solía ser un "wtf?").

Knuth sugirió las palabras clave loop/while/repeat:

loop:
  S;
while C:
  T;
repeat

Donde Sy Tson marcadores de posición para una serie de cero o más declaraciones, y Ces una condición booleana. Si no hubiera una Sdeclaración, entonces sería un ciclo while, y si no hubiera una Tdeclaración, sería un ciclo do.

Esta construcción en sí misma podría generalizarse permitiendo cero o más while Ccláusulas, haciéndola perfecta para expresar bucles infinitos y luego algunas condiciones más raras que necesitarían dos comprobaciones.

En el mismo artículo, Knuth sugirió un mecanismo de señalización que sería una versión local de lanzar / atrapar excepciones (como alternativa al uso de goto).

¿Para mi? Deseo que Java sea compatible con la optimización de llamadas de cola, para poder expresar cualquier estructura de control general según sea necesario.

Actualización: Olvidé mencionar que muchos programadores de C / C ++ / Java eluden este usando una asignación incrustada en la condición de while:

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

El uso de los términos de constructo de Knuth, esto es admisible cuando Sy Cse pueden combinar en una sola expresión. Algunas personas odian ver la tarea incrustada arriba, mientras que otras odian verla breaken lo for (;;)anterior. Pero cuando Sy Cno se pueden combinar, como cuando Stiene múltiples declaraciones, esta for (;;)es la única alternativa sin repetir el código. La otra alternativa es simplemente duplicar el Scódigo:

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

La loop/while/repeatalternativa de Knuth parece mucho mejor.

El lenguaje BCPL tenía una valueofexpresión que podía usarse para convertir una secuencia de declaraciones en una sola expresión:

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

Donde some series of statementspuede ser cualquier cosa y todo se valueofevalúa v.

Esto podría ser útil en Java para cuando necesite calcular un argumento para llamar a this()o super()(lo que requiere que no suceda nada antes). Por supuesto, podría escribir un método separado, pero eso podría ser un problema si necesita pasar muchos valores locales para el contexto.

Si puede usar las finalvariables que necesita, ya puede hacer un valueofen Java utilizando clases internas anónimas:

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

unless(condition) {
  // ...
}

hace lo mismo que:

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

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

hace lo mismo que:

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

En una nota diferente, me gustaría ver un mejor soporte para iteradores en lenguajes de programación. En particular, para cuando quieres bajar dos colecciones en pares :

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

Es posible que algunos lenguajes dinámicos ya tengan esto, o que sean fácilmente compatibles a través de bibliotecas y macros, pero creo que esto está en el espíritu de su pregunta.

Si los dos conjuntos no son del mismo tamaño, podría generar una excepción o podría tener un elsebucle posterior para indicar que hubo una diferencia en los tamaños.

Naturalmente, podría generalizar esto para bajar tres o más listas.

Actualización: También sería útil hacer el producto cartesiano entre iterables:

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

que no sería más que bucles anidados:

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

Me preocupa un poco que entre las dos notaciones que he proporcionado aquí haya una diferencia de O (n) y O (n ^ 2) en el número de pares, con solo el cambio de un solo carácter.

Existe el llamado "bucle de Dijkstra" (también llamado "bucle guardado de Dijkstra"). Se definió en The Guarded Command Language (GCL) . Puede encontrar información sobre la sintaxis y la semántica en el artículo de Wikipedia anterior en la sección 6 Repetición: do .

Hoy en día conozco un lenguaje de programación que soporta esta estructura de control directamente. Es Oberon-07 (PDF, 70 KB). Y es compatible con "Dijkstra's Loop" en tu forma de declaración while. Echa un vistazo a la sección 9.6. Mientras que las declaraciones en el PDF anterior.

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

PD: Esta es una copia de mi respuesta SO .

Expresiones de estilo de icono con retroceso incorporado.

Python obtiene muchos de los beneficios del generador de íconos, y en general funciona mejor, IMO. Y, en principio, el retroceso fue solo una especie de lanzamiento de excepción, pero fue la simplicidad de las expresiones el equivalente aproximado de ...

x = (a / b) else c;

para manejar casos de falla como la división por cero.

Donde Icon se volvió loco: sin operadores de comparación de retorno booleano. Las comparaciones siempre tuvieron éxito o provocaron un retroceso, y hubo otro problema semántico que ahora estoy tratando desesperadamente de recordar que ... bueno, digamos que probablemente sea más reprimido que olvidado.

Siempre pensé que deberían tener una ifexpresión sin otra parte ( if (condition, success-value)tipo de cosa, retroceder si la condición vuelve falsa) y descartar las extrañas comparaciones.

EDITAR Recuerdo, obviamente obvio. Una comparación con dos argumentos tiene éxito o falla: no calcula un nuevo valor para devolver. Por eso, cuando tiene éxito, lo que hace que vuelva? Respuesta: uno de los argumentos. Pero si escribes a > b, ¿cuál es el argumento lógico para volver, ao b? ¿Y qué pasa si escribes en su b < alugar? Yo creo que siempre se devuelve el argumento de la derecha, que tiene tanto sentido como cualquier cosa, pero todavía por lo general parecía que el argumento mal a mí.

Esta es solo una idea general y una sintaxis:

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

TAMBIÉN la condición siempre se evalúa. ELSE funciona como de costumbre.

Funciona para el caso también. Probablemente sea una buena forma de eliminar la declaración de ruptura:

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

se puede leer como:

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

No sé si esto es útil o simple de leer, pero es un ejemplo.

Continuar Pasando Estilo viene a la mente. Entonces, por supuesto, también le gustaría tener la Optimización de llamadas de cola .

Ramificación de subprocesos sin problemas, tiene una sintaxis como una función, pero se ejecuta en un subproceso separado y no puede acceder a los datos que inicialmente no se le han pasado.

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

Cuando se llama a una rama, inmediatamente devolverá un identificador.

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

El identificador se puede usar para verificar si la tarea está hecha.

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

Si se solicita el resultado antes de que se complete la ejecución, el hilo principal simplemente esperará.

[result, storage]=handle.result()

Esto no cubriría los escenarios de subprocesos múltiples más avanzados, sino que proporcionaría una forma fácilmente accesible de comenzar a utilizar múltiples 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

Los bloques FIRST y THEN se ejecutan si alguno de los 3 condicionales se evalúa como verdadero El primer bloque se ejecuta antes del bloque condicional y ENTONCES se ejecuta después de que se haya ejecutado el bloque condicional.

ELSE escritura condicional o final después de la declaración FIRST y THEN son independientes de estos bloques.

Se puede leer 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

Estas funciones son solo una forma de leer. No crearían alcance. Es más como un gosub / return de Basic.

Utilidad y legibilidad como tema de discusión.

A veces me encuentro escribiendo un bucle que necesita hacer algo diferente durante la primera iteración. Por ejemplo, mostrar etiquetas <th> en lugar de etiquetas <td>.

Manejo esta situación con una bandera booleana. Algo como esto:

first = true

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

Parece una tontería comprobar el valor de firstcada iteración cuando será falso la mayor parte del tiempo.

Me gustaría tener una opción de bucle para especificar un cuerpo de bucle diferente en la primera iteración. No habría necesidad de una variable separada. El código compilado tampoco necesitaría uno, porque el código generado tendría dos cuerpos, uno para la primera iteración y otro para el resto.

[copiado de mi propia respuesta en stackoverflow]

ignoring - Para ignorar las excepciones que ocurren en un determinado bloque de código.

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

Con una construcción de control ignorante, puede escribirla de manera más concisa y más legible como:

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

[Scala proporciona esto (y muchas otras construcciones de control de manejo de excepciones) en su biblioteca estándar, en el paquete util.control. ]

En lugar de:

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

Hazlo en Python, o ahora también en C #:

action = val2func[myEnum]
action()

Scala tiene muchas características nuevas.

Finalmente, lenguajes como Clojure pueden ampliarse para proporcionar la funcionalidad adicional.

Tengo dos ideas

A menudo encuentro que me estoy repitiendo en catchbloques. Esto puede ser de alguna manera ayudado a través de métodos de extracción, pero eso puede causar desorden innecesario si los métodos son muy cortos o no son dignos de un método. Por lo tanto, sería bueno anidar catchbloques:

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
 }

En la programación web, a menudo me encuentro haciendo algo como esto (este no es un ejemplo real, así que no analice casos ficticios):

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

En Javascript (bueno, ECMAScript, y tal vez otros con los que no estoy familiarizado), ya que cualquier valor puede evaluarse como una condición, ||puede ayudar.

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

Realmente me gusta cómo se ve, y deseo que más idiomas, especialmente algunos en el lado del servidor, tengan soporte para ello. (PHP puede evaluar cualquier cosa como condición, pero convierte toda la expresión condicional en un valor booleano en lugar de preservar el valor. No sé acerca de Python o Ruby.) Podría volverse difícil de manejar después de tres casos más o menos, pero si tiene más de tres casos, también puede tener un mal diseño de software.

El interruptor generalizado ha dicho anteriormente:

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

En Haskell:

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

En C # me gustaría usar simples switch () { ... }, pero extensibles con tales expresiones:

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;

}

Y así. Lo mismo con números u otros tipos (que admite IComparable,IConvertible , ...)

Esto podría hacer que mi código sea más lacónico y legible.

Es una pregunta divertida, como dijo @Macneil.

Mi estructura de control inusual favorita, que descubrí (humilde tos), es la ejecución diferencial .

Tiene ciertos usos. Para mí, el uso abrumador es en la programación de interfaces de usuario, que es una instancia del problema más general de mantener datos redundantes en correspondencia. Por un lado, hay datos de aplicaciones y, por otro, hay controles de interfaz de usuario que deben mantenerse de acuerdo. Esto suena como "vinculante", pero en realidad hay mucho más.

Por lo general, lo implemento por macros en C o C ++. En C # tengo que hacerlo mediante declaraciones de expansión manual. Eso es un dolor, pero funciona.

Una vez que lo implementé en términos de macros Lisp, y luego estaba muy limpio. No requirió cuidado por parte del programador. Podría haber hecho lo mismo en cualquier otro lenguaje estructurado si me hubiera tomado la molestia de escribir un analizador completo y luego generar todas las cosas correctas. Ese es un gran proyecto, y no lo he hecho.

Las estructuras de control "tradicionales" fortienen que ver con el control del trabajador, manteniéndolo subordinado a las ideologías corruptas de la élite capitalista gobernante. Es por eso que uso estructuras de control alternativas como en su ph0rlugar. Es como for, pero más radical: no te sorprenderá ph0rusar traje y corbata, escupiendo algunas BS corporativas. ph0rlo mantiene real, hombre.

¡Luchar contra el poder!

forBucle más simple

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
}