internal.builtin

function getattr

getattr(obj, attr: Literal[str], default, typ: type = NoneType)

@overload

getattr(obj, attr: Literal[str], type: type = NoneType)

function id

id(x)

function print

print(*args, sep: str = " ", end: str = "\n", file = None, flush: bool = False)

function input

input(prompt: str = "")

function min

min(*args, key = None, default = None)

function max

max(*args, key = None, default = None)

function len

len(x)

function iter

iter(x)

function abs

abs(x)

function hash

hash(x)

function ord

ord(character: str)

function divmod

divmod(a, b)

function chr

chr(codepoint: int)

function next

next(g: Generator[T], default: Optional[T] = None, T: type)

function any

any(x: Generator[T], T: type)

function all

all(x: Generator[T], T: type)

function zip

zip(*args)

function filter

filter(f: CallableTrait[T, bool], x: Generator[T], T: type)

function map

map(f, *args)

function enumerate

enumerate(x, start: int = 0)

function echo

echo(x)

function reversed

reversed(x)

function round

round(x, ndigits = None)

function sum

sum(x, start = 0)

function repr

repr(x)

function bin

bin(n)

function oct

oct(n)

function hex

hex(n)

function format

format(value, format_spec: str = "")

function pow

pow(base: float, exp: float)

@overload

pow(base: int, exp: int, mod: Optional[int] = None)

class Int

@extend

class Int[N]

Extends Int · View complete class API →

class UInt

@extend

class UInt[N]

Extends UInt · View complete class API →

class float

@extend

class float

Extends float · View complete class API →

class complex

@extend

class complex

Extends complex · View complete class API →

class float32

@extend

class float32

Extends float32 · View complete class API →

class float16

@extend

class float16

Extends float16 · View complete class API →

class bfloat16

@extend

class bfloat16

Extends bfloat16 · View complete class API →

class complex64

@extend

class complex64

Extends complex64 · View complete class API →

function cast

@inline

cast(U: type, obj)