What a program looks like

A loop, if, try, bare call, augmented assignment, tuple unpacking, or write through a subscript or attribute at module level. A WebAssembly module has no top-level run step, so the statement would be compiled away. X = 1, X = helper(), X = ClassName(), def, class, and imports (a try/except ImportError guarded import included) do work, and a definition that is not a plain constant is evaluated once, at instantiation, in source order, so every function shares the same list or instance. Move the rest into a function, or under if __name__ == "__main__":.

There is no event loop in the output.

Functions and __init__ take *args: T (a tuple of T), **kwargs: T (a dict[str, T]), and keyword-only parameters, f(*xs) passes a list or tuple on as *args, and keyword arguments work in every call. Other methods take neither starred nor keyword-only parameters, a call cannot unpack a dict with **, and / is refused. Every call to one of the module's own functions is checked against its signature, so a surplus or missing argument is a compile-time TypeError.

Not implemented. Each is reported by name with its location, and so is del of an attribute or a stepped slice. global, nonlocal, nested def, assert, conditional expressions, and del of a list index, list slice, or dict key do work.

Multiple inheritance works, along CPython's C3 method resolution order with cooperative super(), and so do metaclasses: a metaclass's __new__ and __init__ run once for each class it makes, specialized at compile time, and its __call__ replaces instantiation. The class namespace argument, __prepare__, creating a class by calling the metaclass, and class keywords other than metaclass= are refused.

Every implementation of an overridden method is reached through one indirect call, which names a single WebAssembly signature, so def m(self) in the base and def m(self, k: int) in the subclass is refused. Give the override the same parameters and return type.

A lambda's parameters, and a nested function's unannotated ones, take their types from the calls in their scope when those agree, and a sorted() key's from the elements it is given, so sorted(pairs, key=lambda kv: kv[1]) works. A parameter nothing types (a lambda only passed on to an unannotated parameter, or called with an int in one place and a str in another) holds an untyped word, so kv[1] or len(w) on it is refused rather than answering from that word. Use a named def, whose parameters can be annotated.

The method kinds, @dataclass, @abstractmethod, @functools.total_ordering, @functools.singledispatch with @f.register, the caching decorators (accepted, no effect), and decorators the program writes itself all work on module functions: a user decorator is applied at compile time and specialized for each function it wraps, factories and stacks included. A user decorator on a method or a class, a wrapper that uses *args other than to pass it on, @cached_property, @singledispatchmethod, and a decorator name the program never defines are refused, and so are calls to functools.partial, reduce, and cmp_to_key. Write the wrapper's work inline, or use @property.

Tuples and lists compare by value, and a tuple works as a set member or a dict key. Comparing two with different element types ((1, 2) == (1.0, 2), True in CPython) or with element types the compiler cannot see is refused rather than read at the wrong width, and so are equality between dicts and a list, dict, or set used as a set member or dict key (unhashable in CPython). Annotate the collections (List[Tuple[int, int]]) so both sides are known.

Every slot in a collection is read at one width, so a literal mixing types no one type holds ([1, "a"], [1, True]) is refused; use a class or a tuple for a record. An int written into a float collection is widened for you (xs.append(3) on a List[float]). The other direction is refused, because storing 2.5 where the slot is read as an integer would truncate it. Make the elements one type.

def total(cart): return cart.count has no type for cart, so the read is refused with a hint rather than answering 0. Annotate the parameter (cart: Cart). The rich comparison methods are the exception: an unannotated other in __eq__, __lt__, and the rest is typed as the class.

An unannotated parameter or return, and the elements of a bare list, set, or dict parameter or return, hold one word read back as an int. Ints, bools, None, and functions pass through; anything else is refused, since a string would lose its length and a float its width. Annotate the parameter, or write List[str] and Dict[str, int]. A bare annotation on a variable is fine: its elements take the type of the value assigned.

None is the word 0, which an untyped value can also be, so the test cannot be answered there. An Optional[int], Optional[bool], or Optional[float] is boxed, so is None, ==, and truthiness on one give CPython's answer; arithmetic between two optional numbers is refused. dict.get(key) with no default is refused where the values are ints, floats, or strings, which have no distinct word for the None a missing key answers; pass a default.

The whole format specification mini-language works in f-strings, format(), .format(), and %, digit for digit with CPython. .format() and % need a literal format string, and a * width or precision in %, or a precision on %d, %x, or %o, is refused. A spec CPython rejects is a compile error carrying CPython's message when it is a literal, and traps when it is built at run time.

Powers are computed by repeated multiplication. 2.0 ** 0.5 traps, because it needs exp/log this runtime does not carry, and a negative integer exponent traps because Python's answer is a float an int cannot hold. float() and int() of a string with non-ASCII digits or spaces trap too, where CPython would accept them.

Merged modules share one namespace, so utils.format next to report.format is a compile error naming both files. Rename one.

The allocator has no free: every instance lives until the module is torn down, and __del__ is never invoked. A long-running program that allocates in a loop will grow its memory, and a generator abandoned mid-iteration does not run its finally blocks until close() is called.

With x = float("nan"), (x,) == (x,) and [x] == [x] are False here, where CPython answers True: floats are unboxed values, so there is no object identity for CPython's same-object shortcut to find. x == x is False in both.

No traceback is kept. An exception a __main__ block does not catch writes only the last line of CPython's report (ValueError: boom) to standard error and exits with status 1.

No PyPI. Standard-library support is small so far: the module constants (math.pi, os.sep, ...), sys.stdin, sys.stdout, sys.stderr, sys.argv, and sys.exit(), re.sub and re.escape on constant arguments, and the functools decorators. Every other function in sys, os, os.path, math, random, json, re, datetime, logging, collections, itertools, and functools is refused at compile time, and each is tracked on the modules board.