Recursive structural pattern matching

"Structural pattern matching excels at... matching the structure of your objects! For the two examples in this article, we'll be using a number of dataclasses that you can use to build abstract Boolean expressions: from dataclasses import dataclass class Expr: pass @dataclass class And(Expr): exprs: list[Expr] @dataclass class Or(Expr): exprs: list[Expr] @dataclass class Not(Expr): expr: Expr @dataclass class Var(Expr): name: str"

"For example, the code Not(And([Var("A"), Var("B")])) represents the Boolean expression not (A and B). Evaluating a Boolean expression Suppose you have a Boolean expression built out of the components shared above. How do you evaluate that formula if you are given the assignments that map the variables to their values? For example, if you have the assignments {"A": True, "B": False} (for example, a dictionary that maps variable names to values), how can you determine that the expression Not(And([Var("A"), Var("B")])) is True?"

"This is where structural pattern matching can be applied recursively and it's where it really shines! To solve this problem, you will write a function called evaluate(expression: Expr, assignments: dict[str, bool]) -> bool. Your function accepts an expression and the assignments in the form of a dictionary and it returns the final Boolean value the expression evaluates to. Since you're accepting an expression, you're going to use the match statement on the full expression and then create a case branch for each of the possible expressions you might have: The structure of the code looks like this: def evaluate(expression: Expr, assignments: dict[str, bool]) -> bool: match expression: case Var(): pass case And(): pass case Or("

Structural pattern matching suits recursive, tree-like data and matches object structure. Dataclasses define Expr variants: And(exprs), Or(exprs), Not(expr), and Var(name). A compound expression like Not(And([Var("A"), Var("B")])) encodes not (A and B). To evaluate such expressions, provide a dictionary mapping variable names to Boolean values. Implement evaluate(expression: Expr, assignments: dict[str, bool]) -> bool. Use a match statement on the expression and create case branches for Var, And, Or, and Not. Evaluate leaves by consulting assignments and evaluate compound nodes recursively by combining subexpression results.

Read at Mathspp