L2.optimize 

 1from .constant_folding import constant_folding_term
 2from .constant_propogation import constant_propogation_term
 3from .dead_code_elimination import dead_code_elimination_term
 4from .syntax import Program
 5
 6
 7def optimize_program_step(
 8    program: Program,
 9) -> tuple[Program, bool]:
10    propagated = Program(
11        parameters=program.parameters,
12        body=constant_propogation_term(program.body, {}),
13    )
14    folded = Program(
15        parameters=propagated.parameters,
16        body=constant_folding_term(propagated.body, {}),
17    )
18    eliminated = Program(
19        parameters=folded.parameters,
20        body=dead_code_elimination_term(folded.body, {}),
21    )
22    return eliminated, eliminated != program
23
24
25def optimize_program(
26    program: Program,
27) -> Program:
28    current = program
29    while True:
30        current, changed = optimize_program_step(current)
31        if not changed:
32            return current
def optimize_program_step(program: L2.syntax.Program) -> tuple[L2.syntax.Program, bool]: 
 8def optimize_program_step(
 9    program: Program,
10) -> tuple[Program, bool]:
11    propagated = Program(
12        parameters=program.parameters,
13        body=constant_propogation_term(program.body, {}),
14    )
15    folded = Program(
16        parameters=propagated.parameters,
17        body=constant_folding_term(propagated.body, {}),
18    )
19    eliminated = Program(
20        parameters=folded.parameters,
21        body=dead_code_elimination_term(folded.body, {}),
22    )
23    return eliminated, eliminated != program
def optimize_program(program: L2.syntax.Program) -> L2.syntax.Program: 
26def optimize_program(
27    program: Program,
28) -> Program:
29    current = program
30    while True:
31        current, changed = optimize_program_step(current)
32        if not changed:
33            return current