Quelles structures de contrôle alternatives utiles connaissez-vous? [fermé]

Une question similaire a été close sur SO.

Parfois, lorsque nous programmons, nous constatons qu'une structure de contrôle particulière nous serait très utile, mais n'est pas directement disponible dans notre langage de programmation.

Selon vous, quelles structures de contrôle alternatives sont un moyen utile d'organiser le calcul?

Le but ici est d'obtenir de nouvelles façons de penser la structuration du code, afin d'améliorer le découpage et le raisonnement.

Vous pouvez créer une syntaxe / sémantique à souhait non disponible actuellement ou citer une structure de contrôle moins connue sur un langage de programmation existant.

Les réponses devraient donner des idées pour un nouveau langage de programmation ou pour améliorer un langage réel.

Considérez cela comme un remue-méninges, alors postez quelque chose que vous pensez être une idée folle, mais cela peut être viable dans certains scénarios.

Il s'agit d'une programmation impérative.

OK, c'est une question amusante.

Je voudrais également avoir un général elsepour les boucles while et for, lorsque la condition n'est pas vraie lors du premier test:

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

Cela évite le recalcul maladroit de la condition ou son stockage dans une variable.

Pourquoi ne pas mélanger quelques réponses en une seule?

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.

Une syntaxe de construction de contrôle de flux généralisée et extensible dans un langage impératif serait plutôt utile et divertissante. Jusqu'à ce que cela apparaisse, je suppose que je vais simplement utiliser Lisp ou quelque chose.

Les structures de contrôle en tant que fonctions.

Je veux for, if, else, while, etc. comme des fonctions, et non pas des structures spéciales.

Je veux return, try/exceptet gotoêtre des dérivés de suites.

Bien sûr, cela a moins à voir avec une structure de contrôle particulière et plus à voir avec la façon dont vous voyez les structures de contrôle en général, la méta des structures de contrôle.

L'article lié comprend clairement les boucles N + 1/2 de Donald Knuth . Exprimé en C / C ++ / Java:

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

Ceci est utile pour lire des lignes ou des caractères d'un fichier, tester si vous avez atteint EOF, puis le traiter. Je suis tellement habitué à voir le motif for(;;)..if(..)break;apparaître qu'il est idiomatique pour moi. (Avant d'avoir lu l'article de Knuth, réimprimé dans le livre Literate Programming , celui-ci était un "wtf?".)

Knuth a suggéré les mots clés loop/while/repeat:

loop:
  S;
while C:
  T;
repeat

Où Set Tsont les espaces réservés pour une série de zéro ou plusieurs instructions, et Cest une condition booléenne. S'il n'y avait pas de Sdéclaration, ce serait une boucle while, et s'il n'y avait pas de Tdéclaration, ce serait une boucle do.

Cette construction elle-même pourrait être généralisée en autorisant zéro ou plusieurs while Cclauses, ce qui la rend parfaite pour exprimer des boucles infinies, puis des conditions plus rares qui nécessiteraient deux vérifications.

Dans le même article, Knuth a suggéré un mécanisme de signalisation qui serait une version locale des exceptions de lancement / capture (comme alternative à l'utilisation de goto).

Pour moi? Je souhaite que Java supporte l'optimisation des appels, afin que je puisse exprimer n'importe quelle structure de contrôle générale selon les besoins.

Mise à jour: j'ai oublié de mentionner que de nombreux programmeurs C / C ++ / Java contournent celui-ci en utilisant une affectation intégrée dans l'état de while:

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

En utilisant les termes de la construction de Knuth, cela est permis quand Set Cpeut être combiné en une seule expression. Certaines personnes détestent voir l'affectation intégrée ci-dessus, tandis que d'autres détestent voir breakce qui for (;;)précède. Mais quand Set Cne peut pas être combiné, comme quand Sa plusieurs instructions, le for (;;)est la seule alternative sans répéter le code. L'autre alternative est de simplement dupliquer le Scode:

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

L' loop/while/repeatalternative de Knuth semble bien meilleure.

Le langage BCPL avait une valueofexpression qui pouvait être utilisée pour transformer une séquence d'instructions en une seule expression:

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

Où some series of statementspeut être n'importe quoi et le tout valueofs'évalue v.

Cela peut être utile en Java lorsque vous devez calculer un argument pour appeler un this()ou super()(ce qui nécessite que rien ne se passe avant). Bien sûr, vous pouvez simplement écrire une méthode distincte, mais cela pourrait être difficile si vous devez passer de nombreuses valeurs locales pour le contexte.

Si vous pouvez utiliser finalpour les variables nécessaires, vous pouvez déjà faire un valueofen Java en utilisant des classes internes anonymes:

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

unless(condition) {
  // ...
}

fait la même chose que:

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

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

fait la même chose que:

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

Sur une note différente, je voudrais voir un meilleur support pour les itérateurs dans les langages de programmation. En particulier, lorsque vous souhaitez descendre deux collections par paires :

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

Certains langages dynamiques peuvent déjà l'avoir, ou être facilement pris en charge via des bibliothèques et des macros, mais je pense que c'est dans l'esprit de votre question.

Si les deux ensembles ne sont pas de la même taille, cela pourrait déclencher une exception ou vous pourriez avoir un elseaprès la boucle pour signaler qu'il y avait une différence de taille.

Naturellement, vous pouvez généraliser cela pour descendre trois listes ou plus.

Mise à jour: Il serait également utile de faire le produit cartésien entre les itérables:

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

qui ne serait rien de plus que des boucles imbriquées:

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

Je m'inquiète un peu qu'entre les deux notations que j'ai fournies ici, il y ait une différence O (n) et O (n ^ 2) dans le nombre de paires, avec seulement le changement d'un seul caractère.

Il existe ce qu'on appelle la "boucle de Dijkstra" (également appelée "boucle gardée de Dijkstra"). Il a été défini dans The Guarded Command Language (GCL) . Vous pouvez trouver des informations sur la syntaxe et la sémantique dans l'article Wikipédia ci-dessus à la section 6 Répétition: faire .

De nos jours, je connais en fait un langage de programmation qui prend directement en charge cette structure de contrôle. Il s'agit d' Oberon-07 (PDF, 70 Ko). Et il prend en charge "Dijkstra's Loop" sous votre forme de déclaration while. Jetez un œil à la section 9.6. Alors que les déclarations dans le PDF ci-dessus.

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

PS Ceci est une copie de ma réponse SO .

Expressions de style icône avec retour en arrière intégré.

Python bénéficie de nombreux avantages du générateur d'icônes - et en fait un meilleur travail en général, l'OMI. Et en principe, le retour en arrière n'était qu'une sorte de lancer d'exception, mais c'était la simplicité des expressions l'équivalent approximatif de ...

x = (a / b) else c;

pour gérer les cas d'échec comme la division par zéro.

Où Icon est devenu fou - aucun opérateur de comparaison à retour booléen. Les comparaisons ont toujours réussi ou déclenché un retour en arrière, et il y avait un autre problème sémantique dont j'essaie désespérément de me souvenir ... eh bien, disons simplement qu'il est probablement plus réprimé qu'oublié.

J'ai toujours pensé qu'ils devraient avoir une ifexpression sans autre partie - if (condition, success-value)genre de chose, revenir en arrière si la condition retourne fausse - et abandonner les comparaisons étranges.

EDIT Je me souviens - vraiment évident. Une comparaison avec deux arguments réussit ou échoue - elle ne calcule pas de nouvelle valeur à renvoyer. Alors, quand il réussit, que revient- il? Réponse - l'un des arguments. Mais si vous écrivez a > b, quel est l'argument logique pour retourner - aou b? Et si vous écrivez à la b < aplace? Je pense que cela renvoyait toujours le bon argument, ce qui a autant de sens que n'importe quoi, mais cela me semblait toujours le mauvais argument.

Ce n'est qu'une idée générale et une syntaxe:

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

La condition AUSSI est toujours évaluée. ELSE fonctionne comme d'habitude.

Cela fonctionne pour le cas aussi. C'est probablement un bon moyen d'éliminer la déclaration de rupture:

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

peut être lu comme:

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

Je ne sais pas si c'est utile ou simple à lire mais c'est un exemple.

La continuité du style de passage me vient à l'esprit. Ensuite, bien sûr, vous aimeriez également avoir l' optimisation des appels de queue .

Branche de thread transparente, elle a la syntaxe comme une fonction, mais s'exécute dans un thread séparé et ne peut pas accéder aux données qui ne lui ont pas été initialement transmises.

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

Lorsqu'une branche est appelée, elle renvoie immédiatement un handle.

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

La poignée peut être utilisée pour vérifier si la tâche est terminée.

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

Si le résultat est demandé avant la fin de l'exécution, le thread principal attendra simplement.

[result, storage]=handle.result()

Cela ne couvrirait pas les scénarios de multithreading les plus avancés, mais fournirait plutôt un moyen facilement accessible de commencer à utiliser plusieurs cœurs.

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

Les blocs FIRST et THEN s'exécutent si l'une des 3 conditions est évaluée comme vraie. PREMIER bloc s'exécute avant le bloc conditionnel et ALORS s'exécute après l'exécution du bloc conditionnel.

ELSE l'écriture conditionnelle ou finale suivant les instructions FIRST et THEN est indépendante de ces blocs.

Il peut se lire comme suit:

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

Ces fonctions ne sont qu'un formulaire à lire. Ils ne créeraient pas de portée. Cela ressemble plus à un gosub / return de Basic.

Utilité et lisibilité comme sujet de discussion.

Je me retrouve parfois à écrire une boucle qui doit faire quelque chose de différent lors de la première itération. Par exemple, afficher les balises <th> au lieu des balises <td>.

Je gère cette situation avec un drapeau booléen. Quelque chose comme ça:

first = true

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

Il semble stupide de vérifier la valeur de firstà chaque itération alors que ce sera faux la plupart du temps.

J'aimerais avoir une option de bouclage pour spécifier un corps de boucle différent lors de la première itération. Il n'y aurait pas besoin d'une variable distincte. Le code compilé n'en aurait pas besoin non plus, car le code généré aurait deux corps, un pour la première itération et un pour le reste.

[copié de ma propre réponse sur stackoverflow]

ignoring - Pour ignorer les exceptions se produisant dans un certain bloc de code.

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

Avec une construction de contrôle ignorant, vous pouvez l'écrire de manière plus concise et plus lisible sous la forme:

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

[Scala fournit cela (et de nombreuses autres constructions de contrôle de gestion des exceptions) dans sa bibliothèque standard, dans le package util.control. ]

Au lieu de:

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

Faites-le en Python, ou maintenant aussi en C #:

action = val2func[myEnum]
action()

Scala a beaucoup de nouvelles fonctionnalités.

Enfin, des langages tels que Clojure peuvent être étendus pour fournir des fonctionnalités supplémentaires.

J'ai deux idées.

Souvent, je trouve que je me répète par catchblocs. Cela peut être quelque peu aidé par l'extraction de méthodes, mais cela peut entraîner un encombrement inutile si les méthodes sont très courtes ou autrement dignes d'une méthode. Donc, ce serait bien d'imbriquer des catchblocs:

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
 }

Dans la programmation Web, je me retrouve souvent à faire quelque chose comme ça (ce n'est pas un vrai exemple, alors n'analysez pas les cas fictifs):

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

En Javascript (enfin, ECMAScript, et peut-être d'autres que je ne connais pas), car n'importe quelle valeur peut être évaluée comme condition, ||peut aider.

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

J'aime vraiment à quoi cela ressemble, et je souhaite que plus de langues, en particulier certaines côté serveur, soient prises en charge. (PHP peut évaluer n'importe quoi en tant que condition, mais convertit toute l'expression conditionnelle en un booléen au lieu de conserver la valeur. Je ne sais pas pour Python ou Ruby.) Cela pourrait devenir compliqué après environ trois cas, mais si vous en avez plus de trois cas, vous pourriez également avoir une mauvaise conception de logiciel.

Le commutateur généralisé a dit ci-dessus:

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

À 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 #, je voudrais utiliser des switch () { ... }expressions simples mais extensibles:

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;

}

Etc. La même chose avec des chiffres ou d' autres types (que supports IComparable, IConvertible...)

Cela pourrait rendre mon code plus laconique et lisible.

C'est une question amusante, comme l'a dit @Macneil.

Ma structure de contrôle inhabituelle préférée, que j'ai (humble toux) découverte, est l' exécution différentielle .

Il a certaines utilisations. Pour moi, l'écrasante utilisation est dans la programmation des interfaces utilisateur, ce qui est un exemple du problème plus général de la maintenance des données redondantes en correspondance. D'une part, il y a des données d'application, et d'autre part, il y a des contrôles d'interface utilisateur, qui doivent être maintenus en accord. Cela ressemble à "contraignant" mais il y a en fait beaucoup plus.

Habituellement, je l'implémente par des macros en C ou C ++. En C #, je dois le faire en développant des instructions à la main. C'est une douleur, mais ça marche.

Une fois que je l'ai implémenté en termes de macros Lisp, puis c'était très propre. Cela n'a pas exigé de prudence de la part du programmeur. J'aurais pu faire la même chose dans n'importe quel autre langage structuré si j'avais pris la peine d'écrire un analyseur complet puis de générer toutes les bonnes choses. C'est un gros projet et je ne l'ai pas fait.

Les structures de contrôle "traditionnelles" comme le forcontrôle du travailleur, le gardant soumis aux idéologies corrompues de l'élite capitaliste au pouvoir. C'est pourquoi j'utilise des structures de contrôle alternatives comme à la ph0rplace. C'est comme for, mais plus radical: vous ne vous surprendrez pas à ph0rporter un costume et une cravate, jaillissant de certains BS d'entreprise. ph0rle garde réel, mec.

Combattre le pouvoir!

Simplest forboucle-

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
}