Loop-switch sequence

A loop-switch sequence is a specific derivative of the spaghetti code programming antipattern where a clear set of steps is implemented as a byzantine switch-within-a-loop. Also known as "The FOR-CASE paradigm" [1].

Note: it is not necessarily an antipattern to use a switch statement within a loop. It is only considered incorrect when used to model a known sequence of steps. The most common example of the correct use of a switch within a loop is an event handler. In event handler loops, the sequence of events is not known at compile-time, so the repeated switch is both necessary and correct (see Event-driven programming, Event loop and Event-driven finite state machine). It is also reasonable to have a check for the possible performance loss that having a conditional inside a loop could bring. Today modern compilers are capable in some cases to transform the loop with conditional(s) into a construct with better performance (see loop unswitching); therefore it may not always be worthwhile to eliminate these constructs for performance reasons alone, although it may benefit readability to do so.

Example of antipattern (pseudocode)

  // parse a key, a value, then three parameters 

  String key;
  String value;
  List<String> args;
  
  for ( int i = 0; i < 5; ++i )
  {
    switch( i )
    {
      case 0 :
        key = stream.parse();
        break;
  
      case 1 :
        value = stream.parse();
        break;
  
      default:
        args.add( stream.parse() );
    }
  }

Refactored solution (pseudocode)

  // parse a key and value
  
  String key = stream.parse();
  String value = stream.parse();
  
  // parse 3 parameters

  List<String> args;
  
  for ( int i = 0; i < 3; ++i )
  {
    args.add( stream.parse() );
  }