# Copyright (C) 2022-2023 Exaloop Inc. <https://exaloop.io>
@__internal__
class __internal__:
pass
class __magic__:
@tuple
@__notuple__
class bool:
class byte:
class int:
MAX = 9223372036854775807
class float:
MIN_10_EXP = -307
class float32:
MIN_10_EXP = -37
class NoneType:
class type:
class Function[T, TR]:
class Callable[T, TR]:
class Ptr[T]:
cobj = Ptr[byte]
class Generator[T]:
class Optional:
T: type = NoneType
class Int[N: Static[int]]:
class UInt[N: Static[int]]:
class pyobj:
p: Ptr[byte]
class str:
ptr: Ptr[byte]
len: int
class Array:
ptr: Ptr[T]
T: type
@extend
def __new__(obj):
function = Function
class Ref[T]:
class Union[TU]:
# compiler-generated
def __new__(val):
TU
class Function:
@llvm
def __new__() -> Function[T, TR]:
ret ptr null
# dummy
class TypeVar[T]: pass
class ByVal: pass
class ByRef: pass
class Tuple: pass
class ClassVar[T]:
class RTTI:
id: int
class ellipsis:
def __new__() -> ellipsis:
return ()
Ellipsis = ellipsis()
class __array__:
def __new__(sz: Static[int]) -> Array[T]:
@dataclass(init=True)
class Import:
path: Static[str]
name: str
def __new__(P: Static[str], name: str) -> Import[P]:
return (name, )
def __ptr__(var):
def staticlen(obj):
def compile_error(msg: Static[str]):
def isinstance(obj, what):
@__attribute__
def overload():
def hasattr(obj, attr: Static[str], *args, **kwargs):
"""Special handling"""
@overload
def hasattr(obj, attr: Static[str]):
def getattr(obj, attr: Static[str]):
def setattr(obj, attr: Static[str], what):
def tuple(iterable):
def super():
def superf(*args):
def __realized__(fn, args):
def statictuple(*args):
return args
def __has_rtti__(T: type):
# class Type[T]: ...
#(init=False, repr=False, eq=False, order=False, hash=False, pickle=False, python=False, gpu=False, container=False)
class NamedTuple:
args: T
N: Static[int] # name cache ID
# todo)) nicer way to express type(())
def __new__(args: T = (), T: type) -> NamedTuple[0, T]:
return ((), )
def __new__(args: T, N: Static[int], T: type) -> NamedTuple[N, T]:
return (args, )
def __getitem__(self, key: Static[str]):
return getattr(self, key)
def __keys__(self):
return __internal__.namedkeys(N)
def __repr__(self):
keys = self.__keys__()
values = [v.__repr__() for v in self.args]
s = ', '.join(f"{keys[i]}: {values[i]}" for i in range(len(keys)))
return f"({s})"
class Partial:
args: T # format: (agr1, arg2, ..., (star_args...))
kwargs: K
F: Static[str] # function
M: Static[str] # mask
T: type # Tuple
K: type # NamedTuple
def __new__(args: T, kwargs: K, F: Static[str], M: Static[str], T: type, K: type) -> Partial[F, M, T, K]:
# __static_print__(args)
# __static_print__(kwargs)
return (args, kwargs)
return __magic__.repr_partial(self)
