[8.1.5] Nested Statements

[8.1.5] Nested Statements

What are nested statements?

Nested statements are control structures placed inside other control structures. In IGCSE Computer Science, you will most often nest selection (IF...THEN...ELSEIF...ELSE) inside selection, or iteration (FOR, WHILE, REPEAT UNTIL) inside iteration, or combine the two (for example, an IF inside a loop). Nesting lets a program make more precise decisions or repeat more detailed sets of steps.

The syllabus expects you to understand and use nested selection and iteration, up to a practical limit of no more than three levels of nesting. Deep nesting can be hard to read and maintain, so you should develop habits that keep structure clear: choose meaningful conditions, group related steps, and add parentheses and indentation consistently.

Why do we nest?

Nesting solves multi-stage decisions and layered repetition. For example, a shop may first check a customer's age, then if they have a loyalty card, then apply a discount. Likewise, when printing a calendar grid, you repeat over weeks, and inside each week you repeat over days. These are naturally nested processes that would be awkward without nesting.

Nesting selection (IF inside IF)

Nesting selection is useful when one decision depends on the outcome of a previous decision. Keep conditions specific and avoid overlapping ranges. Prefer ELSEIF chains for mutually exclusive branches, and use a final ELSE for an “otherwise” case.

• Clear Nested IF (two levels)
• Refactor to ELSEIF Chain
• Edge Case: Overlapping Conditions

Nesting iteration (loops inside loops)

Nested iteration repeats an inner process for every step of an outer process. Typical uses include table generation (rows and columns), searching a 2D structure, or combining items from two lists. Limit nesting to necessary levels and include clear loop counters.

• Two Loops: Rows and Columns
• Loop With Inner Selection
• Edge Case: Three Levels

Combining selection and iteration

Real problems often combine loops and decisions. For instance, while reading a list of temperatures, an outer loop steps through the data and an inner IF counts how many are above a threshold. Another common structure is input validation: repeat asking for input (loop) until it satisfies a condition (IF).

• Validation Loop (REPEAT...UNTIL)
• Counting With Condition (WHILE + IF)
• FOR Inside IF: Conditional Iteration

Design tips for readable nesting

• Guard first: check for invalid or trivial cases at the top with an IF, so the main logic is cleaner.
• Prefer ELSEIF chains to multiple nested IF blocks when only one branch should run.
• Limit depth: aim for no more than three levels. Extract repeated or complex steps into procedures or functions.
• Name counters and flags meaningfully, e.g. row, col, isValid.
• Test boundaries: values at the edges of ranges often reveal nesting mistakes.

Common patterns to master

Deep Dive: Avoiding the “arrow shape”

Deeply nesting IF inside IF can create a right-slanting “arrow” of indentation that is hard to read. To avoid this, apply guard clauses (validate and handle invalid cases early), use ELSEIF for mutually exclusive tests, and move repeated logic into a procedure. If the inner logic depends on a value that you can compute once, calculate it before the decision to reduce inner complexity.

Deep Dive: Loop invariants and termination

When nesting loops, ensure each loop has a clear invariant (what stays true each time) and a correct termination condition. For instance, in a two-loop grid print, the inner loop must reset its counter each time the outer loop advances, and both counters must eventually reach their limits. Off-by-one mistakes in either loop can break the overall structure.

Worked examples with copy support

// CAIE-style pseudocode: validation loop (nested selection in iteration)
DECLARE mark : INTEGER
REPEAT
    INPUT mark
    IF (mark < 0) OR (mark > 100) THEN
        OUTPUT "Invalid. Enter 0..100."
    ENDIF
UNTIL (mark >= 0) AND (mark <= 100)

// CAIE-style pseudocode: 2D traversal (nested iteration)
DECLARE row : INTEGER
DECLARE col : INTEGER
FOR row ← 1 TO 3
    FOR col ← 1 TO 3
        OUTPUT row * col
    NEXT col
NEXT row

# Python equivalents
# Validation loop (repeat-until emulated)
while True:
    mark = int(input())
    if (mark < 0) or (mark > 100):
        print("Invalid. Enter 0..100.")
    else:
        break

# 2D traversal
for row in range(1, 4):
    for col in range(1, 4):
        print(row * col)