Balanced brackets checker

# Self-authored for the EML case corpus (no external origin). Checks
# whether a string's brackets are correctly nested and matched, using a
# list as a stack — push on an opener, pop-and-compare on a closer. An
# application of the data structure the corpus's examples/simple-stack/
# defines in isolation. Popping is `stack[0:depth - 1] => stack` (slice
# rebuild), since EML has no `.pop()`.

def is_balanced(text):
    stack^+[]
    openers^+{"(": True, "[": True, "{": True}
    pairs^+{")": "(", "]": "[", "}": "{"}
    0 => i
    len(text) => n
    while i < n:
        text[i] => ch
        if ch in openers:
            stack + [ch] => stack
        elif ch in pairs:
            len(stack) => depth
            if depth == 0:
                return False
            stack[depth - 1] => top
            if top != pairs[ch]:
                return False
            stack[0:depth - 1] => stack
        i + 1 => i
    return len(stack) == 0

samples^+["(a[b]{c})", "{[()]}", "(]", "(((", ")(", "", "a(b)c[d]"]

for sample in samples:
    is_balanced(sample) => ok
    "'" + sample + "' -> " + str(ok) => line
    line^0

def is_balanced(text):
    stack = []
    openers = {"(": True, "[": True, "{": True}
    pairs = {")": "(", "]": "[", "}": "{"}
    i = 0
    n = len(text)
    while i < n:
        ch = text[i]
        if ch in openers:
            stack = stack + [ch]
        elif ch in pairs:
            depth = len(stack)
            if depth == 0:
                return False
            top = stack[depth - 1]
            if top != pairs[ch]:
                return False
            stack = stack[0:depth - 1]
        i = i + 1
    return len(stack) == 0

samples = ["(a[b]{c})", "{[()]}", "(]", "(((", ")(", "", "a(b)c[d]"]
for sample in samples:
    ok = is_balanced(sample)
    line = "'" + sample + "' -> " + str(ok)
    print(line)

'(a[b]{c})' -> True
'{[()]}' -> True
'(]' -> False
'(((' -> False
')(' -> False
'' -> True
'a(b)c[d]' -> True

Trace event types