Tolk Python Language Fragment

• Integer literals: 42, 0, 7 (only integers; no floats, hex, octal, or binary).
• Boolean literals: True (t), False (nil).
• None literal: None (represented as :none).

No string literals. No float literals. No complex or imaginary numbers.

Supported, with standard precedence (PEMDAS):

+

addition (:add)

-

subtraction (:sub)

*

multiplication (:mult)

/

division (:div)

Operator precedence is encoded grammatically: * and / bind tighter than + and - Associativity is left-to-right. Parentheses override precedence: (2 + 3) * 4.

+

unary plus (:uadd)

-

unary minus (:usub)

not

boolean negation (:not)

Unary minus has higher precedence than binary operators: -2 + 3 parses as ((-2) + 3).

==

equality (:eq)

!=

inequality (:noteq)

<

less than or equal (:lte)

>=

greater than or equal (:gte)

<

less than (:lt)

>

greater than (:gt)

Comparisons are a single compare node with one operator/comparator pair (chained comparisons like 0 < x < 10 are not supported).

and

conjunction (:and)

or

disjunction (:or)

Short-circuit semantics are standard. and and or form boolop nodes with a list of operands. Precedence: not > and > or.

Identifiers follow Python naming rules: a letter or underscore followed by letters, digits, or underscores. Examples: x, foo_bar, _private.

Keywords (True, False, None, and, or, not, lambda, def, return, if, else, elif) are reserved and cannot be used as names.

Names carry a context slot :ctx set to :load (reading) or :store (target of assignment). This mirrors Python's ast.Name.ctx.

x = 5

Simple assignment to a single identifier. The target is a name node with :ctx :store. No tuple unpacking, no multiple assignment (a = b = 1), no augmented assignment (+, -=, etc.).

arr[i] = value

Indexed assignment. Parsed as a subscript-assign node carrying the array name, index expression, and value expression. This is a statement, distinct from subscript expressions.

x if True else y

The body (then-branch) comes first, matching Python's syntax. Parsed as an ifexpr node with :test, :body, and :orelse slots.

lambda x: x + 1
lambda x, y: x + y
lambda: 42

Parameter list (zero or more comma-separated identifiers), colon, single-expression body. Parsed as a lambda-expr node.

f(1, 2)
add(3, 4)

Comma-separated argument list in parentheses. Zero-argument calls are supported. Calls can be chained: f(1)(2). Parsed as call nodes.

def f(x): x + 1
def add(x, y): x + y
def hello(): 42

A name, optional parameter list, colon, and a body. The body is parsed as a *=block= (INDENT … DEDENT), a return-stmt, or a single expr. Functions are first-class; they create closures at runtime.

return 42

Returns a value from a function. Parsed as a return-stmt node.

if x > 0:
    y = 1
elif x < 0:
    y = -1
else:
    y = 0

if, optional elif (desugared to nested if-stmt nodes), optional else. Each branch contains a block of statements. The test expression appears before the colon (if test:).

[1, 2, 3]
arr[i]
arr[1:5]
arr[::2]

• List literals: Comma-separated expressions in square brackets. Empty lists ([]) are supported. Parsed as list-expr.
• Subscripts: Single index (arr[i]) parsed as subscript. Slices (arr[start:stop:step]) parsed as slice nodes; all three parts are optional.

No dictionary or set literals. No tuple syntax (parsing 1, 2, 3 is not supported). No comprehension syntax.

The parse-program function handles multi-statement programs. Statements are separated by NEWLINE tokens (inserted by the preprocessor). The result is a list of statement ASTs (not wrapped in a module node).

Statements at the top level may be assignments, function definitions, if statements, or expressions. Execution returns the value of the last statement.