Index

Modules: pylib, pylib/Lib/collections/abc, pylib/Lib/errno, pylib/Lib/errno_impl/errnoConsts, pylib/Lib/errno_impl/errnoUtils, pylib/Lib/errno_impl/private/clike, pylib/Lib/errno_impl/private/errnos, pylib/Lib/errno_impl/private/errorcodeInit, pylib/Lib/errno_impl/private/exportUtils, pylib/Lib/errno_impl/private/loopErrno, pylib/Lib/errno_impl/private/singleton_errno, pylib/Lib/io, pylib/Lib/math, pylib/Lib/math_impl/cbrt, pylib/Lib/math_impl/comptime/cbrt, pylib/Lib/math_impl/comptime/common, pylib/Lib/math_impl/comptime/expm1, pylib/Lib/math_impl/comptime/log1p, pylib/Lib/math_impl/constsUtils, pylib/Lib/math_impl/err, pylib/Lib/math_impl/errnoUtils, pylib/Lib/math_impl/expm1_log1p, pylib/Lib/math_impl/frexp, pylib/Lib/math_impl/gammaXRange, pylib/Lib/math_impl/inWordUtils/assertIsLittleEndian, pylib/Lib/math_impl/inWordUtils/consts, pylib/Lib/math_impl/inWordUtils/float_view, pylib/Lib/math_impl/inWordUtils/fromWords, pylib/Lib/math_impl/inWordUtils/indices, pylib/Lib/math_impl/inWordUtils/toWords, pylib/Lib/math_impl/isX, pylib/Lib/math_impl/ldexp, pylib/Lib/math_impl/nextafter_step, pylib/Lib/math_impl/nextafter_ulp, pylib/Lib/math_impl/patch/consts, pylib/Lib/math_impl/patch/fma, pylib/Lib/math_impl/patch/gamma, pylib/Lib/math_impl/patch/inWordUtilsMapper, pylib/Lib/math_impl/patch/ldexp_frexp/assertIsInfinite, pylib/Lib/math_impl/patch/ldexp_frexp/exponent, pylib/Lib/math_impl/patch/ldexp_frexp/frexp, pylib/Lib/math_impl/patch/ldexp_frexp/ldexp, pylib/Lib/math_impl/patch/ldexp_frexp/normalize, pylib/Lib/math_impl/patch/lgamma, pylib/Lib/math_impl/patch/nextafter, pylib/Lib/math_impl/patch/nextafter_step, pylib/Lib/math_impl/patch/sinpi, pylib/Lib/math_impl/patch/trunc, pylib/Lib/math_impl/platformUtils, pylib/Lib/math_impl/polevl, pylib/Lib/math_impl/vec_op, pylib/Lib/math_impl/vec_op/dist, pylib/Lib/math_impl/vec_op/niter_types, pylib/Lib/math_impl/vec_op/private/dl_ops, pylib/Lib/math_impl/vec_op/sumprod, pylib/Lib/n_errno, pylib/Lib/n_math, pylib/Lib/n_time, pylib/Lib/n_timeit, pylib/Lib/ncodec, pylib/Lib/os_impl/common, pylib/Lib/os_impl/consts, pylib/Lib/os_impl/posix_like/isatty, pylib/Lib/os_impl/posix_like/open_close, pylib/Lib/os_impl/posix_like/truncate, pylib/Lib/private/platformInfo, pylib/Lib/private/platformUtils, pylib/Lib/sys, pylib/Lib/time, pylib/Lib/time_impl/asctimeImpl, pylib/Lib/time_impl/converters, pylib/Lib/time_impl/measures, pylib/Lib/time_impl/nstrfptime, pylib/Lib/time_impl/private/doc_utils, pylib/Lib/time_impl/private/macro_utils, pylib/Lib/time_impl/sleep_impl, pylib/Lib/time_impl/strfptime, pylib/Lib/time_impl/struct_time_funcs, pylib/Lib/time_impl/types, pylib/Lib/timeit, pylib/Lib/warnings, pylib/Python/envutils, pylib/Python/fileutils, pylib/Python/force_ascii_utils, pylib/Python/internal/pycore_fileutils, pylib/Python/localeutils, pylib/Python/unicodeobject/char_decl, pylib/Python/unicodeobject/codecs, pylib/Python/unicodeobject/cstring_ptr_op, pylib/Python/unicodeobject/ptr_op, pylib/Python/unicodeobject/ptr_types, pylib/Python/unicodeobject/utf8_codec, pylib/Python/wchar_t, pylib/builtins, pylib/builtins/asciiImpl, pylib/builtins/attr, pylib/builtins/complex, pylib/builtins/dict, pylib/builtins/dict_decl, pylib/builtins/input, pylib/builtins/iter_next, pylib/builtins/iters, pylib/builtins/list, pylib/builtins/list_decl, pylib/builtins/mathfunc, pylib/builtins/misc, pylib/builtins/modPow, pylib/builtins/oopFuncs, pylib/builtins/print, pylib/builtins/private/iterGen, pylib/builtins/private/mathutils, pylib/builtins/private/ncomplex_pow, pylib/builtins/private/pycore_pymath, pylib/builtins/private/strIter, pylib/builtins/pyhashes, pylib/builtins/pyrange, pylib/builtins/pyslice, pylib/builtins/reprImpl, pylib/builtins/set, pylib/builtins/set_decl, pylib/collections_abc, pylib/io, pylib/io_abc, pylib/mutSeqSliceOp, pylib/nimpatch/abs, pylib/nimpatch/floatdollar, pylib/nimpatch/utils, pylib/noneType, pylib/numTypes, pylib/numTypes/floats, pylib/numTypes/floats/floathex, pylib/numTypes/floats/init, pylib/numTypes/floats/parse_inf_nan, pylib/numTypes/floats/parsefloat, pylib/numTypes/ints, pylib/numTypes/ints/decl, pylib/numTypes/ints/getter, pylib/numTypes/ints/init, pylib/numTypes/ints/int_bytes, pylib/numTypes/ints/longint, pylib/numTypes/ints/nint_proto, pylib/numTypes/reimporter, pylib/numTypes/utils/stripOpenArray, pylib/ops, pylib/ops/chk_shl, pylib/private/backendMark, pylib/private/encoding_norm, pylib/private/inspect_cleandoc, pylib/private/trans_imp, pylib/pybool, pylib/pybytearray, pylib/pybytes, pylib/pybytes/bytesbltins, pylib/pybytes/bytesimpl, pylib/pybytes/bytesmeth, pylib/pybytes/bytesprefix, pylib/pybytes/hex, pylib/pybytes/split/common, pylib/pybytes/split/reimporter, pylib/pybytes/split/rsplit, pylib/pybytes/split/rsplit_whitespace, pylib/pybytes/split/split, pylib/pybytes/split/split_whitespace, pylib/pybytes/split/splitlinesIter, pylib/pybytes/strip, pylib/pybytes/translate, pylib/pyerrors, pylib/pyerrors/aritherr, pylib/pyerrors/lkuperr, pylib/pyerrors/oserr, pylib/pyerrors/rterr, pylib/pyerrors/simperr, pylib/pyerrors/unicode_err, pylib/pystring, pylib/pystring/consts, pylib/pystring/format, pylib/pystring/fstring, pylib/pystring/split/common, pylib/pystring/split/reimporter, pylib/pystring/split/rsplit, pylib/pystring/split/rsplit_whitespace, pylib/pystring/split/split, pylib/pystring/split/split_whitespace, pylib/pystring/split/splitlinesIter, pylib/pystring/strbltins, pylib/pystring/strimpl, pylib/pystring/strip, pylib/pystring/strmeth, pylib/pystring/strops, pylib/pystring/strprefix, pylib/pystring/translate, pylib/pysugar, pylib/pysugar/class, pylib/pysugar/parserWithCfg, pylib/pysugar/pydef, pylib/pysugar/pywith, pylib/pysugar/stmt/class, pylib/pysugar/stmt/decorator, pylib/pysugar/stmt/exprRewrite, pylib/pysugar/stmt/frame, pylib/pysugar/stmt/funcSignature, pylib/pysugar/stmt/pydef, pylib/pysugar/stmt/pyraise, pylib/pysugar/stmt/tonim, pylib/pysugar/stmt/types, pylib/pysugar/stmt/unpack, pylib/pysugar/tonim, pylib/pysugar/unpack, pylib/stringlib/errHandle, pylib/stringlib/format, pylib/stringlib/formats, pylib/stringlib/meth, pylib/stringlib/replaceWithCount, pylib/stringlib/split/common, pylib/stringlib/split/reimporter, pylib/stringlib/split/rsplit_whitespace, pylib/stringlib/split/split_whitespace, pylib/stringlib/split/splitlinesIter, pylib/translateEscape, pylib/version, pylib/versionInfo.

API symbols

`$`:

• complex: proc `$`(z: PyTComplex): string
• dict: template `$`(self: PyDict): string
• dict: template `$`(view`gensym3: PyDictItemView): string
• dict: template `$`(view`gensym1: PyDictKeyView): string
• dict: template `$`(view`gensym2: PyDictValueView): string
• list: template `$`[T](ls: PyList[T]): string
• pyrange: proc `$`[T](rng: PyRange[T]): string
• set_decl: template `$`(self: SomePySet): string
• io_abc: proc `$`(p: CanIOOpenT): string
• io_abc: proc `$`(p: PathLike): string
• errnos: proc `$`(e: Errno): string
• floatdollar: proc `$`(x: SomeFloat): string
• pybool: proc `$`(self: PyBool): string
• pybytearray: proc `$`(self: PyByteArray): string
• bytesimpl: proc `$`(self: PyBytes): string
• strimpl: proc `$`(self: PyStr): string
• translate: template `$`(table: TranslateTable): string

`%=`:

• ops: template `%=`(self: var SomeNumber; x: SomeNumber)

`%`:

• ops: proc `%`[T: SomeNumber](a, b: T): T
• ops: template `%`[A: SomeFloat; B: SomeInteger](a: A; b: B): A
• ops: template `%`[A: SomeInteger; B: SomeFloat](a: A; b: B): B

`&=`:

• set: proc `&=`[H; S: SomeSet[H]](self: var SomePySet[H]; s: S)

`&`:

• set: template `&`[H; M: SomePySet[H]; S: SomePySet[H]](self: M; s: S): M | S

`'j`:

• complex: proc `'j`(s: static string): PyComplex

`**=`:

• complex: proc `**=`[T](self: var PyTComplex[T]; x: ComplexPowSecondParamType[T])
• ops: template `**=`(a: var SomeNumber; b: SomeNumber)

`**`:

• complex: template `**`[T](self: PyTComplex[T]; x: ComplexPowSecondParamType[T]): PyTComplex[T]
• complex: template `**`[T](self: PyTComplex[T]; x: int): PyTComplex[T]
• complex: template `**`[T](self: PyTComplex[T]; x: PyComplex): PyTComplex[T]
• ops: template `**`[A: SomeFloat; B: SomeInteger](a: A; b: B): A
• ops: template `**`[A: SomeInteger; B: SomeFloat](a: A; b: B): B
• ops: template `**`[T](a: T; b: Natural): T
• ops: template `**`[T: SomeInteger](a: T; b: static[int]): int | float
• ops: template `**`[T: SomeFloat](a, b: T): T

`*=`:

• complex: template `*=`(a, b: PyTComplex): untyped
• list: proc `*=`[T](self: var PyList[T]; n: int)
• pybytearray: proc `*=`(mself: PyByteArray; n: int)

`*`:

• complex: template `*`[I: SomeInteger; T](a: I; z: PyTComplex[T]): PyTComplex[T]
• complex: template `*`(a, b: PyTComplex): PyTComplex
• complex: template `*`[T: SomeFloat](z: PyTComplex[T]; a: T): PyTComplex[T]
• complex: template `*`[I: SomeInteger; T](z: PyTComplex[T]; a: I): PyTComplex[T]
• complex: template `*`[T: SomeFloat](a: T; z: PyTComplex[T]): PyTComplex[T]
• list: proc `*`[T](n: Natural; ls: PyList[T]): PyList[T]
• list: template `*`[T](ls: PyList[T]; n: Natural): PyList[T]
• bytesmeth: template `*`(i: int; a: PyBytes): PyBytes
• bytesmeth: template `*`(a: PyBytes; i: int): PyBytes
• strmeth: template `*`(i: int; a: StringLike): PyStr
• strmeth: template `*`(a: StringLike; i: int): PyStr

`+=`:

• complex: template `+=`(a, b: PyTComplex): untyped
• list: proc `+=`[T](self: var PyList[T]; ls: openArray[T])
• list: proc `+=`[T](self: var PyList[T]; ls: PyList[T])
• pybytearray: proc `+=`(mself: PyByteArray; other: BytesLike)
• bytesimpl: proc `+=`(mself; s: char)
• bytesimpl: proc `+=`(mself; s: PyBytes)
• bytesimpl: proc `+=`(mself; s: string)
• strimpl: proc `+=`(mself; s: char)
• strimpl: proc `+=`(mself; s: PyStr)
• strimpl: proc `+=`(mself; s: string)

`+`:

• complex: template `+`[I: SomeInteger; T](a: I; z: PyTComplex[T]): PyTComplex[T]
• complex: template `+`(a, b: PyTComplex): PyTComplex
• complex: template `+`[T: SomeFloat](z: PyTComplex[T]; a: T): PyTComplex[T]
• complex: template `+`[I: SomeInteger; T](z: PyTComplex[T]; a: I): PyTComplex[T]
• complex: template `+`[T: SomeFloat](a: T; z: PyTComplex[T]): PyTComplex[T]
• list: proc `+`[T](self: PyList[T]; x: openArray[T]): PyList[T]
• list: template `+`[T](self: var PyList[T]; x: PyList[T]): PyList[T]
• bytesimpl: proc `+`(self: PyBytes; o: char): PyBytes
• bytesimpl: proc `+`(self: PyBytes; o: PyBytes): PyBytes
• bytesimpl: proc `+`(self: PyBytes; o: string): PyBytes
• bytesimpl: proc `+`(o: char; self: PyBytes): PyBytes
• bytesimpl: proc `+`(o: string; self: PyBytes): PyBytes
• strimpl: proc `+`(self: PyStr; s: PyStr): PyStr
• strimpl: proc `+`(self: PyStr; s: StringLike): PyStr
• cstring_ptr_op: template `+`[I: IndexType](s: cstring; i: I): cstring
• ptr_op: template `+`[I: IndexType; T](s: ptr T; i: I): ptr T

`-=`:

• complex: template `-=`(a, b: PyTComplex): untyped
• set: proc `-=`[H; S: SomeSet[H]](self: var SomePySet[H]; s: S)

`-`:

• complex: template `-`[I: SomeInteger; T](a: I; z: PyTComplex[T]): PyTComplex[T]
• complex: template `-`(a, b: PyTComplex): PyTComplex
• complex: template `-`[T: SomeFloat](z: PyTComplex[T]; a: T): PyTComplex[T]
• complex: template `-`[I: SomeInteger; T](z: PyTComplex[T]; a: I): PyTComplex[T]
• complex: template `-`[T: SomeFloat](a: T; z: PyTComplex[T]): PyTComplex[T]
• set: proc `-`[H](self: PyFrozenSet[H]; o: SomePySet[H]): PyFrozenSet[H]
• set: proc `-`[H](self: PySet[H]; o: PyFrozenSet[H]): PyFrozenSet[H]
• set: proc `-`[H](self, o: PySet[H]): PySet[H]
• cstring_ptr_op: template `-`(a, b: cstring): ptrdiff_t
• ptr_op: template `-`[T](a, b: ptr T): ptrdiff_t

`//=`:

• ops: template `//=`[A, B: SomeFloat | SomeInteger](a: var A; b: B)

`//`:

• ops: proc `//`[A, B: SomeFloat | SomeInteger](a: A; b: B): SomeNumber

`/=`:

• complex: template `/=`(a, b: PyTComplex): untyped

`/`:

• complex: template `/`[I: SomeInteger; T](a: I; z: PyTComplex[T]): PyTComplex[T]
• complex: template `/`(a, b: PyTComplex): PyTComplex
• complex: template `/`[T: SomeFloat](z: PyTComplex[T]; a: T): PyTComplex[T]
• complex: template `/`[I: SomeInteger; T](z: PyTComplex[T]; a: I): PyTComplex[T]
• complex: template `/`[T: SomeFloat](a: T; z: PyTComplex[T]): PyTComplex[T]
• ops: template `/`(x: SomeInteger; y: SomeInteger): float

`:=`:

• pysugar: template `:=`(name, value: untyped): untyped

`<%`:

• cstring_ptr_op: template `<%`(a, b: cstring): bool
• ptr_op: template `<%`[T](a, b: ptr T): bool

`<<=`:

• ops: template `<<=`[I: SomeInteger](a, b: I)

`<<`:

• ops: template `<<`[I: SomeInteger](a, b: I): I

`<=%`:

• cstring_ptr_op: template `<=%`(a, b: cstring): bool
• ptr_op: template `<=%`[T](a, b: ptr T): bool

`<=`:

• list_decl: proc `<=`[A, B](self: PyList[A]; o: openArray[B]): bool
• list_decl: proc `<=`[A, B](self: PyList[A]; o: PyList[B]): bool
• list_decl: template `<=`[A, B](o: openArray[A]; self: PyList[B]): bool
• pyslice: proc `<=`(self`gensym6: PySlice; o`gensym6: PySlice): bool
• set: proc `<=`[H](s: set[H]; self: SomePySet[H]): bool
• set: proc `<=`[H](self: SomePySet[H]; s: set[H]): bool
• set_decl: proc `<=`(self, o: SomePySet): int
• types: proc `<=`(st: struct_time; t: tuple): bool
• types: proc `<=`(t: tuple; st: struct_time): bool
• types: proc `<=`(a, b: struct_time): bool
• types: proc `<=`(a: struct_time; b: struct_time_tuple11): bool
• types: proc `<=`(a: struct_time_tuple11; b: struct_time): bool
• ops: template `<=`[A: SomeInteger; B: SomeFloat](a: A; b: B): bool
• ops: template `<=`[A: SomeFloat; B: SomeInteger](a: A; b: B): bool
• pybytearray: proc `<=`(self: PyByteArray; other: PyByteArray): bool
• pybytearray: proc `<=`(self: PyByteArray; other: PyBytes): bool

`<>`:

• ops: template `<>`[A: SomeInteger; B: SomeFloat](a: A; b: B): bool
• ops: template `<>`[A: SomeFloat; B: SomeInteger](a: A; b: B): bool
• strops: template `<>`[A: StringLike; B: StringLike](a: A; b: B): bool

`<`:

• list_decl: proc `<`[A, B](self: PyList[A]; o: openArray[B]): bool
• list_decl: proc `<`[A, B](self: PyList[A]; o: PyList[B]): bool
• list_decl: template `<`[A, B](o: openArray[A]; self: PyList[B]): bool
• pyslice: proc `<`(self`gensym3: PySlice; o`gensym3: PySlice): bool
• set: proc `<`[H](s: set[H]; self: SomePySet[H]): bool
• set: proc `<`[H](self: SomePySet[H]; s: set[H]): bool
• set_decl: proc `<`(self, o: SomePySet): int
• types: proc `<`(st: struct_time; t: tuple): bool
• types: proc `<`(t: tuple; st: struct_time): bool
• types: proc `<`(a, b: struct_time): bool
• types: proc `<`(a: struct_time; b: struct_time_tuple11): bool
• types: proc `<`(a: struct_time_tuple11; b: struct_time): bool
• ops: template `<`[A: SomeInteger; B: SomeFloat](a: A; b: B): bool
• ops: template `<`[A: SomeFloat; B: SomeInteger](a: A; b: B): bool
• pybytearray: proc `<`(self: PyByteArray; other: PyByteArray): bool
• pybytearray: proc `<`(self: PyByteArray; other: PyBytes): bool

`==`:

• complex: template `==`(a, b: PyTComplex): untyped
• dict: proc `==`[A, B](self, other: PyDict[A, B]): bool
• list_decl: proc `==`[A, B](self: PyList[A]; o: openArray[B]): bool
• list_decl: proc `==`[A, B](self: PyList[A]; o: PyList[B]): bool
• list_decl: template `==`[A, B](o: openArray[A]; self: PyList[B]): bool
• pyslice: proc `==`(self: PySlice; o: PySlice): bool
• set: proc `==`[H](s: set[H]; self: SomePySet[H]): bool
• set: proc `==`[H](self: SomePySet[H]; s: set[H]): bool
• set_decl: proc `==`(self, o: SomePySet): int
• collections_abc: proc `==`[K, V](a, b: Mapping[K, V]): bool
• types: proc `==`(st: struct_time; t: tuple): bool
• types: proc `==`(t: tuple; st: struct_time): bool
• types: proc `==`(a, b: struct_time): bool
• types: proc `==`(a: struct_time; b: struct_time_tuple11): bool
• types: proc `==`(a: struct_time_tuple11; b: struct_time): bool
• ops: template `==`[A: SomeInteger; B: SomeFloat](a: A; b: B): bool
• ops: template `==`[A: SomeFloat; B: SomeInteger](a: A; b: B): bool
• ops: template `==`(a, b: typedesc): bool
• pybool: proc `==`(self: PyBool; opyb: PyBool): PyBool
• pybool: proc `==`(self: PyBool; b: bool): PyBool
• pybool: proc `==`(b: bool; self: PyBool): PyBool
• pybytearray: proc `==`(self: PyByteArray; other: PyByteArray): bool
• pybytearray: proc `==`(self: PyByteArray; other: PyBytes): bool
• bytesimpl: proc `==`(self: PyBytes; o: PyBytes): bool
• strimpl: proc `==`(self: PyStr; o: PyStr): bool
• strimpl: proc `==`(self: PyStr; o: string): bool
• strimpl: proc `==`(o: string; self: PyStr): bool

`>>=`:

• ops: template `>>=`[I: SomeInteger](a, b: I)

`>>`:

• ops: template `>>`[I: SomeInteger](a, b: I): I

`@`:

• list_decl: proc `@`[T](ls: PyList[T]): seq[T]
• bytesimpl: proc `@`(self: PyBytes): seq[char]

`[]=`:

• dict: proc `[]=`[A, B](t: PyDict[A, B]; key: A; val: sink B)
• list: proc `[]=`[T](self: var PyList[T]; s: BackwardsIndex; x: T)
• list: proc `[]=`[T](self: var PyList[T]; s: HSlice; x: Iterable[T])
• list: proc `[]=`[T](self: var PyList[T]; s: HSlice; x: openArray[T])
• list: proc `[]=`[T](self: var PyList[T]; s: HSlice; x: PyList[T])
• list: proc `[]=`[T](self: var PyList[T]; idx: int; x: T)
• list: proc `[]=`[T](self: var PyList[T]; s: PySlice; x: not Sequence[T] and Iterable[T])
• list: proc `[]=`[T](self: var PyList[T]; s: PySlice; x: Sequence[T])
• list: proc `[]=`[T](ms: var PyList[T]; indices: Slice[int]; o: Sequence[T])
• float_view: proc `[]=`(fv: var VIEW32; _: range[0 .. 0]; f: float32)
• float_view: proc `[]=`(fv: var VIEW64; _: range[0 .. 0]; f: float64)
• pybytearray: proc `[]=`(mself: PyByteArray; i: HSlice[int, BackwardsIndex]; val: BytesLike)
• pybytearray: proc `[]=`(mself: PyByteArray; i: int; val: int)
• pybytearray: proc `[]=`(mself: PyByteArray; i: Slice[int]; val: BytesLike)
• pybytearray: proc `[]=`(ms: var PyByteArray; indices: Slice[int]; o: Sequence[int])
• wchar_t: proc `[]=`[I: csize_t | int](p: ptr wchar_t; i: I; val: wchar_t)

`[]`:

• dict: proc `[]`[A, B](t: PyDict[A, B]; key: A): B
• list: proc `[]`[T](self: PyList[T]; s: BackwardsIndex): T
• list: proc `[]`[T](self: PyList[T]; s: HSlice): PyList[T]
• list: proc `[]`[T](self: PyList[T]; idx: int): T
• list: proc `[]`[T](self: PyList[T]; s: PySlice): PyList[T]
• pyrange: proc `[]`[T](x: PyRange[T]; y: Natural): T
• float_view: proc `[]`(fv: VIEW32; _: range[0 .. 0]): float32
• float_view: proc `[]`(fv: VIEW64; _: range[0 .. 0]): float64
• pybytearray: proc `[]`(self: PyByteArray; i: HSlice[int, BackwardsIndex]): PyByteArray
• pybytearray: proc `[]`(self: PyByteArray; i: Slice[int]): PyByteArray
• bytesimpl: proc `[]`(self: PyBytes; i: HSlice[int, BackwardsIndex]): PyBytes
• bytesimpl: proc `[]`(self: PyBytes; i: int): int
• bytesimpl: proc `[]`(self: PyBytes; i: Slice[int]): PyBytes
• strimpl: proc `[]`(self: PyStr; i: HSlice[int, BackwardsIndex]): PyStr
• strimpl: proc `[]`(self: PyStr; i: int): PyStr
• strimpl: proc `[]`(self: PyStr; i: Slice[int]): PyStr
• ptr_op: template `[]`[I: IndexType; T](p: ptr T; i: I): T
• wchar_t: proc `[]`(p: ptr wchar_t; i: csize_t): wchar_t
• wchar_t: proc `[]`(p: ptr wchar_t; i: int): wchar_t

`^`:

• set: template `^`[H; M: SomePySet[H]; S: SomePySet[H]](self: M; s: S): M | S

`and`:

• pybool: proc `and`(self: PyBool; opyb: PyBool): PyBool
• pybool: proc `and`(self: PyBool; b: bool): PyBool
• pybool: proc `and`(b: bool; self: PyBool): PyBool
• pybool: proc `and`[T: not PyBool and not bool](nself, npyb: T): T
• strimpl: template `and`(a, b: PyStr): PyStr

`discard`:

• set: proc `discard`[H](self: var PySet[H]; ele: H)

`is`:

• pybool: proc `is`(self: PyBool; opyb: PyBool): PyBool

`not`:

• pybool: proc `not`(self: PyBool): PyBool
• pybool: proc `not`[T: not PyBool and not bool](nself: T): PyBool
• bytesimpl: template `not`(s: PyBytes): bool
• strimpl: template `not`(s: PyStr): bool

`or`:

• pybool: proc `or`(self: PyBool; opyb: PyBool): PyBool
• pybool: proc `or`(self: PyBool; b: bool): PyBool
• pybool: proc `or`(b: bool; self: PyBool): PyBool
• pybool: proc `or`[T: not PyBool and not bool](nself, npyb: T): T
• bytesimpl: template `or`(a, b: PyBytes): PyBytes
• strimpl: template `or`(a, b: PyStr): PyStr

`xor`:

• pybool: proc `xor`(self: PyBool; opyb: PyBool): PyBool

`|=`:

• dict: proc `|=`(a, b: PyDict)
• set: proc `|=`[H; S: SomeSet[H]](self: var SomePySet[H]; s: S)
• consts: template `|=`(a, b: cint)

`|`:

• dict: proc `|`(a, b: PyDict): PyDict
• set: template `|`[H; M: SomePySet[H]; S: SomePySet[H]](self: M; s: S): M | S
• consts: template `|`(a, b: cint): cint

abs:

• complex: proc abs[T](z: PyTComplex[T]): T

accessHighLow:

• indices: template accessHighLow(body)

ac_md_release:

• platformInfo: proc ac_md_release(): string

acos:

• math: proc acos[F: SomeFloat](x: F): F
• n_math: proc acos[F: SomeFloat](x: F): F

acosh:

• math: proc acosh[F: SomeFloat](x: F): F
• n_math: proc acosh[F: SomeFloat](x: F): F

add:

• set: proc add[H](self: var PySet[H]; x: H)
• frame: proc add(mparser; ident: string)

addFields:

• macro_utils: macro addFields(res: string; obj: typed; noMoreThan: static[int] = int.high)

add_from_bytes:

• int_bytes: proc add_from_bytes(res: var NimInt; bytes: PyBytes; byteorder: Endianness; signed = false)

addPatch:

• utils: template addPatch(ver: (int, int, int); flag: bool; patchBody: untyped)

ALIGNOF_SIZE_T:

• codecs: const ALIGNOF_SIZE_T

all:

• pybool: proc all[T](iter: Iterable[T]): PyBool

allAlpha:

• meth: template allAlpha(a, isWhat, isNotWhat: typed; iter, firstItemGetter)

allocWcharArr:

• wchar_t: template allocWcharArr[I](n: I): ptr wchar_t

altsep:

• consts: let altsep

any:

• pybool: proc any[T](iter: Iterable[T]): PyBool

append:

• list: proc append[T](self: var PyList[T]; x: T)
• collections_abc: proc append[T](ms: MutableSequence[T]; x: T)
• pybytearray: proc append(mself: PyByteArray; val: int)

argv:

• sys: var argv

ArithmeticError:

• aritherr: object ArithmeticError

ascii:

• strbltins: proc ascii(us: PyStr): PyStr
• strbltins: proc ascii(us: string): PyStr
• strbltins: template ascii(c: char): PyStr
• strbltins: template ascii(a: untyped): PyStr

ASCII_CHAR_MASK:

• codecs: const ASCII_CHAR_MASK

asctime:

• n_time: proc asctime(): string
• n_time: proc asctime(t: struct_time): string
• n_time: proc asctime(tup: struct_time_tuple): typeof(asctime do: bind struct_time struct_time(tm_year: 1900, tm_mon: 1, tm_mday: 1, tm_yday: 1, tm_isdst: -1))
• n_time: proc asctime(tup: struct_time_tuple10): typeof(asctime do: bind struct_time struct_time(tm_year: 1900, tm_mon: 1, tm_mday: 1, tm_yday: 1, tm_isdst: -1))
• n_time: proc asctime(tup: struct_time_tuple11): typeof(asctime do: bind struct_time struct_time(tm_year: 1900, tm_mon: 1, tm_mday: 1, tm_yday: 1, tm_isdst: -1))
• time: proc asctime(): PyStr
• time: proc asctime(t: Some_struct_time): PyStr
• asctimeImpl: proc asctime(dt: DateTime): string

asctimeImpl:

• asctimeImpl: template asctimeImpl(result: string; dt: DateTime)

asgSeqToObj:

• macro_utils: macro asgSeqToObj(tup, obj: typed)

asHashSet:

• set_decl: proc asHashSet[H](self: SomePySet[H]): HashSet[H]
• set_decl: proc asHashSet[H](self: var SomePySet[H]): var HashSet[H]

asin:

• math: proc asin[F: SomeFloat](x: F): F
• n_math: proc asin[F: SomeFloat](x: F): F

asinh:

• math: proc asinh[F: SomeFloat](x: F): F
• n_math: proc asinh[F: SomeFloat](x: F): F

as_integer_ratio:

• floats: proc as_integer_ratio(self: float; n = halfHigh(int)): (int, int)
• getter: template as_integer_ratio(self: NimInt): (NimInt, NimInt)

asSeq:

• list_decl: converter asSeq[T](self: PyList[T]): seq[T]
• list_decl: converter asSeq[T](self: var PyList[T]): var seq[T]

as_someinteger_ratio:

• floats: proc as_someinteger_ratio[I: SomeInteger](self: float; n = halfHigh(I)): (I, I)

asVersion:

• version: proc asVersion(v: (int, int)): string
• version: template asVersion(major, minor: int): string
• version: template asVersion(major, minor, patch: int): string
• version: proc asVersion(v: (int, int, int)): string

async:

• pydef: macro async(defsign, body): untyped

asyncImpl:

• pydef: proc asyncImpl(defsign, body: NimNode; parser: var PySyntaxProcesser; procType = nnkProcDef): NimNode

atan:

• math: proc atan[F: SomeFloat](x: F): F
• n_math: proc atan[F: SomeFloat](x: F): F

atan2:

• math: proc atan2[F: SomeFloat](x, y: F): F
• n_math: proc atan2[F: SomeFloat](x: F): F

atanh:

• math: proc atanh[F: SomeFloat](x: F): F
• n_math: proc atanh[F: SomeFloat](x: F): F

AttributeError:

• simperr: object AttributeError

autorange:

• n_timeit: template autorange(self: Timer; callable: proc (number: int; time_taken: float) = nil): ( int, float)
• timeit: template autorange(self: Timer; callable = None): (int, float)

b:

• bytesprefix: proc b(c: char{lit}): PyBytes
• bytesprefix: proc b(s: static[string]{lit}): PyBytes

BeforeFixedVer:

• abs: const BeforeFixedVer
• floatdollar: const BeforeFixedVer

BIAS:

• consts: template BIAS[F](_: typedesc[F]): F

bin:

• strbltins: proc bin(a`gensym13: SomeInteger): PyStr

bit_count:

• getter: template bit_count(self: NimInt): NimInt

bit_length:

• getter: template bit_length(self: NimInt): NimInt

bodySetItem:

• mutSeqSliceOp: template bodySetItem(Arr)

bool:

• pybool: proc bool[T](arg: T): PyBool

br:

• bytesprefix: proc br(s: string{lit}): PyBytes

Br:

• bytesprefix: template Br(s): PyBytes

BufferedIOBase:

• io: type BufferedIOBase

BufferedRandom:

• io: type BufferedRandom

BufferedReader:

• io: type BufferedReader

BufferedWriter:

• io: type BufferedWriter

bytearray:

• pybytearray: proc bytearray(): PyByteArray
• pybytearray: proc bytearray(o: BytesLike): PyByteArray
• pybytearray: proc bytearray(nbytes: int): PyByteArray
• pybytearray: proc bytearray(it: Iterable[char]): PyByteArray
• pybytearray: proc bytearray(it: Iterable[int]): PyByteArray
• pybytearray: proc bytearray(s: string): PyByteArray

byteLen:

• bytesimpl: proc byteLen(self: PyBytes): int
• strimpl: proc byteLen(self: PyStr): int

byteorder:

• sys: const byteorder

bytes:

• pybytearray: proc bytes(self: sink PyByteArray): PyBytes
• bytesimpl: proc bytes(): PyBytes
• bytesimpl: proc bytes(c: char): PyBytes
• bytesimpl: proc bytes(nLen: int): PyBytes
• bytesimpl: proc bytes(x: Iterable[char]): PyBytes
• bytesimpl: proc bytes(x: Iterable[int]): PyBytes
• bytesimpl: proc bytes(s: openArray[char]): PyBytes
• bytesimpl: proc bytes(s: sink string): PyBytes
• bytesimpl: proc bytes(self: PyBytes): PyBytes

BytesLike:

• pybytearray: type BytesLike

CanIOOpenT:

• io_abc: type CanIOOpenT

capitalize:

• bytesmeth: proc capitalize(a: PyBytes): PyBytes
• strmeth: proc capitalize(a: PyStr): PyStr

casefold:

• bytesmeth: template casefold(a: PyBytes): PyBytes
• strmeth: proc casefold(a: PyStr): PyStr

cbrt:

• math: proc cbrt[F: SomeFloat](x: F): F
• cbrt: proc cbrt[F: SomeFloat](x: F): F
• cbrt: proc cbrt[F: SomeFloat](x: F): F

ceil:

• n_math: proc ceil(x: SomeFloat): int

center:

• bytesmeth: proc center(a: PyBytes; width: int; fillchar = ' '): PyBytes
• bytesmeth: proc center(a: PyBytes; width: int; fillchar: PyBytes): PyBytes
• strmeth: proc center(a: PyStr; width: int; fillchar = ' '): PyStr
• strmeth: proc center(a: PyStr; width: int; fillchar: PyStr): PyStr
• meth: proc center[S](a: S; width: int; fillchar = ' '): S
• meth: proc center[S](a: S; width: int; fillchar: S = " "): S

c_fma:

• fma: proc c_fma(x, y, z: cdouble): cdouble
• fma: proc c_fma(x, y, z: cfloat): cfloat

c_getenv:

• envutils: proc c_getenv(v: cstring): cstring

chars:

• pybytearray: iterator chars(self: PyByteArray): char
• bytesimpl: iterator chars(self: PyBytes): char
• strimpl: iterator chars(self: PyStr): char

checked_as_integer_ratio:

• floats: proc checked_as_integer_ratio(self: float): (int, int)

checkedShl:

• chk_shl: proc checkedShl[I: SomeInteger](a, b: I): I

check_force_ascii:

• force_ascii_utils: proc check_force_ascii(): bool

checkLenientOps:

• list_decl: template checkLenientOps(A, B)

chr:

• strbltins: proc chr(a: SomeInteger): PyStr

class:

• class: macro class(obj, body: untyped): untyped

classImpl:

• class: proc classImpl(parser: var PySyntaxProcesser; obj, body: NimNode): NimNode

c_ldexp:

• ldexp: proc c_ldexp[F: SomeFloat](x: F; exp: cint): F

clear:

• dict: proc clear(self: PyDict)
• list: proc clear(self: var PyList)
• set_decl: proc clear(self: var PySet): int
• collections_abc: proc clear(ms: MutableSequence)
• pybytearray: proc clear(mself: PyByteArray)

CLEAR_EXP_MASK:

• consts: template CLEAR_EXP_MASK[F](): untyped

CLike:

• platformUtils: const CLike

clikeOr:

• platformUtils: template clikeOr(inCLike, b): untyped

close:

• io: method close(self: IOBase)
• io: method close(self: RawIOBase)
• io: method close(self: TextIOWrapper)
• open_close: proc close(fd: int)

closerange:

• open_close: proc closerange(fd_low, fd_high: int)

ClosureIter:

• niter_types: type ClosureIter

cmpOnField:

• macro_utils: macro cmpOnField(a, b: typed): int

CmpStragy:

• macro_utils: enum CmpStragy

Collection:

• collections_abc: type Collection

comb:

• math: proc comb(n, k: int): int
• n_math: proc comb(n, k: int): int

CompileBackend:

• backendMark: enum CompileBackend

compileLittleEndian:

• assertIsLittleEndian: const compileLittleEndian

complex:

• complex: proc complex(s: string): PyComplex
• complex: proc complex[T: SomeFloat](real: T = 0.0; imag: T = 0.0): PyTComplex[T]
• complex: proc complex[T: SomeInteger](real: T = 0; imag: T = 0): PyComplex
• complex: template complex(real, imag: HasFloat): PyComplex
• complex: template complex(real, imag: HasIndex): PyComplex

conjugate:

• complex: proc conjugate[T](z: PyTComplex[T]): PyTComplex[T]
• getter: template conjugate(self: NimInt): NimInt

consumeDecorator:

• decorator: proc consumeDecorator(mparser; procDef: NimNode): NimNode

Container:

• collections_abc: type Container

contains:

• dict: proc contains[A, B](t: PyDict[A, B]; key: A): bool
• dict: proc contains[K, V](t: PyDictItemView[K, V]; x: (K, V)): bool
• dict: proc contains[T](t: PyDictKeyView[T]; x: T): bool
• dict: proc contains[T](t: PyDictValueView[T]; x: T): bool
• pyrange: proc contains[T](x: PyRange[T]; y: T): bool
• set_decl: proc contains[H](self: SomePySet[H]; x: H): bool
• collections_abc: proc contains[T](s: Container[T]; x: T): bool
• collections_abc: proc contains[K, V](m: Mapping[K, V]; k: K): bool
• bytesmeth: proc contains(a: PyBytes; o: int): bool
• bytesmeth: proc contains(a: PyBytes; o: PyBytes): bool
• strimpl: proc contains(s: PyStr; c: char): bool
• strimpl: proc contains(s: PyStr; c: PyStr): bool
• strimpl: proc contains(s: PyStr; c: string): bool
• frame: proc contains(mparser; ident: string): bool

copy:

• dict: proc copy[K, V](self: PyDict[K, V]): PyDict[K, V]
• set: template copy[H; S: SomePySet[H]](self): S
• pybytearray: proc copy(self: PyByteArray): PyByteArray

copyright:

• sys: const copyright

copysign:

• math: proc copysign[F: SomeFloat](x, y: F): F

cos:

• math: proc cos[F: SomeFloat](x: F): F

cosh:

• math: proc cosh[F: SomeFloat](x: F): F

count:

• pyrange: proc count[T](r: PyRange[T]; x: T): int
• collections_abc: proc count[T](s: Sequence[T]; x: T): int
• bytesmeth: proc count(a: PyBytes; sub: int): int
• bytesmeth: proc count(a: PyBytes; sub: int; start: int): int
• bytesmeth: proc count(a: PyBytes; sub: int; start = 0; end: int): int
• bytesmeth: proc count(a: PyBytes; sub: PyBytes): int
• bytesmeth: proc count(a: PyBytes; sub: PyBytes; start: int): int
• bytesmeth: proc count(a: PyBytes; sub: PyBytes; start = 0; end: int): int
• strmeth: proc count(a: PyStr; sub: PyStr): int
• strmeth: proc count(a: PyStr; sub: PyStr; start: int): int
• strmeth: proc count(a: PyStr; sub: PyStr; start = 0; end: int): int
• meth: proc count[S](a: S; sub: S): int
• meth: proc count[S](a: S; sub: S; start: int): int
• meth: proc count[S](a: S; sub: S; start = 0; end: int): int

c_powi:

• ncomplex_pow: proc c_powi[T](x: Complex[T]; i: int): Complex[T]

c_powu:

• ncomplex_pow: proc c_powu[T](x: Complex[T]; n: Natural): Complex[T]

csEq:

• macro_utils: CmpStragy.csEq

c_setlocale:

• localeutils: proc c_setlocale(category: cint; v: cstring): cstring

csLhs:

• macro_utils: CmpStragy.csLhs

csRhs:

• macro_utils: CmpStragy.csRhs

csShorter:

• macro_utils: CmpStragy.csShorter

ctime:

• n_time: proc ctime(): string
• n_time: proc ctime(secs: float | int64): string
• time: proc ctime(): PyStr
• time: proc ctime(secs: float | int64): PyStr

curdir:

• consts: let curdir

deallocWcArr:

• wchar_t: template deallocWcArr(p: ptr wchar_t)

declErrorcodeWith:

• errorcodeInit: template declErrorcodeWith[K, V](initFunc: typed)

declTupleWithNFieldsFrom:

• macro_utils: macro declTupleWithNFieldsFrom(name: untyped; Cls: typedesc; n: static[int]; exported: static[bool] = true)

DECODE_ERROR:

• wchar_t: const DECODE_ERROR

Decorator:

• frame: type Decorator

decorators:

• frame: proc decorators(mparser): var seq[Decorator]

def:

• pydef: macro def(signature, body): untyped

DEFAULT_BUFFER_SIZE:

• io: const DEFAULT_BUFFER_SIZE

default_number:

• n_timeit: const default_number

default_repeat:

• n_timeit: const default_repeat
• timeit: const default_repeat

DefaultTimeFormat:

• n_time: const DefaultTimeFormat
• time: const DefaultTimeFormat

default_timer:

• n_timeit: var default_timer
• timeit: var default_timer

defAux:

• pydef: proc defAux(signature, body: NimNode; deftype = ident"untyped"; parser: var PySyntaxProcesser; procType = nnkTemplateDef; pragmas = emptyn): NimNode

DefEncoding:

• io: const DefEncoding

DefErrors:

• ncodec: const DefErrors

defImpl:

• pydef: proc defImpl(signature, body: NimNode; parser: var PySyntaxProcesser; pragmas = emptyn; deftype = ident"auto"; procType = nnkProcDef): NimNode

define:

• pydef: macro define(signature, body): untyped

DefNewLine:

• io: const DefNewLine

defpath:

• consts: const defpath

DefSplitCap:

• common: const DefSplitCap

degrees:

• n_math: proc degrees[F: SomeFloat](x: F): F

del:

• pysugar: macro del(seqIdx: untyped)

delitem:

• dict: proc delitem[K, V](self: PyDict[K, V]; k: K)
• list: proc delitem(self: var PyList; idx: int)
• list: proc delitem(ms: var PyList; indices: PySlice)
• list: proc delitem(ms: var PyList; indices: Slice[int])
• pybytearray: proc delitem(mself: PyByteArray; i: int)
• pybytearray: proc delitem(ms: var PyByteArray; indices: PySlice)
• pybytearray: proc delitem(ms: var PyByteArray; indices: Slice[int])

DeprecationWarning:

• warnings: Warning.DeprecationWarning

devnull:

• consts: const devnull

dict:

• dict: macro dict(kwargs: varargs[untyped]): PyDict
• dict_decl: type dict

difference:

• set: proc difference[H](self: PyFrozenSet[H]; o: SomePySet[H]): PyFrozenSet[H]
• set: proc difference[H](self: PySet[H]; o: PyFrozenSet[H]): PyFrozenSet[H]
• set: proc difference[H](self, o: PySet[H]): PySet[H]
• set: proc difference[H; Self: SomePySet[H]; S](self: Self; s1: auto; s2: auto; x: varargs[S]): Self
• set: proc difference[H; Self: SomePySet[H]; S: not PySet[H]](self: Self; s: S): Self

difference_update:

• set: proc difference_update[H; I: Iterable[H]](self: var SomePySet[H]; i: I)

dist:

• math: template dist[T](p, q: (Iterable[T] and not openArray[T])): float
• math: template dist[T](p, q: ClosureIter[T]): float
• math: template dist[T](p, q: list[T]): float
• math: template dist[T](p, q: openArray[T]): float
• dist: proc dist[A, B](p, q: (A, B)): float
• dist: proc dist[A, B, C](p, q: (A, B, C)): float
• dist: proc dist[T; I: static[int]](p, q: array[I, T]): float

dist_checkedSameLen:

• niter_types: proc dist_checkedSameLen[T](p, q: T): int

divmod:

• ops: proc divmod[T: SomeNumber](x, y: T): (T, T)

dl_mul:

• dl_ops: proc dl_mul(x: float; y: float): DoubleLength

dl_sum:

• dl_ops: proc dl_sum(a, b: float): DoubleLength

docTable:

• nstrfptime: const docTable

DocTable:

• doc_utils: object DocTable

DoubleLength:

• dl_ops: object DoubleLength

dtToStructTime:

• converters: proc dtToStructTime(dt: DateTime; res: var struct_time)

dunder_stderr:

• sys: let dunder_stderr

dunder_stdin:

• sys: let dunder_stdin

dunder_stdout:

• sys: let dunder_stdout

e:

• n_math: const e

E2BIG:

• errnoConsts: let E2BIG

EACCES:

• errnoConsts: let EACCES

EADDRINUSE:

• errnoConsts: let EADDRINUSE

EADDRNOTAVAIL:

• errnoConsts: let EADDRNOTAVAIL

EADV:

• errnoConsts: let EADV

EAFNOSUPPORT:

• errnoConsts: let EAFNOSUPPORT

EAGAIN:

• errnoConsts: let EAGAIN

EALREADY:

• errnoConsts: let EALREADY

EBADE:

• errnoConsts: let EBADE

EBADF:

• errnoConsts: let EBADF

EBADFD:

• errnoConsts: let EBADFD

EBADMSG:

• errnoConsts: let EBADMSG

EBADR:

• errnoConsts: let EBADR

EBADRQC:

• errnoConsts: let EBADRQC

EBADSLT:

• errnoConsts: let EBADSLT

EBFONT:

• errnoConsts: let EBFONT

EBUSY:

• errnoConsts: let EBUSY

ECANCELED:

• errnoConsts: let ECANCELED

ECHILD:

• errnoConsts: let ECHILD

ECHRNG:

• errnoConsts: let ECHRNG

ECOMM:

• errnoConsts: let ECOMM

ECONNABORTED:

• errnoConsts: let ECONNABORTED

ECONNREFUSED:

• errnoConsts: let ECONNREFUSED

ECONNRESET:

• errnoConsts: let ECONNRESET

EDEADLK:

• errnoConsts: let EDEADLK

EDEADLOCK:

• errnoConsts: let EDEADLOCK

EDESTADDRREQ:

• errnoConsts: let EDESTADDRREQ

EDOM:

• errnoConsts: let EDOM

EDOTDOT:

• errnoConsts: let EDOTDOT

EDQUOT:

• errnoConsts: let EDQUOT

EEXIST:

• errnoConsts: let EEXIST

EFAULT:

• errnoConsts: let EFAULT

EFBIG:

• errnoConsts: let EFBIG

EHOSTDOWN:

• errnoConsts: let EHOSTDOWN

EHOSTUNREACH:

• errnoConsts: let EHOSTUNREACH

EIDRM:

• errnoConsts: let EIDRM

EILSEQ:

• errnoConsts: let EILSEQ

EINPROGRESS:

• errnoConsts: let EINPROGRESS

EINTR:

• errnoConsts: let EINTR

EINVAL:

• errnoConsts: let EINVAL

EIO:

• errnoConsts: let EIO

EISCONN:

• errnoConsts: let EISCONN

EISDIR:

• errnoConsts: let EISDIR

EISNAM:

• errnoConsts: let EISNAM

EKEYEXPIRED:

• errnoConsts: let EKEYEXPIRED

EKEYREJECTED:

• errnoConsts: let EKEYREJECTED

EKEYREVOKED:

• errnoConsts: let EKEYREVOKED

EL2HLT:

• errnoConsts: let EL2HLT

EL2NSYNC:

• errnoConsts: let EL2NSYNC

EL3HLT:

• errnoConsts: let EL3HLT

EL3RST:

• errnoConsts: let EL3RST

ELIBACC:

• errnoConsts: let ELIBACC

ELIBBAD:

• errnoConsts: let ELIBBAD

ELIBEXEC:

• errnoConsts: let ELIBEXEC

ELIBMAX:

• errnoConsts: let ELIBMAX

ELIBSCN:

• errnoConsts: let ELIBSCN

ELNRNG:

• errnoConsts: let ELNRNG

ELOOP:

• errnoConsts: let ELOOP

EMEDIUMTYPE:

• errnoConsts: let EMEDIUMTYPE

EMFILE:

• errnoConsts: let EMFILE

EMLINK:

• errnoConsts: let EMLINK

emptyPyDict:

• dict_decl: proc emptyPyDict[K, V](): PyDict[K, V]

EMSGSIZE:

• errnoConsts: let EMSGSIZE

EMULTIHOP:

• errnoConsts: let EMULTIHOP

ENAMETOOLONG:

• errnoConsts: let ENAMETOOLONG

ENAVAIL:

• errnoConsts: let ENAVAIL

EncErrors:

• ncodec: enum EncErrors

encoding:

• io: proc encoding(s: TextIOWrapper): PyStr

encodings.normalize_encoding:

• encoding_norm: proc encodings.normalize_encoding(encoding: string): string

endsWith:

• bytesmeth: proc endsWith(a: PyBytes; suffix: char): bool
• bytesmeth: proc endsWith(a: PyBytes; suffix: int): bool
• bytesmeth: proc endsWith[Suf: PyBytes | tuple](a: PyBytes; suffix: Suf; start: int): bool
• bytesmeth: proc endsWith[Suf: PyBytes | tuple](a: PyBytes; suffix: Suf; start, end: int): bool
• bytesmeth: proc endsWith[Tup: tuple](a: PyBytes; suffix: Tup): bool
• strmeth: proc endsWith(a: char; suffix: PyStr): bool
• strmeth: proc endsWith(a: PyStr; suffix: char): bool
• strmeth: proc endsWith[Suf: PyStr | tuple](a: PyStr; suffix: Suf; start: int): bool
• strmeth: proc endsWith[Suf: PyStr | tuple](a: PyStr; suffix: Suf; start, end: int): bool
• strmeth: proc endsWith[Tup: tuple](a: PyStr; suffix: Tup): bool
• meth: proc endsWith[S; Suf: S | tuple](a: S; suffix: Suf; start: int): bool
• meth: proc endsWith[S; Suf: S | tuple](a: S; suffix: Suf; start, end: int): bool
• meth: proc endsWith[S; Tup: tuple](a: S; suffix: Tup): bool
• meth: template endsWith[S](a: char; suffix: S): bool
• meth: template endsWith[S](a: S; suffix: char): bool

ENETDOWN:

• errnoConsts: let ENETDOWN

ENETRESET:

• errnoConsts: let ENETRESET

ENETUNREACH:

• errnoConsts: let ENETUNREACH

ENFILE:

• errnoConsts: let ENFILE

ENOANO:

• errnoConsts: let ENOANO

ENOBUFS:

• errnoConsts: let ENOBUFS

ENOCSI:

• errnoConsts: let ENOCSI

ENODATA:

• errnoConsts: let ENODATA

ENODEV:

• errnoConsts: let ENODEV

ENOENT:

• errnoConsts: let ENOENT

ENOEXEC:

• errnoConsts: let ENOEXEC

ENOKEY:

• errnoConsts: let ENOKEY

ENOLCK:

• errnoConsts: let ENOLCK

ENOLINK:

• errnoConsts: let ENOLINK

ENOMEDIUM:

• errnoConsts: let ENOMEDIUM

ENOMEM:

• errnoConsts: let ENOMEM

ENOMSG:

• errnoConsts: let ENOMSG

ENONET:

• errnoConsts: let ENONET

ENOPKG:

• errnoConsts: let ENOPKG

ENOPROTOOPT:

• errnoConsts: let ENOPROTOOPT

ENOSPC:

• errnoConsts: let ENOSPC

ENOSR:

• errnoConsts: let ENOSR

ENOSTR:

• errnoConsts: let ENOSTR

ENOSYS:

• errnoConsts: let ENOSYS

ENOTBLK:

• errnoConsts: let ENOTBLK

ENOTCONN:

• errnoConsts: let ENOTCONN

ENOTDIR:

• errnoConsts: let ENOTDIR

ENOTEMPTY:

• errnoConsts: let ENOTEMPTY

ENOTNAM:

• errnoConsts: let ENOTNAM

ENOTRECOVERABLE:

• errnoConsts: let ENOTRECOVERABLE

ENOTSOCK:

• errnoConsts: let ENOTSOCK

ENOTSUP:

• errnoConsts: let ENOTSUP

ENOTTY:

• errnoConsts: let ENOTTY

ENOTUNIQ:

• errnoConsts: let ENOTUNIQ

enter:

• io: proc enter[IO: IOBase](self: IO): IO

enumerate:

• iters: proc enumerate[T](x: Iterable[T]; start = 0): Enumerate[T]
• iters: iterator enumerate[T](x: Iterable[T]; start = 0): (int, T)

ENXIO:

• errnoConsts: let ENXIO

EOPNOTSUPP:

• errnoConsts: let EOPNOTSUPP

EOVERFLOW:

• errnoConsts: let EOVERFLOW

EOWNERDEAD:

• errnoConsts: let EOWNERDEAD

EPERM:

• errnoConsts: let EPERM

EPFNOSUPPORT:

• errnoConsts: let EPFNOSUPPORT

EPIPE:

• errnoConsts: let EPIPE

EPROTO:

• errnoConsts: let EPROTO

EPROTONOSUPPORT:

• errnoConsts: let EPROTONOSUPPORT

EPROTOTYPE:

• errnoConsts: let EPROTOTYPE

ERANGE:

• errnoConsts: let ERANGE

EREMCHG:

• errnoConsts: let EREMCHG

EREMOTE:

• errnoConsts: let EREMOTE

EREMOTEIO:

• errnoConsts: let EREMOTEIO

ERESTART:

• errnoConsts: let ERESTART

erf:

• math: proc erf[F: SomeFloat](x: F): F

erfc:

• math: proc erfc[F: SomeFloat](x: F): F

ERFKILL:

• errnoConsts: let ERFKILL

EROFS:

• errnoConsts: let EROFS

Errno:

• errnos: enum Errno

errno:

• singleton_errno: var errno

ErrnoCount:

• errnos: const ErrnoCount

errnoMsg:

• oserr: proc errnoMsg(errnoCode: cint): string

errors:

• io: proc errors(s: TextIOWrapper): PyStr

ESHUTDOWN:

• errnoConsts: let ESHUTDOWN

ESOCKTNOSUPPORT:

• errnoConsts: let ESOCKTNOSUPPORT

ESPIPE:

• errnoConsts: let ESPIPE

ESRCH:

• errnoConsts: let ESRCH

ESRMNT:

• errnoConsts: let ESRMNT

ESTALE:

• errnoConsts: let ESTALE

ESTRPIPE:

• errnoConsts: let ESTRPIPE

ETIME:

• errnoConsts: let ETIME

ETIMEDOUT:

• errnoConsts: let ETIMEDOUT

ETOOMANYREFS:

• errnoConsts: let ETOOMANYREFS

ETXTBSY:

• errnoConsts: let ETXTBSY

EUCLEAN:

• errnoConsts: let EUCLEAN

EULER:

• consts: const EULER

EUNATCH:

• errnoConsts: let EUNATCH

EUSERS:

• errnoConsts: let EUSERS

EWOULDBLOCK:

• errnoConsts: let EWOULDBLOCK

excl:

• set_decl: proc excl[H](self: var SomePySet[H]; x: H)

EXDEV:

• errnoConsts: let EXDEV

executable:

• sys: template executable(): PyStr

EXFULL:

• errnoConsts: let EXFULL

exit:

• io: template exit(self: IOBase; args: varargs[untyped])
• sys: proc exit(c: int)
• sys: proc exit(x: NoneType)
• sys: proc exit(s: PyStr)
• sys: proc exit[T](obj: T)

exp:

• math: proc exp[F: SomeFloat](x: F): F

expandtabs:

• bytesmeth: proc expandtabs(a: PyBytes; tabsize = 8): PyBytes
• strmeth: proc expandtabs(a: PyStr; tabsize = 8): PyStr

expandtabsImpl:

• meth: template expandtabsImpl[S](a: S; tabsize: int; strByteLen: int; iter): string

expm1:

• math: proc expm1[F: SomeFloat](x: F): F
• expm1: proc expm1[F: SomeFloat](x: F): F
• expm1_log1p: proc expm1[F: SomeFloat](x: F): F

EXP_MASK:

• consts: template EXP_MASK[F](): untyped

exponent:

• exponent: proc exponent[F: SomeFloat](x: F): BiggestInt

exportAllErrnosViaEnumOrImportc:

• exportUtils: macro exportAllErrnosViaEnumOrImportc()

extend:

• list: proc extend[T](self: var PyList[T]; ls: openArray[T])
• list: template extend[T](self: var PyList[T]; ls: Iterable[T])
• collections_abc: proc extend[T](ms: MutableSequence[T]; it: Iterable[T])
• pybytearray: proc extend(mself: PyByteArray; other: BytesLike)

extsep:

• consts: let extsep

f:

• fstring: template f(s: string{lit}): PyStr

fabs:

• math: proc fabs[F: SomeFloat](x: F): F
• n_math: proc fabs[F: SomeFloat](x: F): F

factorial:

• math: proc factorial(x: int): int
• n_math: proc factorial(x: Natural): int

False:

• pybool: const False

fetchDoc:

• doc_utils: macro fetchDoc(tab: static DocTable)
• doc_utils: macro fetchDoc(tab: static DocTable; def)

FileExistsError:

• oserr: object FileExistsError

FileIO:

• io: type FileIO

fileno:

• io: proc fileno(f: IOBase): int

FileNotFoundError:

• oserr: object FileNotFoundError

filter:

• iters: proc filter[T](comp: NoneType; iter: Iterable[T]): Filter[T]
• iters: proc filter[T](comp: proc (arg: T): bool; iter: Iterable[T]): Filter[T]
• iters: iterator filter[T](comp: NoneType; iter: Iterable[T]): T
• iters: iterator filter[T](comp: proc (arg: T): bool; iter: Iterable[T]): T

find:

• bytesmeth: proc find(a: PyBytes; b: int; start = 0; end = len(a)): int
• bytesmeth: proc find(a: PyBytes; b: PyBytes; start = 0; end = len(a)): int
• strmeth: proc find(a: PyStr; b: PyStr; start = 0; end = len(a)): int
• meth: proc find[S; T](a: S; b: T; start = 0): int
• meth: proc find[S; T](a: S; b: T; start = 0; end: int): int

find1:

• meth: proc find1[S; T](a: S; b: T; start = 0): int
• meth: proc find1[S; T](a: S; b: T; start = 0; end: int): int

fitLen:

• nint_proto: template fitLen(_: var NimInt; nbyte: int): bool

FixedVer:

• abs: const FixedVer
• floatdollar: const FixedVer

float:

• init: proc float(a: PyStr | PyBytes): BiggestFloat
• init: template float(a: bool): BiggestFloat
• init: template float(obj: HasIndex): BiggestFloat
• init: template float(number: SomeNumber = 0.0): BiggestFloat

float_fromhex:

• floats: proc float_fromhex(s: string): float

floatFromhexImpl:

• floathex: proc floatFromhexImpl(s: string): float

float_info:

• sys: const float_info

floor:

• n_math: proc floor(x: SomeFloat): int

flush:

• io: proc flush(f: IOBase)

fma:

• math: proc fma[F: SomeFloat](x, y, z: F): F
• fma: proc fma[F: SomeFloat](x, y, z: F): F
• fma: proc fma[F: SomeFloat](x, y, z: F; exc: var ref Exception): F

fmod:

• math: proc fmod[F: SomeFloat](x: F; y: F): F
• n_math: proc fmod[F: SomeFloat](x: F; y: F): F

force_ascii:

• force_ascii_utils: template force_ascii(): untyped

forErrno:

• loopErrno: template forErrno(res: NimNode; err; body)

format:

• format: template format(s: PyStr; argKw: varargs[untyped]): PyStr
• format: template format[T](value: T; format_spec: PyStr = ""): PyStr
• formats: proc format(value: char; format_spec: string = ""): string
• formats: template format[T](value: T; format_spec: string = ""): string

fr:

• fstring: macro fr(pattern: string{lit}): PyStr

Fr:

• fstring: macro Fr(pattern: string{lit}): PyStr

frexp:

• frexp: proc frexp[F: SomeFloat](x: F): (F, int)
• frexp: proc frexp[F: SomeFloat](x: F; e: var int): F
• frexp: proc frexp[F: SomeFloat](x: F): (F, int)

from_bytes:

• int_bytes: proc from_bytes(_: typedesc[NimInt]; bytes: PyBytes; byteorder: PyStr; signed = false): NimInt
• int_bytes: proc from_bytes(_: typedesc[NimInt]; bytes: PyBytes; byteorder: static[PyStr] = str("big"); signed = false): NimInt

fromhex:

• floats: proc fromhex(_: typedesc[float]; s: string): float
• hex: proc fromhex(_: typedesc[PyBytes]; s: PyStr): PyBytes

fromWords:

• fromWords: proc fromWords(high, low: uint16): float32
• fromWords: proc fromWords(high, low: uint32): float

frozenset:

• set: proc frozenset[H](): PyFrozenSet[H]
• set: proc frozenset[H](s: HashSet[H]): PyFrozenSet[H]
• set: proc frozenset[H](it: Iterable[H]): PyFrozenSet[H]
• set: proc frozenset[H](arr: openArray[H]): PyFrozenSet[H]
• set: proc frozenset[H](s: SomePySet[H]): PyFrozenSet[H]
• set_decl: type frozenset

fspath:

• io_abc: proc fspath(c: char): PyStr
• io_abc: proc fspath(s: string): PyStr
• bytesimpl: proc fspath(self: PyBytes): PyBytes
• strimpl: proc fspath(self: PyStr): PyStr

fsum:

• n_math: proc fsum[T: SomeFloat](iterable: Iterable[T]): T

ftruncate:

• truncate: proc ftruncate(file: Positive; length: int64)

gamma:

• math: proc gamma[F: SomeFloat](x: F): F
• gamma: proc gamma[F: SomeFloat](x: F): F
• gamma: proc gamma[T: SomeFloat](x: T; res: var T): GammaError
• n_math: proc gamma[F: SomeFloat](x: F): F

GammaError:

• err: enum GammaError

gcd:

• n_math: proc gcd[I: SomeInteger](x, y: I): I
• n_math: proc gcd[I: SomeInteger](x, y, z: I; args: varargs[I]): I

geDom:

• err: GammaError.geDom

geGotNegInf:

• err: GammaError.geGotNegInf

genDelItem:

• mutSeqSliceOp: template genDelItem(Arr)

genGenericSetItem:

• mutSeqSliceOp: template genGenericSetItem(Arr, Arr2)

genIter:

• iterGen: macro genIter(def)

genNonGenericSetItem:

• mutSeqSliceOp: template genNonGenericSetItem(Arr, Arr2)

genWithArg:

• constsUtils: template genWithArg(sym, v32, v64)

genWithBracket:

• constsUtils: template genWithBracket(sym, v32, v64)
• constsUtils: template genWithBracket(sym, v32, v64, Ret)

geOk:

• err: GammaError.geOk

geOverFlow:

• err: GammaError.geOverFlow

get:

• dict: proc get[K, V](self: PyDict[K, V]; key: K): V
• dict: proc get[K, V](self: PyDict[K, V]; key: K; default: V): V
• collections_abc: proc get[K, V](m: Mapping[K, V]; key: K): V
• collections_abc: proc get[K, V](m: Mapping[K, V]; key: K; default: V): V

getattr:

• attr: macro getattr(x; attr: static[string]): untyped
• attr: macro getattr(x; attr: static[string]; default): untyped

getChar:

• pybytearray: proc getChar(self: PyByteArray; i: Natural): char
• bytesimpl: proc getChar(self: PyBytes; i: Natural): char
• strimpl: proc getChar(self: PyStr; i: Natural): char

getCharPtr:

• pybytearray: proc getCharPtr(self: PyByteArray; i: Natural | Natural): ptr char
• bytesimpl: proc getCharPtr(self: PyBytes; i: Natural | BackwardsIndex): ptr char

getdefaultencoding:

• sys: proc getdefaultencoding(): PyStr

getErrno:

• errnoUtils: template getErrno(): cint

getfilesystemencoding:

• sys: proc getfilesystemencoding(): PyStr

GET_FLOAT_WORD:

• common: template GET_FLOAT_WORD(x: float32): uint32
• common: template GET_FLOAT_WORD(word: var uint32; x: float32)

getLowWord:

• common: template getLowWord(x: float32): uint16
• common: template getLowWord(x: float64): uint32

getMaxChar:

• codecs: proc getMaxChar[C](): C

getOrDefault:

• dict_decl: proc getOrDefault[A, B](t: PyDict[A, B]; key: A): B

getPtr:

• list_decl: proc getPtr[T](self: sink PyList[T]; i: Natural | BackwardsIndex): ptr T

getSize:

• nint_proto: template getSize(self: NimInt): int

getsizeof:

• sys: template getsizeof(x): int
• sys: template getsizeof(x; default: int): int

geUnderFlow:

• err: GammaError.geUnderFlow

geZeroCantDetSign:

• err: GammaError.geZeroCantDetSign

gmtime:

• struct_time_funcs: proc gmtime(): struct_time
• struct_time_funcs: proc gmtime(secs: float): struct_time
• struct_time_funcs: proc gmtime(secs: int64): struct_time

hasattr:

• attr: macro hasattr(x; attr: static[string]): bool

hasBug:

• abs: const hasBug
• floatdollar: const hasBug

hasChar:

• bytesimpl: proc hasChar(a: PyBytes; o: char): bool

hash:

• pyhashes: proc hash(x: tuple): int
• pyhashes: proc hash(x: float): int
• pyhashes: proc hash(x: int): int
• pyhashes: proc hash(x: proc): int
• pyhashes: proc hash(x: PyDict): int
• pyhashes: proc hash(x: PyList): int
• pyhashes: proc hash(x: PySet): int
• pyhashes: proc hash(x: PyTComplex): int
• pyhashes: proc hash(x: PyStr | PyBytes): int
• set_decl: proc hash[H](self: PyFrozenSet[H]): int

HAVE_MBRTOWC:

• wchar_t: const HAVE_MBRTOWC

hex:

• floats: proc hex(x: float): PyStr
• hex: proc hex(self: PyBytes): PyStr
• hex: proc hex(self: PyBytes; sep: PyStr | PyBytes): PyStr
• hex: proc hex(self: PyBytes; sep: char | PyStr | PyBytes; bytes_per_sep: int): PyStr
• hex: proc hex(self: PyBytes; sep: char): PyStr
• strbltins: proc hex(a`gensym16: SomeInteger): PyStr

hexImpl:

• floathex: proc hexImpl(x: float): string

hexversion:

• sys: const hexversion

HIGH:

• indices: const HIGH

HighWordFracBits:

• consts: template HighWordFracBits[F](): untyped

hugeF:

• expm1: template hugeF[F](): untyped

hypot:

• n_math: proc hypot[I: SomeFloat](x, y: I): I
• n_math: proc hypot[I: SomeFloat](x, y, z: I; args: varargs[I]): I

id:

• misc: template id(x): int

imag:

• complex: template imag[T](z: PyTComplex[T]): T

imag=:

• complex: template imag=[T](z: PyTComplex[T]; _: T)

impExp:

• trans_imp: macro impExp(pre; mods: varargs[untyped])

impJsOrC:

• platformUtils: template impJsOrC(sym, cfloatSym, argSym)

implementation:

• sys: const implementation

inc:

• cstring_ptr_op: template inc(s: cstring; i = 1)
• ptr_op: template inc[T](s: ptr T; i = 1)
• wchar_t: template inc[I](p: var ptr wchar_t; i: I = 1)

incl:

• set_decl: proc incl[H](self: var SomePySet[H]; x: H)

INCOMPLETE_CHARACTER:

• wchar_t: const INCOMPLETE_CHARACTER

index:

• pyrange: proc index[T](r: PyRange[T]; x: T): int
• collections_abc: proc index[T](s: Sequence[T]; x: T; start = 0; stop = -1): int
• bytesmeth: proc index(a: PyBytes; b: int; start = 0; end = len(a)): int
• bytesmeth: proc index(a: PyBytes; b: PyBytes; start = 0; end = len(a)): int
• strmeth: proc index(a, b: PyStr; start = 0; end = len(a)): int
• meth: proc index[S; T](a: S; b: T; start = 0): int
• meth: proc index[S; T](a: S; b: T; start = 0; end: int): int

index1:

• meth: proc index1[S; T](a: S; b: T; start = 0): int
• meth: proc index1[S; T](a: S; b: T; start = 0; end: int): int

indices:

• pyslice: proc indices(self: PySlice; length: int): (int, int, int)

inf:

• n_math: const inf

init32FloatView:

• float_view: template init32FloatView(FLOAT32_VIEW, UINT16_VIEW)

init64FloatView:

• float_view: template init64FloatView(FLOAT64_VIEW, UINT32_VIEW)

initBufAsPy:

• io: proc initBufAsPy(nfile: var File; buf: int)

initDocTable:

• doc_utils: proc initDocTable(moduleDoc: string; init: openArray[(string, string)]): DocTable

initErrorcodeMap:

• errorcodeInit: macro initErrorcodeMap(K, V; res: untyped; initFunc: typed)

initNCodecInfo:

• ncodec: proc initNCodecInfo(encoding: string; errors = DefErrors): NCodecInfo

initStructTime:

• types: template initStructTime(): struct_time
• types: template initStructTime(year, mon, mday, hour, min, sec, wday, yday, isdst, zone, gmtoff): struct_time

InJs:

• oserr: const InJs

input:

• input: proc input(prompt = str("")): PyStr

insert:

• list: proc insert[T](self: var PyList[T]; idx: int; x: T)
• pybytearray: proc insert(mself: PyByteArray; i: int; val: int)

inspect.cleandoc:

• inspect_cleandoc: proc inspect.cleandoc(doc: openArray[char]): string

int:

• init: proc int(a: PyStr | PyBytes): NimInt
• init: proc int(a: PyStr | PyBytes; base: int): NimInt
• init: template int(obj: HasIndex and HasIndex): NimInt
• init: template int(a: bool): NimInt
• init: template int(a: char): NimInt
• init: template int(f: float): NimInt
• init: template int(obj: HasIndex): NimInt
• init: template int(obj: HasTrunc): NimInt
• init: template int(i: SomeInteger): NimInt

intersection:

• set: proc intersection[H](self: PyFrozenSet[H]; o: SomePySet[H]): PyFrozenSet[H]
• set: proc intersection[H](self: PySet[H]; o: PyFrozenSet[H]): PyFrozenSet[H]
• set: proc intersection[H](self, o: PySet[H]): PySet[H]
• set: proc intersection[H; Self: SomePySet[H]; S](self: Self; s1: auto; s2: auto; x: varargs[S]): Self
• set: proc intersection[H; Self: SomePySet[H]; S: not PySet[H]](self: Self; s: S): Self

intersection_update:

• set: proc intersection_update[H; I: Iterable[H]](self: var SomePySet[H]; i: I)

IOBase:

• io: type IOBase

iPosCeil:

• mathutils: proc iPosCeil[I: SomeInteger](x: float): I

IsADirectoryError:

• oserr: object IsADirectoryError

isalnum:

• meth: proc isalnum(c: char): bool
• meth: proc isalnum(s: string): bool

isalpha:

• bytesmeth: proc isalpha(a`gensym42: PyBytes): bool
• strmeth: proc isalpha(a: PyStr): bool
• meth: proc isalpha(c: char): bool
• meth: proc isalpha(s: string): bool

isascii:

• bytesmeth: proc isascii(a: PyBytes): bool
• strmeth: proc isascii(a: PyStr): bool
• strmeth: proc isascii(a: Rune): bool
• meth: proc isascii(c: char): bool
• meth: proc isascii(s: string): bool

isatty:

• io: proc isatty(f: IOBase): bool
• isatty: proc isatty(fd: int): bool

isclose:

• n_math: proc isclose(a, b: SomeFloat; rel_tol = 1e-9; abs_tol = 0.0): bool

IS_CONTINUATION_BYTE:

• codecs: template IS_CONTINUATION_BYTE(ch: untyped): untyped

isdigit:

• bytesmeth: proc isdigit(a`gensym43: PyBytes): bool
• meth: proc isdigit(c: char): bool
• meth: proc isdigit(s: string): bool

isdisjoint:

• set: proc isdisjoint[H, S](self: SomePySet[H]; s: S): bool

isErr:

• errnoUtils: template isErr(E: untyped): bool

isErr0:

• errnoUtils: template isErr0(): bool

isfinite:

• isX: proc isfinite(x: SomeFloat): bool

isinf:

• isX: proc isinf(x: SomeFloat): bool

isInfinite:

• assertIsInfinite: template isInfinite(f: SomeFloat): bool

isinstance:

• oopFuncs: template isinstance(obj, class_or_tuple): bool

is_integer:

• floats: proc is_integer(self: float): bool
• getter: template is_integer(_: NimInt): bool

isLittleEndian:

• assertIsLittleEndian: proc isLittleEndian(): bool

islower:

• bytesmeth: proc islower(a: PyBytes): bool
• strmeth: proc islower(a: PyStr): bool

isNotFound:

• oserr: proc isNotFound(err: OSErrorCode): bool

isqrt:

• math: proc isqrt[I: SomeInteger](x: I): int
• n_math: proc isqrt(n: Natural): int
• n_math: proc isqrt[T: SomeFloat](x: T): int

isqrtPositive:

• n_math: proc isqrtPositive(n: Positive): int

isspace:

• bytesmeth: proc isspace(a`gensym41: PyBytes): bool

ISSPACE:

• common: proc ISSPACE(s: PyBytes; pos: int): bool
• common: proc ISSPACE(s: PyStr; pos: int): bool

isspace:

• strmeth: proc isspace(a: PyStr): bool
• meth: proc isspace(c: char): bool
• meth: proc isspace(s: string): bool

IsSpaceAt:

• common: type IsSpaceAt

issubclass:

• oopFuncs: template issubclass(obj, class_or_tuple): bool

issubset:

• set: proc issubset[H, S](self, o: SomePySet[H]; s: S): bool

issuperset:

• set: proc issuperset[H, S](self, o: SomePySet[H]; s: S): bool

istitle:

• bytesmeth: proc istitle(a: PyBytes): bool
• strmeth: proc istitle(a: PyStr): bool

istitleImpl:

• meth: template istitleImpl(a, isupper, islower: typed; iter, firstItemGetter)

isupper:

• bytesmeth: proc isupper(a: PyBytes): bool
• strmeth: proc isupper(a: PyStr): bool

isUtcZone:

• types: template isUtcZone(st: struct_time): bool

is_valid_wide_char:

• wchar_t: proc is_valid_wide_char(ch: wchar_t): bool

items:

• dict: proc items[K, V](self: PyDict[K, V]): PyDictItemView[K, V]
• dict: iterator items[K, V](self: PyDict[K, V]): (K, V)
• dict: template items(view: SomePyDictView): untyped
• iter_next: iterator items[T](self: PyIterator[T]): T
• iters: iterator items[T](x: Enumerate[T]): T
• iters: iterator items[T](x: Filter[T]): T
• iters: iterator items[T](x: Map[T]): T
• iters: iterator items[T](x: Reversed[T]): T
• iters: iterator items[T](x: Zip[T]): T
• list_decl: iterator items[T](self: PyList[T]): T
• pyrange: iterator items[T](rng: PyRange[T]): T
• set_decl: iterator items[H](self: SomePySet[H]): H
• collections_abc: iterator items[K, V](m: Mapping[K, V]): (K, V)
• pybytearray: iterator items(self: PyByteArray): int
• bytesimpl: iterator items(self: PyBytes): int
• strimpl: iterator items(self: PyStr): PyStr

iter:

• dict: proc iter[K, V](self: PyDict[K, V]): PyIterator[K]
• dict: iterator iter[K, V](self: PyDict[K, V]): K
• dict: template iter(view: SomePyDictView): untyped
• iter_next: proc iter[T](x: Iterable[T]): PyIterator[T]
• iter_next: proc iter[T](x: Iterator[T]): PyIterator[T]

Iterable:

• collections_abc: type Iterable

Iterator:

• collections_abc: type Iterator

join:

• bytesmeth: proc join[T](sep: PyBytes; a: openArray[T]): PyBytes
• strmeth: proc join[T](sep: PyStr; a: openArray[T]): PyStr
• meth: proc join[T](sep: char; a: openArray[T]): string
• meth: proc join[T, S](sep: S; a: openArray[T]): S

JsBigInt64Option:

• utils: const JsBigInt64Option

keys:

• dict: proc keys[K, V](self: PyDict[K, V]): PyDictKeyView[K]
• dict: iterator keys[K, V](self: PyDict[K, V]): K
• collections_abc: template keys[K, V](m: Mapping[K, V]): untyped

lambda:

• pysugar: template lambda(code: untyped): untyped

LC_ALL:

• localeutils: let LC_ALL

LC_CTYPE:

• localeutils: let LC_CTYPE

lcm:

• n_math: proc lcm[I: SomeInteger](x, y: I): I
• n_math: proc lcm[I: SomeInteger](x, y, z: I; args: varargs[I]): I

ldexp:

• math: proc ldexp(x: SomeFloat; i: int): float
• ldexp: proc ldexp[F: SomeFloat](frac: F; exp: int): F
• n_math: proc ldexp[F: SomeFloat](x: F; i: int): F
• n_math: proc ldexp[F: SomeFloat](x: F; i: int; exc: var ref Exception): F

len:

• dict: proc len(self: PyDict): int
• dict: proc len(view: SomePyDictView): int
• list: template len(self: PyList): int
• pyrange: template len[T](rng: PyRange[T]): int
• set_decl: proc len(self: SomePySet): int
• pybytearray: proc len(self: PyByteArray): int
• bytesimpl: proc len(self: PyBytes): int
• strimpl: proc len(self: PyStr): int
• strimpl: proc len(c: char): int

lgamma:

• math: proc lgamma[F: SomeFloat](x: F): F
• lgamma: proc lgamma[F: SomeFloat](x: F): F
• lgamma: proc lgamma[F: SomeFloat](x: F; res: var F): GammaError
• n_math: proc lgamma[F: SomeFloat](x: F): F

linesep:

• consts: let linesep

list:

• list: proc list[T](): PyList[T]
• list: proc list[T](iter: Iterable[T]): PyList[T]
• list: proc list[T](a: sink openArray[T]): PyList[T]
• list: proc list[T](x: sink seq[T]): PyList[T]
• list_decl: type list

ljust:

• bytesmeth: proc ljust(a: PyBytes; width: int; fillchar = ' '): PyBytes
• bytesmeth: proc ljust(a: PyBytes; width: int; fillchar: PyBytes): PyBytes
• strmeth: proc ljust(a: PyStr; width: int; fillchar = ' '): PyStr
• strmeth: proc ljust(a: PyStr; width: int; fillchar: PyStr): PyStr
• meth: proc ljust[S](a: S; width: int; fillchar: S = " "): S
• meth: proc ljust(a: string; width: int; fillchar = ' '): string

ln2_hi:

• common: const ln2_hi

ln2_lo:

• common: const ln2_lo

LocaleEncoding:

• io: const LocaleEncoding

localtime:

• struct_time_funcs: proc localtime(): struct_time
• struct_time_funcs: proc localtime(secs: float): struct_time
• struct_time_funcs: proc localtime(secs: int64): struct_time

log:

• math: proc log[F: SomeFloat](x: F): F
• math: proc log[F: SomeFloat](x, base: F): F
• n_math: proc log[F: SomeFloat](x: F): F
• n_math: proc log[F: SomeFloat](x, base: F): F

log10:

• math: proc log10[F: SomeFloat](x: F): F
• n_math: proc log10[F: SomeFloat](x: F): F

log1p:

• math: proc log1p[F: SomeFloat](x: F): F
• log1p: proc log1p[F: SomeFloat](x: F): F
• expm1_log1p: proc log1p[F: SomeFloat](x: F): F

log2:

• math: proc log2[F: SomeFloat](x: F): F
• n_math: proc log2[F: SomeFloat](x: F): F

long:

• longint: template long(a: bool): int
• longint: template long(a: char): BiggestInt
• longint: template long(a: string): BiggestInt
• longint: template long[T: SomeNumber](a: T): BiggestInt

LookupError:

• lkuperr: object LookupError

LOW:

• indices: const LOW

lower:

• bytesmeth: proc lower(a: PyBytes): PyBytes
• strmeth: proc lower(a: PyStr): PyStr

lstrip:

• strip: proc lstrip(self: PyBytes): PyBytes
• strip: proc lstrip(self: PyBytes; chars: PyBytes): PyBytes
• strip: proc lstrip(self: PyStr): PyStr
• strip: proc lstrip(self: PyStr; chars: PyStr): PyStr

Major:

• versionInfo: const Major

makeIterable:

• iterGen: template makeIterable(Typ)

maketrans:

• translate: proc maketrans(_: typedesc[PyBytes]; frm, to: PyBytes): PyBytes
• translate: macro maketrans(_: typedesc[PyStr]; mapOrLit: untyped): TranslateTable
• translate: template maketrans(_: typedesc[PyStr]; frm, to): StrTypedTranslateTable
• translate: template maketrans(_: typedesc[PyStr]; frm, to, skip): TranslateTable

MantissaDigits:

• consts: template MantissaDigits[F](): untyped

map:

• iters: proc map[T, R](function: proc (x: T): R; iterable: Iterable[T]): Map[T]
• iters: iterator map[T, R](function: proc (x: T): R; iterable: Iterable[T]): R

mapPathLike:

• io_abc: template mapPathLike[T](nexpr): T
• io_abc: template mapPathLike[T](s: PathLike[T]; nimProc): T

Mapping:

• collections_abc: type Mapping

mapRaiseGammaErr:

• err: proc mapRaiseGammaErr(err: GammaError)

math_is_error:

• n_math: proc math_is_error(x: SomeFloat; exc: var ref Exception): bool

max:

• pyrange: proc max[T](x: PyRange[T]): T

MAX_EXPONENT:

• consts: template MAX_EXPONENT[F](_: typedesc[F]): F

MAX_GAMMA_X:

• gammaXRange: template MAX_GAMMA_X[F](_: typedesc[F]): F

maxSafeInteger:

• consts: template maxSafeInteger[F](_: typedesc[F]): F

maxsize:

• sys: const maxsize

MAX_STIRLING:

• gamma: template MAX_STIRLING[F](_: typedesc[F]): F

MAX_SUBNORMAL_EXPONENT:

• consts: template MAX_SUBNORMAL_EXPONENT[F](_: typedesc[F]): F

MAX_UNICODE_val:

• wchar_t: const MAX_UNICODE_val

MaxWStrLen:

• utf8_codec: const MaxWStrLen

mbstate_t:

• wchar_t: object mbstate_t

min:

• pyrange: proc min[T](x: PyRange[T]): T

MIN_GAMMA_X:

• gammaXRange: template MIN_GAMMA_X[F](_: typedesc[F]): F

Minor:

• versionInfo: const Minor

MIN_SUBNORMAL_EXPONENT:

• consts: template MIN_SUBNORMAL_EXPONENT[F](_: typedesc[F]): F

mitems:

• list_decl: iterator mitems[T](self: PyList[T]): var T

mixinOrderOnFields:

• macro_utils: macro mixinOrderOnFields(lhs, rhs: typed; cmpOp; cmpStragy: static[CmpStragy] = csEq): bool

mktime:

• struct_time_funcs: proc mktime(t: struct_time): float
• struct_time_funcs: proc mktime(tup: struct_time_tuple): typeof(mktime do: bind struct_time struct_time(tm_year: 1900, tm_mon: 1, tm_mday: 1, tm_yday: 1, tm_isdst: -1))

modf:

• n_math: proc modf[F: SomeFloat](x: F): tuple[intpart: F, floatpart: F]

monotonic:

• measures: proc monotonic(): float

monotonic_ns:

• measures: proc monotonic_ns(): int64

MutableSequence:

• collections_abc: type MutableSequence

name:

• consts: const name

nan:

• n_math: const nan

NCodecInfo:

• ncodec: object NCodecInfo

newGenericsTree:

• funcSignature: proc newGenericsTree(): NimNode

newInt:

• nint_proto: template newInt(): NimInt

newNoEncTextIO:

• io: proc newNoEncTextIO(file: File; name: string; newline = DefNewLine): NoEncTextIOWrapper

newProc:

• funcSignature: proc newProc(name, generics: NimNode; params: openArray[NimNode] = [newEmptyNode()]; body = emptyn; procType = nnkProcDef; pragmas = emptyn): NimNode
• funcSignature: proc newProc(tup: tuple[name: NimNode, params: seq[NimNode]]; generics: NimNode; body = emptyn; procType = nnkProcDef; pragmas = emptyn): NimNode

newPyAsgnFrame:

• frame: proc newPyAsgnFrame(): PyAsgnFrame

newPyAsgnRewriter:

• frame: proc newPyAsgnRewriter(supportGenerics = false; dedentDoc = false): PyAsgnRewriter

newPyByteArray:

• pybytearray: proc newPyByteArray(): PyByteArray
• pybytearray: proc newPyByteArray(len: int): PyByteArray
• pybytearray: proc newPyByteArray(s: sink string): PyByteArray

newPyDict:

• dict_decl: proc newPyDict[K, V](x: int): PyDict[K, V]
• dict_decl: proc newPyDict[K, V](x: openArray[(K, V)] = []): PyDict[K, V]

newPyDictImpl:

• dict_decl: template newPyDictImpl[K, V](x: int): untyped
• dict_decl: template newPyDictImpl[K, V](x: openArray[(K, V)] = []): untyped

newPyFrozenSet:

• set_decl: proc newPyFrozenSet[H](initialSize = defaultInitialSize): PyFrozenSet[H]
• set_decl: proc newPyFrozenSet[H](h: HashSet[H]): PyFrozenSet[H]

newPyIterator:

• iter_next: proc newPyIterator[T](it: iterator (): T): PyIterator[T]

newPyList:

• list_decl: proc newPyList[T](len = 0): PyList[T]
• list_decl: proc newPyList[T](a: sink openArray[T]): PyList[T]
• list_decl: proc newPyList[T](s: sink seq[T]): PyList[T]

newPyListOfCap:

• list_decl: proc newPyListOfCap[T](cap = 0): PyList[T]

newPySet:

• set_decl: proc newPySet[H](initialSize = defaultInitialSize): PySet[H]
• set_decl: proc newPySet[H](h: HashSet[H]): PySet[H]

newTimer:

• n_timeit: proc newTimer(stmt: TimeitParam = NullStmt; setup: TimeitParam = NullStmt; timer = default_timer; number = default_number): Timer

newUnicodeDecodeError:

• unicode_err: proc newUnicodeDecodeError(codec: string; src: char; start, stop: int; reason: string): ref UnicodeDecodeError
• unicode_err: proc newUnicodeDecodeError(codec: string; src: string; start, stop: int; reason: string): ref UnicodeDecodeError

next:

• iter_next: proc next[T](self: PyIterator[T]): T

nextafter:

• math: proc nextafter[F: SomeFloat](x, y: F): F
• math: proc nextafter[F: SomeFloat](x, y: F; steps: int | uint64): F
• nextafter_step: proc nextafter(x, y: float; steps: int): float
• nextafter_step: proc nextafter(x, y: float; usteps: uint64): float
• nextafter_ulp: proc nextafter[F: SomeFloat](x, y: F): F
• nextafter_ulp: proc nextafter[F: SomeFloat](x, y: F; steps: int | uint64): F
• nextafter: proc nextafter[F](x, y: F): F
• nextafter_step: proc nextafter(x, y: float; usteps: uint64): float

nextImpl:

• iter_next: proc nextImpl[T](self: PyIterator[T]): Option[T]
• iter_next: proc nextImpl[T](self: PyIterator[T]; res: var T): bool

n_frexp:

• frexp: proc n_frexp[F: SomeFloat](x: F): (F, int)
• frexp: proc n_frexp[F: SomeFloat](x: F; e: var int): F

nimArrayAsList:

• list: converter nimArrayAsList[T; I](arr: array[I, T]): PyList[T]

NimHasBindOverloadSymBugForComplexPow:

• complex: const NimHasBindOverloadSymBugForComplexPow

NimInt:

• decl: type NimInt

nimint:

• init: template nimint(a): NimInt

NimVersionTuple:

• utils: const NimVersionTuple

Ninf:

• consts: const Ninf

n_ldexp:

• ldexp: proc n_ldexp[F: SomeFloat](x: F; i: int): F

noBackend:

• backendMark: template noBackend(backends: untyped; def)

noBackends:

• backendMark: template noBackends(backends: untyped; def)

noEmptySep:

• errHandle: template noEmptySep(sep)

NoEncTextIOBase:

• io: type NoEncTextIOBase

NoEncTextIOWrapper:

• io: type NoEncTextIOWrapper

noJsBackend:

• backendMark: template noJsBackend(def)

None:

• noneType: const None

noneStdstream:

• sys: converter noneStdstream(n: NoneType): typeof(stdout)

NoneType:

• noneType: type NoneType

noNimsBackend:

• backendMark: template noNimsBackend(def)

nonlocalAdd:

• frame: proc nonlocalAdd(mparser; ident: string)

nonlocalContains:

• frame: proc nonlocalContains(mparser; ident: string): bool

normalize:

• normalize: proc normalize[F: SomeFloat](x: F): (F, int)

norm_maxsplit:

• common: proc norm_maxsplit(maxsplit: int; str_len, sep_len: int): int
• common: template norm_maxsplit(maxsplit: int; str_len): int

NotADirectoryError:

• oserr: object NotADirectoryError

NotImplDirectives:

• nstrfptime: const NotImplDirectives

NotImplementedError:

• rterr: object NotImplementedError

noWeirdBackend:

• backendMark: template noWeirdBackend(def)

noWeirdTarget:

• oserr: template noWeirdTarget(def)

NullaryFunc:

• n_timeit: type NullaryFunc

NullStmt:

• n_timeit: const NullStmt

O_APPEND:

• consts: let O_APPEND

O_CLOEXEC:

• consts: let O_CLOEXEC

O_CREAT:

• consts: let O_CREAT

oct:

• strbltins: proc oct(a`gensym10: SomeInteger): PyStr

O_EXCL:

• consts: let O_EXCL

onceDeclInFrames:

• frame: proc onceDeclInFrames(ident: string; mparser): bool

open:

• io: template open(file: int; mode: static[string | char] = "r"; buffering: int = -1; encoding: string = DefEncoding; errors: string = DefErrors; newline: string | char = DefNewLine): untyped
• io: template open[S](file: PathLike[S]; mode: static[string | char] = "r"; buffering: int = -1; encoding: string = DefEncoding; errors: string = DefErrors; newline: string | char = DefNewLine): untyped
• open_close: proc open(path: PathLike; flags: int; mode = 0o000000000777; dir_fd = -1): int

openarray_Check:

• niter_types: template openarray_Check(x): bool

OpenarrayOrNimIter:

• niter_types: type OpenarrayOrNimIter

ord:

• bytesbltins: proc ord(a: PyBytes): int
• strbltins: proc ord(a: PyStr): int
• wchar_t: proc ord(wc: wchar_t): int

ord1:

• strbltins: proc ord1(a: PyStr): int

orderOnFields:

• macro_utils: macro orderOnFields[T](a, b: T; cmpOp): bool

O_RDONLY:

• consts: let O_RDONLY

O_RDWR:

• consts: let O_RDWR

orig_argv:

• sys: var orig_argv

osErrorMsgWithPath:

• oserr: template osErrorMsgWithPath(fp: PathLike; err: OSErrorCode): string
• oserr: template osErrorMsgWithPath(fp: PathLike; err: OSErrorCode; osErrorMsgCb): string

o_threshold:

• expm1: template o_threshold[F](): untyped

O_TRUNC:

• consts: let O_TRUNC

O_WRONLY:

• consts: let O_WRONLY

p1evl:

• polevl: proc p1evl[F](x: F; coef: openArray[F]; N = coef.high - 1): F

pairs:

• list_decl: iterator pairs[T](self: PyList[T]): (int, T)

pardir:

• consts: let pardir

parseBracketGenericParams:

• funcSignature: proc parseBracketGenericParams(generics: var NimNode; params: NimNode): NimNode

parseGenericParams:

• funcSignature: proc parseGenericParams(generics: var NimNode; params: NimNode): NimNode

parse_inf_or_nan:

• parse_inf_nan: proc parse_inf_or_nan(res: var float; ori_s: openArray[char]): bool
• parse_inf_nan: proc parse_inf_or_nan(ori_s: openArray[char]; res: var float): int

parsePyBody:

• tonim: proc parsePyBody(mparser; body: NimNode): NimNode
• tonim: template parsePyBody(body: NimNode): NimNode

parsePyBodyWithDoc:

• tonim: proc parsePyBodyWithDoc(mparser; body: NimNode): NimNode
• tonim: proc parsePyBodyWithDoc(mparser; body: NimNode; docNode: var NimNode): NimNode

parsePyFloat:

• parsefloat: proc parsePyFloat(a: openArray[char]; res: var BiggestFloat): int

parsePyStmt:

• tonim: proc parsePyStmt(mparser; statement: NimNode): NimNode

parserWithDefCfg:

• parserWithCfg: proc parserWithDefCfg(): PyAsgnRewriter

parseSignature:

• funcSignature: proc parseSignature(generics: var NimNode; signature: NimNode; deftype = ident"untyped"): tuple[name: NimNode, params: seq[NimNode]]

parseSignatureMayGenerics:

• pydef: proc parseSignatureMayGenerics(parser: var PySyntaxProcesser; generics: var NimNode; signature: NimNode; deftype = ident"untyped"): tuple[ name: NimNode, params: seq[NimNode]]

parseSignatureNoGenerics:

• funcSignature: proc parseSignatureNoGenerics(signature: NimNode; deftype = ident"untyped"): tuple[ name: NimNode, params: seq[NimNode]]

partition:

• bytesmeth: proc partition(a: PyBytes; sep: PyBytes): tuple[before, sep, after: PyBytes]
• strmeth: proc partition(a: PyStr; sep: PyStr): tuple[before, sep, after: PyStr]
• meth: proc partition[S](a: S; sep: S): tuple[before, sep, after: S]

pass:

• pysugar: template pass()

Patch:

• versionInfo: const Patch

PathLike:

• io_abc: type PathLike

pathrepr:

• io_abc: proc pathrepr(p: PathLike[PyBytes]): string
• io_abc: proc pathrepr(p: PathLike[PyStr]): string

pathsAsOne:

• oserr: proc pathsAsOne[T](a, b: PathLike[T]; sep = " -> "): string

pathsep:

• consts: let pathsep

perf_counter:

• measures: proc perf_counter(): float

perf_counter_ns:

• measures: proc perf_counter_ns(): int64

perm:

• math: proc perm(n: int): int
• math: proc perm(n, k: int): int
• n_math: proc perm(n: int): int
• n_math: proc perm(n, k: Natural): int

pi:

• n_math: const pi

Pinf:

• consts: const Pinf

platform:

• sys: const platform

platform.system:

• platformInfo: const platform.system

platform.version:

• platformInfo: proc platform.version(): string

polevl:

• polevl: proc polevl[F](x: F; coef: openArray[F]; N = coef.high): F

polExpd:

• polevl: macro polExpd[F](x: F; coef: untyped): F

polExpd0:

• polevl: macro polExpd0[F](x: F; rcoef: untyped): F

pop:

• dict: proc pop[K, V](self: PyDict[K, V]; key: K): V
• dict: proc pop[K, V](self: PyDict[K, V]; key: K; default: V): V
• list: proc pop[T](self: var PyList[T]): T
• list: proc pop[T](self: var PyList[T]; index: int): T
• set_decl: proc pop[H](self: var PySet[H]): H
• collections_abc: proc pop[T](ms: MutableSequence[T]; index = -1): T
• pybytearray: proc pop(mself: PyByteArray): int
• frame: proc pop(mparser)

popitem:

• dict: proc popitem[K, V](self: PyDict[K, V]): (K, V)

pow:

• complex: template pow[T](self: PyTComplex[T]; x: ComplexPowSecondParamType[T]; _: NoneType): PyTComplex[ T]
• complex: template pow[T](self: PyTComplex[T]; x: int): PyTComplex[T]
• complex: template pow[T](self: PyTComplex[T]; x: PyTComplex[T]): PyTComplex[T]
• complex: template pow[T](self: PyTComplex[T]; x: static Natural): PyTComplex[T]
• complex: template pow[T](self: PyTComplex[T]; x: T): PyTComplex[T]
• mathfunc: proc pow(base, exp, modulo: float): int
• mathfunc: proc pow(base: int; exp: Natural): int
• modPow: proc pow(base, exp, modulo: int): int
• ncomplex_pow: proc pow[T](a, b: Complex[T]): Complex[T]
• ncomplex_pow: proc pow[T](self: Complex[T]; i: int): Complex[T]
• ncomplex_pow: proc pow[T](self: Complex[T]; n: static Natural): Complex[T]
• math: proc pow[F: SomeFloat](x, y: F): F
• n_math: proc pow[F: SomeFloat](x, y: F): F

powu:

• ncomplex_pow: proc powu[T](self: Complex[T]; n: Natural): Complex[T]

PREPARE_CAP:

• common: template PREPARE_CAP(maxcount): int

prepareROErrno:

• errnoUtils: template prepareROErrno()

prepareRWErrno:

• errnoUtils: template prepareRWErrno()

print:

• print: macro print(data: varargs[untyped]): untyped

print_exc:

• n_timeit: proc print_exc(self: Timer; file: auto = nil)
• timeit: proc print_exc(self: Timer; file: auto = None)

process_time:

• measures: proc process_time(): float

prod:

• n_math: proc prod[T](iterable: Iterable[T]; start = 1.T): T

ptrdiff_t:

• ptr_types: type ptrdiff_t

push:

• frame: proc push(mparser)

pushDecorator:

• decorator: proc pushDecorator(mparser; item: NimNode)

Py_ADJUST_ERANGE1:

• pycore_pymath: proc Py_ADJUST_ERANGE1(x: float)

Py_ADJUST_ERANGE2:

• pycore_pymath: proc Py_ADJUST_ERANGE2(x, y: float)

pyasciiImpl:

• asciiImpl: proc pyasciiImpl(us: string): string

PyAsgnFrame:

• frame: type PyAsgnFrame

PyAsgnRewriter:

• frame: object PyAsgnRewriter

PyBool:

• pybool: type PyBool

pybool:

• pybool: converter pybool(x: bool): PyBool
• pybool: converter pybool[T](x: T): PyBool

PyByteArray:

• pybytearray: type PyByteArray

PyBytes:

• bytesimpl: type PyBytes

pybytes:

• bytesimpl: template pybytes[T](x: T): PyBytes

PyComplex:

• complex: type PyComplex

pycomplex:

• complex: template pycomplex[T](z: Complex[T]): PyTComplex[T]
• complex: template pycomplex[T](re: T; im = T(0)): PyTComplex[T]

Py_DecodeLocaleEx:

• fileutils: proc Py_DecodeLocaleEx(arg: cstring; wstr: var ptr wchar_t; wlen: ptr csize_t; reason: var cstring; current_locale: bool; errors: Py_error_handler): int

Py_DecodeUTF8Ex:

• utf8_codec: proc Py_DecodeUTF8Ex(orig_s: cstring; size: csize_t; wstr: var ptr wchar_t; wlen: ptr csize_t; reason: var cstring; errors: Py_error_handler): int

PyDedentDocString:

• parserWithCfg: const PyDedentDocString

PyDict:

• dict_decl: type PyDict

PyDictItemView:

• dict: object PyDictItemView

PyDictKeyView:

• dict: object PyDictKeyView

PyDictValueView:

• dict: object PyDictValueView

PyDictView:

• dict: object PyDictView

pydiscard:

• set: proc pydiscard[H](self: var PySet[H]; ele: H)

Py_ERROR_BACKSLASHREPLACE:

• pycore_fileutils: Py_error_handler.Py_ERROR_BACKSLASHREPLACE

Py_error_handler:

• pycore_fileutils: enum Py_error_handler

Py_ERROR_IGNORE:

• pycore_fileutils: Py_error_handler.Py_ERROR_IGNORE

Py_ERROR_OTHER:

• pycore_fileutils: Py_error_handler.Py_ERROR_OTHER

Py_ERROR_REPLACE:

• pycore_fileutils: Py_error_handler.Py_ERROR_REPLACE

Py_ERROR_STRICT:

• pycore_fileutils: Py_error_handler.Py_ERROR_STRICT

Py_ERROR_SURROGATEESCAPE:

• pycore_fileutils: Py_error_handler.Py_ERROR_SURROGATEESCAPE

Py_ERROR_SURROGATEPASS:

• pycore_fileutils: Py_error_handler.Py_ERROR_SURROGATEPASS

Py_ERROR_UNKNOWN:

• pycore_fileutils: Py_error_handler.Py_ERROR_UNKNOWN

Py_ERROR_XMLCHARREFREPLACE:

• pycore_fileutils: Py_error_handler.Py_ERROR_XMLCHARREFREPLACE

Py_FORCE_UTF8_FS_ENCODING:

• force_ascii_utils: const Py_FORCE_UTF8_FS_ENCODING

Py_FORCE_UTF8_LOCALE:

• force_ascii_utils: const Py_FORCE_UTF8_LOCALE

pyformat:

• format: macro pyformat(s: static[string]; argKw: varargs[untyped]): string

pyformatImplAux:

• format: proc pyformatImplAux(s: string; args: seq[NimNode]; kw: Kw): NimNode

PyFrozenSet:

• set_decl: type PyFrozenSet

Py_GetErrorHandler:

• pycore_fileutils: proc Py_GetErrorHandler(errors: string): Py_error_handler

Py_GetForceASCII:

• force_ascii_utils: proc Py_GetForceASCII(): bool

Py_GetLocaleEncoding:

• fileutils: proc Py_GetLocaleEncoding(): string

Py_IS_ALIGNED:

• codecs: template Py_IS_ALIGNED(p: cstring | ptr; a: typeof(ALIGNOF_SIZE_T)): bool

PyIterator:

• iter_next: type PyIterator

PyList:

• list_decl: type PyList

PyMajor:

• versionInfo: const PyMajor

py_math_isclose_impl:

• n_math: template py_math_isclose_impl(abs)

Py_mbrtowc:

• wchar_t: proc Py_mbrtowc(wc: PWc; src: cstring; n: csize_t; mbs: var mbstate_t): csize_t

Py_mbstowcs:

• wchar_t: proc Py_mbstowcs(dest: ptr wchar_t; src: cstring; n: csize_t): csize_t

PyMinor:

• versionInfo: const PyMinor

Py_normalize_encoding:

• encoding_norm: proc Py_normalize_encoding(encoding: string): string

PyPatch:

• versionInfo: const PyPatch

PyRange:

• pyrange: type PyRange

PyReleaseLevel:

• versionInfo: const PyReleaseLevel

pyrepr:

• strbltins: proc pyrepr(s: StringLike): PyStr

pyreprbImpl:

• reprImpl: proc pyreprbImpl(s: string): string

pyreprImpl:

• reprImpl: proc pyreprImpl(s: string; escape127: static[bool] = false): string

Py_ResetForceASCII:

• force_ascii_utils: proc Py_ResetForceASCII()

PySerial:

• versionInfo: const PySerial

pyset:

• set: proc pyset[H](): PySet[H]
• set: proc pyset[H](s: HashSet[H]): PySet[H]
• set: proc pyset[H](iterable: Iterable[H]): PySet[H]
• set: proc pyset[H](arr: openArray[H]): PySet[H]
• set: proc pyset[H](s: SomePySet[H]): PySet[H]

PySet:

• set_decl: type PySet

pysetLit:

• set: macro pysetLit(lit): PySet

Py_SetLocaleFromEnv:

• envutils: proc Py_SetLocaleFromEnv(category: cint): cstring

PySignatureSupportGenerics:

• parserWithCfg: const PySignatureSupportGenerics

pysince:

• version: proc pysince[R](ver: static[float | MajorMinorVersion]; defExpr, elseExpr: R): R
• version: macro pysince(major, minor: static int; def)
• version: template pysince[R](ver: MajorMinorVersion; defExpr, elseExpr: R): R

PySlice:

• pyslice: type PySlice

PySlice1:

• pyslice: type PySlice1

PyStr:

• strimpl: type PyStr

PySyntaxProcesser:

• types: type PySyntaxProcesser

PyTComplex:

• complex: type PyTComplex

Py_UCS1:

• char_decl: type Py_UCS1

Py_UCS2:

• char_decl: type Py_UCS2

Py_UCS4:

• char_decl: type Py_UCS4

Py_UNICODE_IS_SURROGATE:

• wchar_t: template Py_UNICODE_IS_SURROGATE(ch: wchar_t): bool

radians:

• n_math: proc radians[F: SomeFloat](x: F): F

raiseDomainErr:

• err: template raiseDomainErr()
• err: template raiseDomainErr(details: string)

raiseErrno:

• oserr: proc raiseErrno(errno: cint; additionalInfo = "")
• oserr: proc raiseErrno(additionalInfo = "")

raiseErrnoWithPath:

• oserr: proc raiseErrnoWithPath[T](p: PathLike[T])
• oserr: proc raiseErrnoWithPath[T](p: PathLike[T]; errno: cint)

raiseExcWithPath:

• oserr: proc raiseExcWithPath(p: PathLike)
• oserr: proc raiseExcWithPath(p: PathLike; errCode: OSErrorCode)
• oserr: proc raiseExcWithPath(fp: PathLike; exc: typedesc; err: OSErrorCode)
• oserr: proc raiseExcWithPath(fp: PathLike; exc: typedesc; err: OSErrorCode; additionalInfo: string)

raiseExcWithPath2:

• oserr: proc raiseExcWithPath2(src, dst: PathLike)

raiseFileExistsError:

• oserr: proc raiseFileExistsError(fp: PathLike)

raiseFileNotFoundError:

• oserr: proc raiseFileNotFoundError(fp: PathLike)
• oserr: proc raiseFileNotFoundError(fp: PathLike; err: OSErrorCode)

raiseOsOrFileNotFoundError:

• io: proc raiseOsOrFileNotFoundError(file: int)
• io: proc raiseOsOrFileNotFoundError[T](file: PathLike[T])

raiseRangeErr:

• err: template raiseRangeErr()
• err: template raiseRangeErr(details: string)

range:

• pyrange: proc range[T: SomeInteger](start, stop, step: T): PyRange[T]
• pyrange: template range[T: SomeInteger](stop: T): PyRange[T]
• pyrange: template range[T: SomeInteger](start, stop: T): PyRange[T]

rangeLen:

• mathutils: proc rangeLen[I](start, stop, step: I): I

RawIOBase:

• io: type RawIOBase

rb:

• bytesprefix: template rb(s): PyBytes

Rb:

• bytesprefix: template Rb(s): PyBytes

read:

• io: proc read(self: NoEncTextIOWrapper): PyStr
• io: proc read(self: NoEncTextIOWrapper; size: int): PyStr
• io: proc read(self: RawIOBase): PyBytes
• io: proc read(self: RawIOBase; size: int): PyBytes
• io: proc read(self: TextIOWrapper): PyStr
• io: proc read(self: TextIOWrapper; size: int): PyStr

readline:

• io: proc readline(self: NoEncTextIOWrapper): PyStr
• io: proc readline(self: NoEncTextIOWrapper; size: int): PyStr
• io: proc readline(self: RawIOBase): PyBytes
• io: proc readline(self: RawIOBase; size: Natural): PyBytes
• io: proc readline(self: TextIOWrapper): PyStr
• io: proc readline(self: TextIOWrapper; size: Natural): PyStr

real:

• complex: template real[T](z: PyTComplex[T]): T

real=:

• complex: template real=[T](z: PyTComplex[T]; _: T)

recReplaceSuperCall:

• class: proc recReplaceSuperCall(n: NimNode; defSupCls: NimNode; start = 0): NimNode

ReleaseLevel:

• versionInfo: const ReleaseLevel

remainder:

• math: proc remainder[F: SomeFloat](x, y: F): F
• n_math: proc remainder[F: SomeFloat](x: F; y: F): F

remove:

• set: proc remove[H](self: var PySet[H]; ele: H)
• collections_abc: proc remove[T](ms: MutableSequence[T]; x: T)
• pybytearray: proc remove(mself: PyByteArray; val: int)

removeprefix:

• bytesmeth: proc removeprefix(a: PyBytes; suffix: PyBytes): PyBytes
• strmeth: proc removeprefix(a: PyStr; suffix: PyStr): PyStr
• meth: proc removeprefix[S](a: S; suffix: S): S

removesuffix:

• bytesmeth: proc removesuffix(a: PyBytes; suffix: PyBytes): PyBytes
• strmeth: proc removesuffix(a: PyStr; suffix: PyStr): PyStr
• meth: proc removesuffix[S](a: S; suffix: S): S

repeat:

• n_timeit: template repeat(stmt: TimeitParam = NullStmt; setup: TimeitParam = NullStmt; timer = default_timer; repeat = default_repeat; number = default_number): seq[ float]
• n_timeit: template repeat(self: Timer; repeat = default_repeat; number = default_number): seq[float]
• timeit: template repeat(stmt: TimeitParam = NullStmt; setup: TimeitParam = NullStmt; timer = default_timer; repeat = pysince(3.7, 5, 3); number = default_number): PyList[float]
• timeit: template repeat(self: Timer; repeat = pysince(3.7, 5, 3); number = default_number): PyList[ float]

replace:

• bytesmeth: proc replace(a: PyBytes; sub, by: PyBytes | char): PyBytes
• bytesmeth: proc replace(a: PyBytes; sub, by: PyBytes | char; count: int): PyBytes
• strmeth: proc replace(a: PyStr; sub, by: PyStr | char): PyStr
• strmeth: proc replace(a: PyStr; sub, by: PyStr | char; count: int): PyStr
• meth: proc replace[S](a: S; sub, by: char): S
• meth: proc replace[S](a: S; sub, by: char; count: int): S
• meth: proc replace[S](a: S; sub, by: S): S
• meth: proc replace[S](a: S; sub, by: S; count: int): S
• replaceWithCount: proc replace(s: string; sub, by: char; count: Natural): string
• replaceWithCount: proc replace(s: string; sub, by: string; count: Natural): string

repr:

• complex: proc repr(z: PyTComplex): string
• dict: template repr(self: PyDict): string
• dict: template repr(view`gensym3: PyDictItemView): string
• dict: template repr(view`gensym1: PyDictKeyView): string
• dict: template repr(view`gensym2: PyDictValueView): string
• list: proc repr(ls: PyList[char]): string
• list: template repr[T](ls: PyList[T]): string
• list_decl: proc repr[T: set | string | openArray](self: PyList[T]): string
• pyrange: proc repr[T](rng: PyRange[T]): string
• pyslice: proc repr(self: PySlice): string
• set_decl: template repr(self: PyFrozenSet): string
• set_decl: template repr(self: PySet): string
• types: proc repr(st: struct_time): string
• init: proc repr(x: SomeFloat): string
• pybool: proc repr(self: PyBool): string
• bytesbltins: proc repr(x: PyBytes): string
• strbltins: proc repr(x: PyStr): string
• translate: proc repr(table: TranslateTable): string

reverse:

• list: proc reverse(self: var PyList)
• collections_abc: proc reverse(ms: MutableSequence)
• pybytearray: proc reverse(mself: PyByteArray)

reversed:

• iters: proc reversed[T](x: Sequence[T]): Reversed[T]
• iters: iterator reversed[T](x: Sequence[T]): T
• bytesbltins: proc reversed(s: PyBytes): PyBytes
• strbltins: proc reversed(s: PyStr): PyStr

rewriteRaise:

• pyraise: proc rewriteRaise(rStmt: NimNode): NimNode

rf:

• fstring: macro rf(pattern: string{lit}): PyStr

Rf:

• fstring: macro Rf(pattern: string{lit}): PyStr

rfind:

• bytesmeth: proc rfind(a: PyBytes; b: int; start = 0; end = len(a)): int
• bytesmeth: proc rfind(a: PyBytes; b: PyBytes; start = 0; end = len(a)): int
• strmeth: proc rfind(a: PyStr; b: PyStr; start = 0; end = len(a)): int
• meth: proc rfind[S; T](a: S; b: T; start = 0): int
• meth: proc rfind[S; T](a: S; b: T; start = 0; end: int): int

rfind1:

• meth: proc rfind1[S; T](a: S; b: T; start = 0): int
• meth: proc rfind1[S; T](a: S; b: T; start = 0; end: int): int

rGamma:

• gamma: proc rGamma[F: SomeFloat](x: F): F

rindex:

• bytesmeth: proc rindex(a: PyBytes; b: int; start = 0; end = len(a)): int
• bytesmeth: proc rindex(a: PyBytes; b: PyBytes; start = 0; end = len(a)): int
• strmeth: proc rindex(a, b: PyStr; start = 0; end = len(a)): int
• meth: proc rindex[S; T](a: S; b: T; start = 0): int
• meth: proc rindex[S; T](a: S; b: T; start = 0; end: int): int

rindex1:

• meth: proc rindex1[S; T](a: S; b: T; start = 0): int
• meth: proc rindex1[S; T](a: S; b: T; start = 0; end: int): int

rjust:

• bytesmeth: proc rjust(a: PyBytes; width: int; fillchar = ' '): PyBytes
• bytesmeth: proc rjust(a: PyBytes; width: int; fillchar: PyBytes): PyBytes
• strmeth: proc rjust(a: PyStr; width: int; fillchar = ' '): PyStr
• strmeth: proc rjust(a: PyStr; width: int; fillchar: PyStr): PyStr
• meth: proc rjust[S](a: S; width: int; fillchar: S = " "): S
• meth: proc rjust(a: string; width: int; fillchar = ' '): string

rLgamma:

• lgamma: proc rLgamma[F: SomeFloat](x: F): F

rounds:

• sys: template rounds(fi: typeof(float_info)): int

rpartition:

• bytesmeth: proc rpartition(a: PyBytes; sep: PyBytes): tuple[before, sep, after: PyBytes]
• strmeth: proc rpartition(a: PyStr; sep: PyStr): tuple[before, sep, after: PyStr]
• meth: proc rpartition[S](a: S; sep: S): tuple[before, sep, after: S]

rsplit:

• rsplit: proc rsplit(a: PyBytes; sep: PyBytes | char; maxsplit = -1): PyList[PyBytes]
• rsplit: proc rsplit(a: PyBytes; sep = None; maxsplit = -1): PyList[PyBytes]
• rsplit: iterator rsplit(a: PyBytes; sep = None; maxsplit = -1): PyBytes
• rsplit: proc rsplit(a: PyStr; sep = None; maxsplit = -1): PyList[PyStr]
• rsplit: proc rsplit(a: PyStr; sep: StringLike; maxsplit = -1): PyList[PyStr]
• rsplit: iterator rsplit(a: PyStr; sep = None; maxsplit = -1): PyStr

rsplit_whitespace:

• rsplit_whitespace: proc rsplit_whitespace(pystr: PyBytes; maxsplit = -1): PyList[PyBytes]
• rsplit_whitespace: proc rsplit_whitespace(pystr: PyStr; maxsplit = -1): PyList[PyStr]
• rsplit_whitespace: proc rsplit_whitespace[S](pystr: S; maxsplit = -1): PyList[S]

rstrip:

• strip: proc rstrip(self: PyBytes): PyBytes
• strip: proc rstrip(self: PyBytes; chars: PyBytes): PyBytes
• strip: proc rstrip(self: PyStr): PyStr
• strip: proc rstrip(self: PyStr; chars: PyStr): PyStr

runeAtPos:

• strimpl: proc runeAtPos(self: PyStr; pos: int): Rune

runeLenAt:

• strimpl: proc runeLenAt(self: PyStr; i: Natural): int

runes:

• strimpl: iterator runes(self: PyStr): Rune

RuntimeError:

• rterr: object RuntimeError

RuntimeWarning:

• warnings: Warning.RuntimeWarning

scipyGammaLn:

• lgamma: proc scipyGammaLn[F: SomeFloat](x: F): F

seek:

• io: method seek(f: IOBase; cookie: int64; whence = SEEK_SET): int64
• io: method seek(self: TextIOWrapper; cookie: int64; whence = SEEK_SET): int64

SEEK_CUR:

• io: const SEEK_CUR

SEEK_END:

• io: const SEEK_END

SEEK_SET:

• io: const SEEK_SET

sep:

• consts: let sep

Sequence:

• collections_abc: type Sequence

Serial:

• versionInfo: const Serial

set:

• set: proc set[H](): PySet[H]
• set: proc set[H](s: HashSet[H]): PySet[H]
• set: proc set[H](iterable: Iterable[H]): PySet[H]
• set: proc set[H](arr: openArray[H]): PySet[H]
• set: proc set[H](s: SomePySet[H]): PySet[H]
• set_decl: type set

setattr:

• attr: macro setattr(x; attr: static[string]; val)

setdefault:

• dict: proc setdefault[K, V](self: PyDict[K, V]; key: K; default = V.default)

setenvOverwrite:

• envutils: proc setenvOverwrite(key, val: string): bool

setErrno:

• errnoUtils: template setErrno(v: untyped)

setErrno0:

• errnoUtils: template setErrno0()

SET_EXP_MASK:

• consts: template SET_EXP_MASK[F](): untyped

setHighWord:

• common: template setHighWord(x: float; hi)

setLen:

• list_decl: proc setLen(self: PyList; len: Natural)

setlocale:

• localeutils: template setlocale(category; v: string): cstring

sin:

• math: proc sin[F: SomeFloat](x: F): F

sinh:

• math: proc sinh[F: SomeFloat](x: F): F

sinpi:

• sinpi: proc sinpi[F: SomeFloat](x: F): F

Sized:

• collections_abc: type Sized

sleep:

• sleep_impl: template sleep(s: int | float)

slice:

• pyslice: proc slice(stop: int): PySlice1
• pyslice: proc slice(start, stop: int): PySlice1
• pyslice: proc slice(start, stop: int; step: int): PySlice

SomePyDictView:

• dict: type SomePyDictView

SomePySet:

• set_decl: type SomePySet

SomeSet:

• set: type SomeSet

SomeSinglePyDictView:

• dict: type SomeSinglePyDictView

Some_struct_time:

• types: type Some_struct_time

Some_struct_time_tuple:

• types: type Some_struct_time_tuple

sort:

• list: proc sort[T](self: var PyList[T]; reverse = false)
• list: proc sort[T, K](self: var PyList[T]; key: proc (x: T): K; reverse = false)

sorted:

• list: proc sorted[T, K](x: not Sequence[T] and Iterable[T]; key: proc (x: T): K; reverse = false): PyList[T]
• list: proc sorted[T](self: PyList[T]; reverse = false): PyList[T]
• list: proc sorted[T, K](x: Sequence[T]; key: proc (x: T): K; reverse = false): PyList[T]

split:

• split: proc split(a: PyBytes; sep: PyBytes | char; maxsplit = -1): PyList[PyBytes]
• split: proc split(a: PyBytes; sep = None; maxsplit = -1): PyList[PyBytes]
• split: iterator split(a: PyBytes; sep: PyBytes | char; maxsplit = -1): PyBytes
• split: iterator split(a: PyBytes; sep = None; maxsplit = -1): PyBytes
• split: proc split(a: PyStr; sep = None; maxsplit = -1): PyList[PyStr]
• split: proc split(a: PyStr; sep: StringLike; maxsplit = -1): PyList[PyStr]
• split: iterator split(a: PyStr; sep = None; maxsplit = -1): PyStr
• split: iterator split(a: PyStr; sep: StringLike; maxsplit = -1): PyStr

splitlines:

• split: proc splitlines(self: PyBytes; keepends = false): PyList[PyBytes]
• splitlinesIter: iterator splitlines(self: PyBytes; keepends = false): PyBytes
• split: proc splitlines(self: PyStr; keepends = false): PyList[PyStr]
• splitlinesIter: iterator splitlines(self: PyStr; keepends = false): PyStr
• splitlinesIter: iterator splitlines[S](self: S; keepends = false): S

split_whitespace:

• split_whitespace: proc split_whitespace(pystr: PyBytes; maxsplit = -1): PyList[PyBytes]
• split_whitespace: iterator split_whitespace(pystr: PyBytes; maxsplit = -1): PyBytes
• split_whitespace: proc split_whitespace(pystr: PyStr; maxsplit = -1): PyList[PyStr]
• split_whitespace: iterator split_whitespace(pystr: PyStr; maxsplit = -1): PyStr
• split_whitespace: proc split_whitespace[S](pystr: S; maxsplit = -1): PyList[S]
• split_whitespace: iterator split_whitespace[S](pystr: S; maxsplit = -1): S

sqrt:

• math: proc sqrt[F: SomeFloat](x: F): F

SQRT_TWO_PI:

• consts: const SQRT_TWO_PI

startsWith:

• bytesmeth: proc startsWith(a: PyBytes; suffix: char): bool
• bytesmeth: proc startsWith(a: PyBytes; suffix: int): bool
• bytesmeth: proc startsWith[Suf: PyBytes | tuple](a: PyBytes; suffix: Suf; start: int): bool
• bytesmeth: proc startsWith[Suf: PyBytes | tuple](a: PyBytes; suffix: Suf; start, end: int): bool
• bytesmeth: proc startsWith[Tup: tuple](a: PyBytes; suffix: Tup): bool
• strmeth: proc startsWith(a: char; suffix: PyStr): bool
• strmeth: proc startsWith(a: PyStr; suffix: char): bool
• strmeth: proc startsWith[Suf: PyStr | tuple](a: PyStr; suffix: Suf; start: int): bool
• strmeth: proc startsWith[Suf: PyStr | tuple](a: PyStr; suffix: Suf; start, end: int): bool
• strmeth: proc startsWith[Tup: tuple](a: PyStr; suffix: Tup): bool
• meth: proc startsWith[S; Suf: S | tuple](a: S; suffix: Suf; start: int): bool
• meth: proc startsWith[S; Suf: S | tuple](a: S; suffix: Suf; start, end: int): bool
• meth: proc startsWith[S; Tup: tuple](a: S; suffix: Tup): bool
• meth: template startsWith[S](a: char; suffix: S): bool
• meth: template startsWith[S](a: S; suffix: char): bool

staticErrno:

• singleton_errno: var staticErrno

stderr:

• sys: var stderr

stdin:

• sys: var stdin

stdlibJsGamma:

• gamma: proc stdlibJsGamma[F: SomeFloat](x: F): F

stdlibJsLgamma:

• lgamma: proc stdlibJsLgamma[F: SomeFloat](x: F): F

stdout:

• sys: var stdout

StopIteration:

• iter_next: object StopIteration

str:

• strimpl: proc str(c: char): PyStr
• strimpl: proc str(self: PyStr): PyStr
• strimpl: proc str(a: Rune): PyStr
• strimpl: proc str(object = ""): PyStr
• strimpl: template str[O: object](o: O): PyStr
• strimpl: template str[T](a: T): PyStr

strerror:

• errnos: proc strerror(e: Errno): string

strftime:

• n_time: proc strftime(format: string): string
• time: proc strftime(format: PyStr): PyStr
• time: proc strftime(format: PyStr; st: Some_struct_time): PyStr
• nstrfptime: proc strftime(format: string; dt: DateTime): string
• strfptime: proc strftime[S](format: S; st: struct_time): S
• strfptime: proc strftime(format: string; st: Some_struct_time_tuple): string
• strfptime: proc strftime(format: string; st: struct_time): string

STRINGLIB_MUTABLE:

• common: const STRINGLIB_MUTABLE

StringLike:

• strimpl: type StringLike

strip:

• strip: proc strip(self: PyBytes): PyBytes
• strip: proc strip(self: PyBytes; chars: PyBytes): PyBytes
• strip: proc strip(self: PyStr): PyStr
• strip: proc strip(self: PyStr; chars: PyStr): PyStr

stripAsRange:

• stripOpenArray: proc stripAsRange(s: openArray[char]; leading: static[bool] = true; trailing: static[bool] = true; runes: openArray[Rune] = unicodeSpaces): tuple[first, last: int]

strIterImpl:

• strIter: template strIterImpl(it; strProc; start, stop): string

strptime:

• n_time: proc strptime(s: string): struct_time
• time: proc strptime(s: PyStr; format = DefaultTimeFormat): struct_time
• nstrfptime: proc strptime(dt: var DateTime; s: string; format_with_sp_asis: string)
• strfptime: proc strptime(s: string; f: string): struct_time

StrTypedTranslateTable:

• translate: type StrTypedTranslateTable

struct_time:

• converters: proc struct_time(tup`gensym0: struct_time_tuple): struct_time
• converters: proc struct_time(tup`gensym2: struct_time_tuple10): struct_time
• converters: proc struct_time(tup`gensym4: struct_time_tuple11): struct_time
• types: type struct_time

structTimeToDt:

• converters: proc structTimeToDt(st: struct_time; res: var DateTime)

struct_time_tuple:

• types: tuple struct_time_tuple

struct_time_tuple10:

• types: tuple struct_time_tuple10

struct_time_tuple11:

• types: tuple struct_time_tuple11

substr:

• bytesimpl: proc substr(self: PyBytes; start: int): PyBytes
• bytesimpl: proc substr(self: PyBytes; start, last: int): PyBytes
• strimpl: proc substr(self: PyStr; start, last: int): PyStr

suf--:

• common: proc suf--(i: var int): int

sumprod:

• math: template sumprod[T](p, q: (Iterable[T] and not openArray[T])): float
• math: template sumprod[T](p, q: ClosureIter[T]): float
• math: template sumprod[T](p, q: list[T]): float
• math: template sumprod[T](p, q: openArray[T]): float
• sumprod: proc sumprod[P, Q](p_it: ClosureIter[P]; q_it: ClosureIter[Q]): float
• sumprod: proc sumprod[P, Q](p: openArray[P]; q: openArray[Q]): float

symmetric_difference:

• set: proc symmetric_difference[H](self: PyFrozenSet[H]; o: SomePySet[H]): PyFrozenSet[H]
• set: proc symmetric_difference[H](self: PySet[H]; o: PyFrozenSet[H]): PyFrozenSet[H]
• set: proc symmetric_difference[H](self, o: PySet[H]): PySet[H]
• set: proc symmetric_difference[H; Self: SomePySet[H]; S](self: Self; s1: auto; s2: auto; x: varargs[S]): Self
• set: proc symmetric_difference[H; Self: SomePySet[H]; S: not PySet[H]](self: Self; s: S): Self

SystemExit:

• simperr: object SystemExit

tan:

• math: proc tan[F: SomeFloat](x: F): F

tanh:

• math: proc tanh[F: SomeFloat](x: F): F

tau:

• n_math: const tau

tell:

• io: proc tell(f: IOBase): int64

TextIOWrapper:

• io: type TextIOWrapper

time:

• measures: proc time(): float

timeit:

• pylib: template timeit(repetitions: int; statements: untyped): untyped
• n_timeit: template timeit(repetitions: int; statements: untyped)
• n_timeit: template timeit(stmt: TimeitParam = NullStmt; setup: TimeitParam = NullStmt; timer = default_timer; number = default_number): float
• n_timeit: template timeit(self: Timer; number = default_number): float

TimeitParam:

• n_timeit: type TimeitParam

TimeItUseTime:

• timeit: const TimeItUseTime

time_ns:

• measures: proc time_ns(): int64

Timer:

• n_timeit: type Timer

tinyF:

• expm1: template tinyF[F](): untyped

title:

• bytesmeth: proc title(a: PyBytes): PyBytes
• strmeth: proc title(a: PyStr): PyStr

toBool:

• pybool: template toBool[T](arg: T): bool

to_bytes:

• int_bytes: proc to_bytes(self: NimInt; length: int; byteorder: PyStr; signed = false): PyBytes
• int_bytes: proc to_bytes(self: NimInt; length: int; byteorder: static[PyStr] = str("big"); signed = false): PyBytes

to_chars:

• int_bytes: proc to_chars(self: NimInt; length: int; endianness: Endianness; signed = false): seq[ char]

tonim:

• tonim: macro tonim(body): untyped

toNimBool:

• pybool: converter toNimBool(self: PyBool): bool

toNimComplex:

• complex: template toNimComplex[T](z: PyTComplex[T]): Complex[T]

toNimIterator:

• niter_types: template toNimIterator[T](x): ClosureIter[T]

toNimSlice:

• pyslice: converter toNimSlice(s: PySlice1): Slice[int]

toNimStr:

• strimpl: proc toNimStr(self: PyStr): string

toNimString:

• pybytearray: proc toNimString(self: PyByteArray): string
• pybytearray: proc toNimString(self: var PyByteArray): var string
• bytesimpl: converter toNimString(self: PyBytes): string
• strimpl: converter toNimString(self: PyStr): string

toNimTable:

• dict_decl: proc toNimTable[K, V](self: PyDict[K, V]): var OrderedTable[K, V]

toPyBytes:

• pybytearray: converter toPyBytes(self: PyByteArray): PyBytes

toPyDict:

• dict: proc toPyDict[K, V](x: not openArray[(K, V)] and Iterable[(K, V)]): PyDict[K, V]
• dict: proc toPyDict[K, V](x: openArray[(K, V)]): PyDict[K, V]

toPyExpr:

• exprRewrite: proc toPyExpr(atm: NimNode): NimNode

toPyExprNoList:

• exprRewrite: proc toPyExprNoList(atm: NimNode): NimNode

toPyStr:

• strimpl: converter toPyStr(s: char): PyStr
• strimpl: converter toPyStr(s: Rune): PyStr
• strimpl: converter toPyStr(s: string): PyStr

toTuple:

• converters: converter toTuple(st: struct_time): struct_time_tuple

toWords:

• toWords: proc toWords(x: float): (uint32, uint32)
• toWords: proc toWords(x: float32): (uint16, uint16)

translate:

• translate: proc translate(self: PyBytes; table: NoneType; delete: PyBytes): PyBytes
• translate: proc translate(self, table: PyBytes): PyBytes
• translate: proc translate(self, table, delete: PyBytes): PyBytes
• translate: proc translate(s: PyStr; table: StrTypedTranslateTable): PyStr
• translate: proc translate(s: PyStr; table: TranslateTable): PyStr
• translate: proc translate(s: PyStr; table: TranslateTableABC): PyStr
• translate: proc translate[K: TranslateValType](s: PyStr; table: TypedTranslateTableABC[K]): PyStr

TranslateAction:

• translate: enum TranslateAction

translateEscape:

• translateEscape: proc translateEscape(pattern: string): string

translateEscapeWithErr:

• translateEscape: macro translateEscapeWithErr(pattern: string): string

TranslateTable:

• translate: type TranslateTable

TranslateTableABC:

• translate: type TranslateTableABC

TranslateTableVal:

• translate: object TranslateTableVal

TranslateValType:

• translate: type TranslateValType

True:

• pybool: const True

trunc:

• n_math: proc trunc(x: SomeFloat): int

truncate:

• io: proc truncate(self: IOBase): int
• io: proc truncate(self: IOBase; size: int64): int64
• truncate: proc truncate(file: CanIOOpenT; length: Natural)

tryHandleDecorator:

• decorator: proc tryHandleDecorator(mparser; statement: NimNode): bool

tryOsOp:

• oserr: template tryOsOp(p: PathLike; body)

TypedTranslateTableABC:

• translate: type TypedTranslateTableABC

TypeError:

• simperr: object TypeError

u:

• strprefix: proc u(s: static[string]{lit}): PyStr
• strprefix: proc u(a: char{lit}): PyStr

ulp:

• math: proc ulp[F: SomeFloat](x: F): F
• nextafter_ulp: proc ulp[F: SomeFloat](x: F): F

uname_release_major:

• platformInfo: proc uname_release_major(): string

uncheckedTruncToInt:

• trunc: proc uncheckedTruncToInt[I: SomeInteger](x: SomeFloat): I

UnicodeDecodeError:

• unicode_err: object UnicodeDecodeError

UnicodeError:

• unicode_err: object UnicodeError

unicodeSpaces:

• consts: const unicodeSpaces

union:

• set: proc union[H](self: PyFrozenSet[H]; o: SomePySet[H]): PyFrozenSet[H]
• set: proc union[H](self: PySet[H]; o: PyFrozenSet[H]): PyFrozenSet[H]
• set: proc union[H](self, o: PySet[H]): PySet[H]
• set: proc union[H; Self: SomePySet[H]; S](self: Self; s1: auto; s2: auto; x: varargs[S]): Self
• set: proc union[H; Self: SomePySet[H]; S: not PySet[H]](self: Self; s: S): Self

unpack:

• unpack: macro unpack(data: untyped; values: varargs[untyped]): untyped

unpackImpl:

• unpack: proc unpackImpl(data: NimNode; symbols: NimNode): NimNode

unpackImplRec:

• unpack: template unpackImplRec(data: NimNode; symbols: NimNode; res: var NimNode; receiver)

unpackWithLenImpl:

• unpack: proc unpackWithLenImpl(data: NimNode; len2unpack: Positive): NimNode

UNRELIABLE_FMA:

• fma: const UNRELIABLE_FMA

UnsupportedOperation:

• io: object UnsupportedOperation

update:

• dict: macro update(self: PyDict; kws: varargs[untyped])
• set: proc update[H; I: Iterable[H]](self: var SomePySet[H]; i: I)

upper:

• bytesmeth: proc upper(a: PyBytes): PyBytes
• strmeth: proc upper(a: PyStr): PyStr

UserWarning:

• warnings: Warning.UserWarning

UseSmallApprox:

• gamma: template UseSmallApprox[F](_: typedesc[F]): F

Utf8:

• fileutils: const Utf8

utf8_decode:

• codecs: proc utf8_decode[STRINGLIB_CHAR](inptr: var (cstring | ptr char); end: (cstring | ptr char); dest: ptr STRINGLIB_CHAR; outpos: var Py_ssize_t): Py_UCS4

values:

• dict: proc values[K, V](self: PyDict[K, V]): PyDictValueView[V]
• dict: iterator values[K, V](self: PyDict[K, V]): V
• collections_abc: iterator values[K, V](m: Mapping[K, V]): V

version:

• sys: const version

Version:

• version: const Version

version_info:

• sys: const version_info

warn:

• warnings: template warn(message: string; category: Warning = UserWarning; stacklevel = 1)

Warning:

• warnings: enum Warning

wchar_t:

• wchar_t: type wchar_t

whenDefErrno:

• loopErrno: template whenDefErrno(res: NimNode; errnoName: string; body): untyped

with:

• pywith: macro with(args: varargs[untyped]): untyped

wrapTuple:

• converters: template wrapTuple(sym)
• converters: template wrapTuple(sym, tupType)

write:

• io: proc write(self: NoEncTextIOWrapper; s: PyStr): int
• io: proc write(self: RawIOBase; s: PyBytes): int
• io: proc write(self: TextIOWrapper; s: PyStr): int

wu_import:

• inWordUtilsMapper: macro wu_import(moduleOrfromExpr)

ZeroDivisionError:

• aritherr: object ZeroDivisionError

zfill:

• bytesmeth: proc zfill(a: PyBytes; width: int): PyBytes
• strmeth: proc zfill(a: PyStr; width: int): PyStr
• meth: proc zfill(c: char; width: int): string
• meth: proc zfill(a: string; width: int): string

zip:

• iters: proc zip[A, B](it1: Iterable[A]; it2: Iterable[B]; strict = false): Zip[A]
• iters: iterator zip[A, B](it1: Iterable[A]; it2: Iterable[B]; strict = false): (A, B)
• iters: macro zip(iterables_or_strict: varargs[untyped]): Zip