CONVERSION REFERENCE

Containers and records

PyCForge admits fixed, local data shapes whose capacity, representation, access, and lifetime can be proved before C is rendered.

Fixed homogeneous containers

Lists, tuples, dictionaries, and admitted sets are function-local, fixed, automatic-storage conversion forms. Capacity is 1–64 elements. A binding is assigned exactly once directly in a function body and may be used only through a proved operation documented below.

Lists and tuples

def pick() -> int:
    values = [10, 20, 30]
    return values[-1]

• Elements use one homogeneous supported scalar representation: bool, int, float, or str.
• Indexing uses an in-range compile-time signed integer literal. Supported negative indices are resolved statically.
• Iteration is bounded by fixed capacity and preserves element order.

Sets and membership — new in 1.0.1

def is_priority(value: int) -> bool:
    priorities = {1, 4, 9}
    return value in priorities

def is_other(value: int) -> bool:
    priorities = {1, 4, 9}
    return value not in priorities

An admitted set is one directly assigned local literal containing 1–64 unique, homogeneous direct int, finite float, or bool literals. PyCForge proves that set order cannot be observed, then lowers storage to a read-only fixed automatic C array.

• in and not in are supported only with the set's direct local name as the single comparator.
• The searched expression must have the exact proved element representation. It is evaluated once into a generated temporary.
• Membership uses a deterministic bounded linear equality search with at most 64 comparisons. not in negates that result once.
• No heap allocation, hash table, mutation, cleanup, or Python runtime is introduced.

Empty sets, set comprehensions, duplicate elements, strings, heterogeneous or computed elements, inline membership sets, indexing, iteration, methods, mutation, aliasing, rebinding, passing, return, and escape reject. Set iteration is deliberately excluded because Python set order is not a portable observable order; it reports PYC3412. Set indexing reports PYC3411.

Dictionaries

def lookup() -> int:
    values = {'low': 1, 'high': 2}
    return values['high']

• Keys are unique literal int or str values with one homogeneous key representation.
• Values have one homogeneous supported scalar representation.
• Lookup requires a present literal key matching the proved key representation.
• Direct iteration yields the fixed keys in their source-defined order.

Container rejection boundary

Rejected forms include empty or oversized containers, heterogeneous or nested containers, comprehensions, generator expressions, unpacking, duplicate dictionary keys, dynamic indexing, element mutation, container methods, rebinding, aliasing, passing, returning, or escape. The set-specific boundaries above are additional and intentional.

Immutable automatic static records

A deliberately narrow top-level class shape becomes an inline automatic C record. Each record has 1–64 ordered int, float, or bool fields, followed by exactly one structural __init__.

class Point:
    x: int
    y: int

    def __init__(self, x: int, y: int) -> None:
        self.x = x
        self.y = y

def sum_point(left: int, right: int) -> int:
    point = Point(left, right)
    return point.x + point.y

• Fields are value-less annotated declarations in order, before __init__.
• Initializer parameters and direct self.field = parameter assignments match every field exactly.
• Construction is fresh, positional, and direct in a function body. Field reads are direct and statically resolved.
• No heap allocation, pointer alias, null record state, or cleanup helper is used.

Record rejection boundary

Other methods, inheritance, decorators, class-level values, dynamic or string fields, mutation after construction, rebinding, copying, aliasing, method calls, passing or returning records, storing records in containers, importing records, and cross-module record use reject.