Skip to content

Python's built-in functions in d/Python

Generated on 2026-09-14 from builtins.json

Python comes with 69 built-in functions and types, such as print, len, int and sorted. This table says, for every one of them, how much d/Python supports today and what is still missing. The rule it follows:

A partial row is not complete. Syntax, compile acceptance, named type checks and related D/OS APIs do not establish builtin behavior. Each row remains visible until fully implemented.

46 are supported in part, 23 are not yet supported, and 0 are marked complete. "In part" is the honest word even for print: it does what the Works today column says, and the Not yet column names the rest. Each name links to the official Python 3.9 documentation.

Builtin Status Feature Works today Not yet
__import__ not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
abs in part semantics.int Integer/boolean, float and complex absolute value; ordinary inherited abs preserves supported result identity and raised exceptions. Numeric slot descriptors and conversion deprecation warnings have focused executing coverage. Full numeric subclass operators/descriptors and broader dynamic class slots remain separate work; supported runtime-varying numeric conversion, truth and length results execute with exact warnings/errors. General custom binary/reflected operators and generic buffers remain outside the primitive numeric adapters. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
all in part builtins.boolean_reductions Short-circuit supported iterables and truth protocols. Ordinary class iterator inputs use the shared consumer adapters. Remaining iterator protocols and complete invalid-argument translation
any in part builtins.boolean_reductions Short-circuit supported iterables and truth protocols. Ordinary class iterator inputs use the shared consumer adapters. Remaining iterator protocols and complete invalid-argument translation
ascii in part semantics.str Supported scalar, container, exception and user repr results; non-ASCII Unicode scalar escaping, unchanged ASCII bytes, builtin aliases and f-string !a conversion with supported evaluated format specifications; Python float representation through the separately admitted shared formatter Existing repr gaps, including address-bearing object/function/method representations; surrogates remain pending. Format specifications retain the explicit builtins.format boundaries. DBC string capacity limits expansion.
bin in part builtins.integer_formatting bin(), oct() and hex() over arbitrary signed integers and booleans, preserving standard prefixes, lowercase digits and signs; first-class builtin aliases, fixed call unpacking and round trips through int(text, base). Ordinary class index methods use inherited class-slot lookup, ignore instance-only special attributes, convert once and preserve raised exception identity. Supported non-integer returns and missing/noncallable slots produce catchable TypeError. This row covers bin(), oct(), hex() and chr(); int(), float() and round() have separate numeric-protocol coverage. Runtime tagged integer/boolean values work; invalid primitive arguments and fixed argument binding errors preserve evaluated argument effects and raise catchable TypeError. Bool-returning index warnings and supported numeric slot descriptors have executing coverage. Broader dynamic class changes and unsupported result representations remain separate work. General dynamic call merging and broader reflection remain separate adapters. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
bool in part builtins.boolean_reductions Empty constructor and supported value truth protocols; captured builtin aliases, filter(bool, ...) and selected builtin type observations preserve identity after name shadowing Complete argument-error translation and unsupported value adapters
breakpoint not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
bytearray not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
bytes in part semantics.str Empty constructor; bytes literals are a separate syntax feature Encoding, integer-size, iterable and general buffer constructors
callable in part semantics.functions Known functions, bound user methods, named classes and ordinary supported values; first-class user/object class values; user instances test the presence of a class-level call slot, including non-callable slot values as CPython does, while instance-only fields do not make an object callable. Builtin exception class values support class identity observations. Dynamic type/descriptor changes and other first-class builtin type values remain pending.
chr in part semantics.str chr() constructs one Unicode scalar from an integer or boolean, evaluates its argument once, preserves captured aliases and fixed argument expansion, and raises catchable wrong-type, signed C-int overflow and Unicode-range errors with builtin exception identity despite name shadowing. Ordinary class index methods use inherited class-slot lookup, ignore instance-only special attributes, convert once and preserve raised exception identity. Supported non-integer returns and missing/noncallable slots produce catchable TypeError. This row covers bin(), oct(), hex() and chr(); int(), float() and round() have separate numeric-protocol coverage. Runtime-varying Int/Bool/Float/Complex index results use actual executed type checks; Bool results emit the pinned deprecation warning through the shared numeric slot binder. Surrogate code points U+D800..U+DFFF explicitly raise NotImplementedError because the current string representation cannot preserve them; CPython accepts them, so this refusal is not conformance. Remaining dynamic class changes, unsupported return representations, broader wrong-type names and catchable argument-shape errors remain pending. C-int overflow behavior remains pinned to the macOS CPython oracle, including overflow before the Unicode range check after index conversion.
classmethod not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
compile not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
complex in part semantics.complex Complex numeric/text construction with fixed positional/keyword binding, complex then real conversion fallback; exact stored binary64 real/imaginary parts, conjugate, unary/binary arithmetic, division, absolute value and powers through shared MATH profiles. Runtime Number joins retain the Int/Float/Bool/Complex kind and existing boxed identity. Python complex strings, default representation and explicit numeric formatting execute. Supported single-inheritance numeric subclasses retain object identity, user fields, builtin ancestry, default base construction before user initialization, conversion overrides, strict-result warnings and inherited payload fallbacks. Custom unary neg, pos and invert use the class-slot binder once, preserve supported returned values and use builtin numeric-subclass payload fallback only when the override is absent. Numeric slot descriptors and conversion deprecation warnings have focused executing coverage. Full numeric subclass operators/descriptors and broader dynamic class slots remain separate work; supported runtime-varying numeric conversion, truth and length results execute with exact warnings/errors. General custom binary/reflected operators and generic buffers remain outside the primitive numeric adapters. Portable complex power records six large-phase zero-sign differences from the pinned macOS libm; tests do not establish universal bit identity. Complex order, floor/mod and modular pow raise their Python errors. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
delattr not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
dict in part semantics.mappings Typed pair/keyword/known mapping construction. Ordinary class iterator inputs use the shared consumer adapters. Remaining iterator protocols and dynamic key/value representations
dir not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
divmod in part semantics.int Two positional integer/boolean operands; an integer quotient/remainder tuple, single left-to-right argument evaluation, catchable zero division, captured callable aliases and fixed argument unpacking Float/mixed arithmetic and custom divmod/rdivmod numeric protocols
enumerate in part semantics.iterators Lazy supported-source iteration, positional/keyword start and arbitrary integer counters. Ordinary class iterator sources use the same lazy enumerate adapter. Sequence fallback, callable/sentinel iteration, callable-valued class-slot descriptors, unsupported source adapters, tagged result/default shapes and full reflection remain pending; see the iterator semantic ledger.
eval not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
exec not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
filter in part builtins.filter Lazy filter over existing supported iterator sources, retaining original source and predicate arguments evaluated once in order. None and supported function/closure/bound-method/callable-object/bool predicates use existing truth protocols; original items and identities are yielded. Predicate and truth errors consume that item but permit continuation. Direct next preserves the original StopIteration instance and arguments; iteration consumers and next(default) stop that iteration without closing filter. Nested wrappers retain CPython repeated exhausted zip effects. Source iterator creation is eager. Shared cursor identity, defining-module callbacks, reentrant predicates, object retention/cleanup and selected filter builtin type observations are covered by the existing executed tests. Ordinary class iterator sources preserve eager iterator acquisition and lazy predicate execution. Remaining class-slot and length-hint protocols, mapping/view/set sources, mixed iterator item carriers, dynamic predicate rebinding, broad dynamic argument unpacking, full catchable argument-binding errors, general filter type reflection/subclassing/repr/reduce and unsupported predicate/result type-name adapters remain explicit gaps. Unknown-empty list inference keeps existing diagnostics. Terminal D/OS refusals end the run.
float in part semantics.float Binary64 literals and Python numeric construction from booleans, arbitrary integers, existing floats, Unicode decimal text and bytes, with inherited float then absent-only index. Text parsing covers whitespace, underscores, special values and complete-input validation. Shared IEEE + - * / // % and divmod preserve numeric result kinds, signed zero, subnormals, nonfinite results and Python errors. Integer/float comparisons retain exact integer information. Float int/round conversion uses exact decimal ties and Python nonfinite errors. abs, real/imag, conjugate, hex, is_integer and exact as_integer_ratio execute. Shared shortest-round-trip output and format mini-language preserve tested Python spellings. Direct and captured float.fromhex parse the pinned ASCII hexadecimal grammar through a bounded scanner and exact shared ratio rounding, including signed NaN/zero bits and documented CPython 3.9.6 quirks. Captured numeric methods and conditional builtin numeric type identities preserve supported owners and argument effects. Supported single-inheritance numeric subclasses retain object identity, user fields, builtin ancestry, default base construction before user initialization, conversion overrides, strict-result warnings and inherited payload fallbacks. Custom unary neg, pos and invert use the class-slot binder once, preserve supported returned values and use builtin numeric-subclass payload fallback only when the override is absent. Numeric slot descriptors and conversion deprecation warnings have focused executing coverage. Full numeric subclass operators/descriptors and broader dynamic class slots remain separate work; supported runtime-varying numeric conversion, truth and length results execute with exact warnings/errors. General custom binary/reflected operators and generic buffers remain outside the primitive numeric adapters. Remaining numeric descriptor reflection, tuple-key NaN identity and raw scalar allocation identity have their own representation boundaries. Existing BASIC/QB arithmetic and formatting retain their contracts. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
format in part builtins.formatting format() and specified f-strings over Int/Bool/Float/Str/Complex and runtime Number; sign, alignment, fill, width, precision, grouping, alternate form and Unicode decimal width/precision. Value/spec/conversion order, saved format aliases, fixed argument expansion, ordinary inherited format, numeric error translation, shared capacity refusal and cleanup execute. Ordinary f-strings without a specification keep the previous exact artifacts. Locale-dependent n requires a locale contract. Supported numeric slot descriptors have executing coverage; full numeric subclass operators/descriptors and general dynamic binding remain separate work. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
frozenset in part semantics.sets Supported homogeneous iterable conversion. Ordinary class iterator inputs use the shared consumer adapters. Remaining iterator/length-hint/hash protocols and arbitrary dynamic elements
getattr not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
globals not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
hasattr not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
hash not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
help not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
hex in part builtins.integer_formatting bin(), oct() and hex() over arbitrary signed integers and booleans, preserving standard prefixes, lowercase digits and signs; first-class builtin aliases, fixed call unpacking and round trips through int(text, base). Ordinary class index methods use inherited class-slot lookup, ignore instance-only special attributes, convert once and preserve raised exception identity. Supported non-integer returns and missing/noncallable slots produce catchable TypeError. This row covers bin(), oct(), hex() and chr(); int(), float() and round() have separate numeric-protocol coverage. Runtime tagged integer/boolean values work; invalid primitive arguments and fixed argument binding errors preserve evaluated argument effects and raise catchable TypeError. Bool-returning index warnings and supported numeric slot descriptors have executing coverage. Broader dynamic class changes and unsupported result representations remain separate work. General dynamic call merging and broader reflection remain separate adapters. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
id not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
input in part builtins.input Console input() uses shared CONSOLE.READ_LINE_RESULT, minimum service 1.0.1.22, with the same macOS endpoint as d/BASIC. Zero or one positional prompt, existing str protocols, eager argument evaluation, exact LF removal, empty lines, CR/NUL/valid Unicode and final unterminated lines execute. Only canonical EOF raises builtin EOFError. Host/storage/version/capability refusals retain all original fields. Pending input and deferred allocation preserve one read and publish the result pair together. GUI input producer/cancellation, configured or replaced streams, readline/history/auditing, surrogate strings, broader argument/descriptor protocols and full Python output I/O exception fidelity remain deferred. Undecodable UTF-8 raises an explicit NotImplementedError for the missing surrogateescape representation. The shared 65,535-byte string ceiling refuses larger lines instead of matching CPython unbounded input.
int in part semantics.int arbitrary-precision + - * compare // % **; catchable zero division; int() construction from integers/booleans/text/bytes with bases 0 and 2..36, Unicode decimal digits, Python whitespace/sign/prefix/underscore rules, arbitrary precision accumulation and catchable ValueError; bool/int comparisons preserve Python numeric equality and ordering; bool/int arithmetic, boolean abs and integer/boolean inversion; arbitrary-integer &, | and ^ preserve infinite sign extension; two boolean operands produce bool and mixed bool/int operands produce int; augmented assignment preserves the existing fixed variable representation; << and >> with arbitrary integer counts, catchable negative-count ValueError, zero-left-shift and huge-right-shift shortcuts, and the pinned macOS ssize_t OverflowError for excessive nonzero left shifts; divmod() over integers and booleans returns a quotient/remainder tuple through existing shared arithmetic and tuple ownership, preserving argument evaluation and catchable zero division; ordinary inherited int then index construction, captured int aliases and fixed argument expansions, plus custom abs returning its supported original value; integer true division rounds an exact ratio once without independently narrowing huge operands to float; mixed Int/Bool/Float arithmetic and exact comparisons; int(float) truncation with nonfinite errors; ordinary inherited base index and absent-only trunc fallback; negative nonmodular powers return float; bit_length and as_integer_ratio methods; integer/boolean to_bytes and direct or captured from_bytes preserve required Python 3.9 arguments, signed/endian conversion, bytes, supported iterator consumption and shared capacity refusal; captured classmethods retain the actual Int/Bool owner through runtime type tokens, closures and rebinding. Supported single-inheritance numeric subclasses retain object identity, user fields, builtin ancestry, default base construction before user initialization, conversion overrides, strict-result warnings and inherited payload fallbacks. Int/Bool/Number numerator and denominator instance properties retain exact integer values, actual missing-attribute errors and known boxed Int numerator identity. Custom unary neg, pos and invert use the class-slot binder once, preserve supported returned values and use builtin numeric-subclass payload fallback only when the override is absent. Numeric slot descriptors and conversion deprecation warnings have focused executing coverage. Full numeric subclass operators/descriptors and broader dynamic class slots remain separate work; supported runtime-varying numeric conversion, truth and length results execute with exact warnings/errors. General custom binary/reflected operators and generic buffers remain outside the primitive numeric adapters. Custom reflected shift/bitwise operators remain separate work; CPython does not implicitly invoke an arbitrary operand's index for binary shifts. Unicode decimal input uses the pinned Unicode 13 table. macOS excessive-left-shift errors need separate target qualification. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
isinstance in part builtins.type_checks Known user/builtin classes and nested alternatives; first-class user/object classes, module attributes and class values in tuples. Builtin exception class values support class identity observations and isinstance(value, type). Other first-class builtin types, exception hierarchy and metaclass hooks
issubclass in part builtins.type_checks Known user/builtin classes and nested alternatives; first-class user/object classes, module attributes and class values in tuples Other first-class builtin types, exception hierarchy and metaclass hooks
iter in part semantics.iterators Lazy source iterators for homogeneous lists/tuples, text, bytes and ranges; existing iterators preserve identity. Ordinary user-class iter uses inherited class-slot lookup and returns the original valid class/builtin iterator object. Sequence fallback, callable/sentinel iteration, callable-valued class-slot descriptors, unsupported source adapters, tagged result/default shapes and full reflection remain pending; see the iterator semantic ledger.
len in part semantics.classes Supported containers/text/ranges and user len with result validation Generic buffer/value adapters and complete type errors
list in part semantics.collections Supported iterable construction preserving references. Ordinary class iterator inputs use the shared consumer adapters. Remaining iterator/length-hint protocols and dynamically mixed element representations
locals not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
map in part builtins.map Lazy map over supported sources, with all argument expressions evaluated once before eager ordered iterator acquisition. Each request advances sources left to right and applies the retained callback only after every source provides an item. The shortest source stops that request; earlier inputs retain partial advancement and are probed on subsequent attempts. Functions, closures, supported builtin callbacks, bound methods, inherited callable objects and class constructors use existing typed calls. Original source/callback Python exception identity and continuation, defining-module globals, mutable sources, object results, selected builtin/type observations and shared ownership are covered by the executing focused suite. Repeated direct lists with the same concrete element carrier share iterator owner layouts while retaining independent cursors and list aliases. Callback results must have a concrete representation inferred at construction; recursive map-self references, mixed or dynamically changing carriers and unsupported callback binding remain diagnosed. Mapping/view/set sources, remaining class-slot/descriptor/sequence/length-hint/async protocols, dynamic unpacking, tagged next defaults, general reflection/repr/reduce/subclassing and direct dos.array callback/result ownership remain deferred. Existing shared memory, string, frame and consumer limits apply; no timing or full map-conformance claim.
max in part builtins.numeric_reductions sum() over supported iterables with positional/keyword start, non-mutating list addition, catchable forbidden text/bytes starts; min/max with multiple arguments or a supported homogeneous iterable, compatible default, key=None or supported function, closure, bound-method or user-object callbacks, once-per-item keys, first-wins ties, catchable empty ValueError and arithmetic extrema of huge ranges; supported tuple keys retain lexicographic ordering. sum/min/max consume supported ordinary class iterators using the existing typed reduction adapters. Mixed numeric list literals, positional min/max values and sum over numeric iterables use a tagged numeric result when necessary; float sums no longer need an explicit float start. Mixed numeric tuple iteration/dynamic indexing, iterator next defaults and min/max defaults preserve numeric kind and existing boxed identity; range extrema retain arithmetic endpoint selection with differently typed numeric defaults. Mixed nonnumeric result carriers require further adapters. General custom arithmetic/comparison protocols, changing callable types, unsupported container shapes, dictionary-item ordering and full invalid-call translation remain pending. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
memoryview not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
min in part builtins.numeric_reductions sum() over supported iterables with positional/keyword start, non-mutating list addition, catchable forbidden text/bytes starts; min/max with multiple arguments or a supported homogeneous iterable, compatible default, key=None or supported function, closure, bound-method or user-object callbacks, once-per-item keys, first-wins ties, catchable empty ValueError and arithmetic extrema of huge ranges; supported tuple keys retain lexicographic ordering. sum/min/max consume supported ordinary class iterators using the existing typed reduction adapters. Mixed numeric list literals, positional min/max values and sum over numeric iterables use a tagged numeric result when necessary; float sums no longer need an explicit float start. Mixed numeric tuple iteration/dynamic indexing, iterator next defaults and min/max defaults preserve numeric kind and existing boxed identity; range extrema retain arithmetic endpoint selection with differently typed numeric defaults. Mixed nonnumeric result carriers require further adapters. General custom arithmetic/comparison protocols, changing callable types, unsupported container shapes, dictionary-item ordering and full invalid-call translation remain pending. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
next in part semantics.iterators Supported iterators with StopIteration and an optional compatible default. Ordinary user-class next supports direct exception identity, repeated probing and compatible defaults; direct next does not call iter. Sequence fallback, callable/sentinel iteration, callable-valued class-slot descriptors, unsupported source adapters, tagged result/default shapes and full reflection remain pending; see the iterator semantic ledger.
object in part semantics.classes Root object construction and class checks; first-class root class aliases, callable construction and name/module metadata Full default object protocols, attributes and representation
oct in part builtins.integer_formatting bin(), oct() and hex() over arbitrary signed integers and booleans, preserving standard prefixes, lowercase digits and signs; first-class builtin aliases, fixed call unpacking and round trips through int(text, base). Ordinary class index methods use inherited class-slot lookup, ignore instance-only special attributes, convert once and preserve raised exception identity. Supported non-integer returns and missing/noncallable slots produce catchable TypeError. This row covers bin(), oct(), hex() and chr(); int(), float() and round() have separate numeric-protocol coverage. Runtime tagged integer/boolean values work; invalid primitive arguments and fixed argument binding errors preserve evaluated argument effects and raise catchable TypeError. Bool-returning index warnings and supported numeric slot descriptors have executing coverage. Broader dynamic class changes and unsupported result representations remain separate work. General dynamic call merging and broader reflection remain separate adapters. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
open not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
ord in part semantics.str One Unicode scalar or single-byte bytes value, arbitrary Python integer result, once-only argument evaluation, catchable exact wrong-length and supported wrong-type TypeErrors, captured aliases and fixed argument expansion Bytearray and broader buffer adapters, surrogate representations, callable/exception type-name adapters and catchable argument-shape errors remain pending. Wrong-length Unicode inputs are counted through bounded shared bytecode chunks; string copying and the existing carrier limits still apply.
pow in part builtins.pow Two-argument and explicit-None-modulus integer/boolean, float and complex powers, including negative integer exponents and real powers with complex results. Three-argument exact integer modular powers use square-and-multiply; negative modular exponents use extended Euclid and preserve signed modulus and noninvertible/zero errors. Fixed arguments/keywords, captured aliases and callbacks retain evaluation order. Type errors for tagged Float/Complex modular inputs, finally/cleanup, and power OverflowError string/repr are qualified. General custom/reflected power protocols, numeric subclasses, dynamic call merging and full exception.args remain separate adapters. Portable complex powers retain the documented large-phase zero-sign differences. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
print in part builtins.print Supported representations, spacing/newlines and literal or computed string/None sep/end, with once-only evaluation and catchable wrong-type option errors; Python float representation through the separately admitted shared formatter file/flush options and remaining representation protocols
property not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
range in part semantics.ranges Arbitrary integer bounds, dynamic steps and Python 3.9 boolean attributes Custom index protocols, argument errors and mixed attribute-type rebinding
repr in part semantics.str Supported scalars/collections, exceptions and user repr; Python float representation through the separately admitted shared formatter Default address-bearing object/function/method representations and remaining protocols
reversed in part semantics.iterators Lazy reversal of lists, homogeneous tuples, Unicode strings, bytes and arbitrary ranges; live list changes, latched exhaustion, source and element identity, returned/captured iterators, direct iterator methods and supported builtin type observations Custom reversed/sequence protocols, mapping reversal, mixed tuples, range iterator type-name width selection, general reflection and catchable argument-shape errors remain pending. Repeatable untyped-empty-list inference remains conservative; linked-list lookup and shared string copies retain their existing costs.
round in part builtins.round Integer/boolean rounding with exact decimal ties-to-even and arbitrary integer precision, omission/None normalization, safe huge-precision shortcuts before counter narrowing or power construction, and ordinary index precision conversion. Ordinary inherited round preserves arbitrary supported result identity; omission/None calls without precision and other precision objects pass unchanged. Fixed argument expansion, keywords, saved aliases, closures, effects, original exception identity, finally and successful/failed ownership cleanup execute. Float rounding with omission/None returns exact integer ties-to-even; explicit index precision returns correctly rounded floats with signed zero. Nonfinite and extreme precision behavior is translated through shared numeric statuses. Numeric slot descriptors and conversion deprecation warnings have focused executing coverage. Full numeric subclass operators/descriptors and broader dynamic class slots remain separate work; supported runtime-varying numeric conversion, truth and length results execute with exact warnings/errors. General custom binary/reflected operators and generic buffers remain outside the primitive numeric adapters. Huge-negative integer precision expectations use independent mathematics to avoid enormous CPython allocations. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
set in part semantics.sets Supported homogeneous iterable conversion. Ordinary class iterator inputs use the shared consumer adapters. Remaining iterator/length-hint/hash protocols and arbitrary dynamic elements
setattr not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
slice not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
sorted in part builtins.sorting Stable sorted() over supported homogeneous iterable snapshots, scalar or tuple keys, key=None or supported callables including closures, bound methods and user callable objects, once-per-item keys in input order, reverse stability and checked signed-32-bit integer reverse conversion. Preserves original inputs and item identities, consumes sources before keys, propagates key exceptions, and exposes a saved sorted builtin alias. Static Int/Bool/Str and tuple keys retain linked bottom-up merge passes with native bounded counters and ordinary billed DBC instructions. Fixed tuple/literal argument unpacking is supported. In-place list.sort() reuses this stable sorting engine, preserves shared list identity, returns None, captures the receiver before keyword effects, evaluates keys once in original order while aliases see the temporarily empty list, restores original order on Python key exceptions, restores sorted order before reporting ValueError for mutation, and preserves outer mutation state across nested sorts. Mutation includes growth followed by removal and CPython generic-empty extension behavior; exact empty list/tuple extension remains a no-op. sorted consumes supported ordinary class iterators before evaluating keys. Finite Int/Float/Bool/Number and numeric tuple keys use exact shared comparisons. Complex equal tuple prefixes proceed until an actual order is required; sort restoration and once-per-item key evaluation remain intact. Flat Float/Number keys, including NaNs, use the pinned CPython 3.9.6 Timsort order over cached keys and retained item identities. Comparison failures restore the exact tested partial permutation before rethrowing the original exception. Compiler-only lexical source identity separates generated comparator closures from user closures. Tuple NaN keys (including complex components) retain an explicit NotImplementedError because Python tuple ordering also observes scalar identity. Flat numeric Timsort is qualified for the bounded cases and costs recorded in its receipt. Nonnumeric mixed containers, custom partial orders, dynamically changing callables, remaining iterator/length-hint protocols, saved list.sort descriptors, unsupported argument expansion and reverse index remain separate adapters. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
staticmethod not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
str in part semantics.str Empty constructor and supported scalar/container/exception/object formatting; Python float representation through the separately admitted shared formatter Captured aliases/fixed argument expansion and map callbacks retain builtin str identity, including supported isinstance/issubclass checks. Decoding, numeric subclasses and remaining object representations
sum in part builtins.numeric_reductions sum() over supported iterables with positional/keyword start, non-mutating list addition, catchable forbidden text/bytes starts; min/max with multiple arguments or a supported homogeneous iterable, compatible default, key=None or supported function, closure, bound-method or user-object callbacks, once-per-item keys, first-wins ties, catchable empty ValueError and arithmetic extrema of huge ranges; supported tuple keys retain lexicographic ordering. sum/min/max consume supported ordinary class iterators using the existing typed reduction adapters. Mixed numeric list literals, positional min/max values and sum over numeric iterables use a tagged numeric result when necessary; float sums no longer need an explicit float start. Mixed numeric tuple iteration/dynamic indexing, iterator next defaults and min/max defaults preserve numeric kind and existing boxed identity; range extrema retain arithmetic endpoint selection with differently typed numeric defaults. Mixed nonnumeric result carriers require further adapters. General custom arithmetic/comparison protocols, changing callable types, unsupported container shapes, dictionary-item ordering and full invalid-call translation remain pending. Shared string, memory, frame and execution limits apply to inputs and intermediate results; no floor/cart or hard deadline qualification is claimed.
super in part semantics.classes Zero-argument method-context dispatch, including saved parent methods Explicit arguments, first-class super objects and general descriptor lookup
tuple in part semantics.collections Empty and identity-preserving tuple constructor; tuple literals are separate General iterable construction and dynamically mixed lengths/shapes
type in part builtins.type_checks Type-name observations for exceptions, functions, bound methods, supported iterators, modules, user instances and first-class user/object class values. Builtin exception class values support class identity observations. Standalone type() results, other first-class builtin types, general reflection and three-argument construction
vars not yet builtins.remaining This builtin is not implemented; related syntax or D/OS APIs do not count as its Python semantics.
zip in part semantics.iterators Lazy supported-source iteration, shortest termination, shared cursors and repeated exhausted probes in Python 3.9. Ordinary class iterator sources preserve ordered acquisition and step consumption. Sequence fallback, callable/sentinel iteration, callable-valued class-slot descriptors, unsupported source adapters, tagged result/default shapes and full reflection remain pending; see the iterator semantic ledger.