Built-in Functions

The functions on this page are always in scope - no import needed. They are the workhorses you reach for every day: printing, measuring length, looping over indices, converting between types, and inspecting values. Dragon mirrors Python's names and signatures wherever the typed, compiled model allows, so most of what you know from Python transfers directly.

Every entry in this appendix was verified by compiling and running it against the Dragon compiler. Where a Python builtin is recognized by the grammar but does not yet have a working implementation, it is listed in Not yet available with the exact error - so you always know what is real.

Output and input

print("hello")           # hello
print(1, 2, 3)           # 1 2 3

const name: str = input("Name: ")   # reads a line after printing "Name: "
print("Hi " + name)

Length and ranges

print(len("abc"))        # 3
print(len([1, 2, 3]))    # 3

for i in range(5) {
    print(i)             # 0 1 2 3 4
}

range is an iteration construct, not an annotation type - write for i in range(n), not r: range = range(n). To materialize the values into a list, use a comprehension: const xs: list[int] = [i for i in range(5)].

Type conversion

print(int("17"))         # 17
print(int(3.9))          # 3
print(float("2.5"))      # 2.5
print(str([1, 2, 3]))    # [1, 2, 3]

bytes("text", "utf-8") is not supported - the two-argument

string-encode form errors. Build bytes via the bytes(list[int]) form or the

io / encoding stdlib instead.

Numeric helpers

print(abs(-5))           # 5
print(min(3, 1))         # 1
print(max([4, 2, 9]))    # 9
print(sum([1, 2, 3, 4])) # 10

Sequence operations

sorted and reversed return a new list[T]:

const s: list[int] = sorted([3, 1, 2])
print(s)                 # [1, 2, 3]

const r: list[int] = reversed([1, 2, 3])
print(r)                 # [3, 2, 1]

enumerate and zip are used as loop drivers:

for i, v in enumerate([10, 20, 30]) {
    print(i, v)          # 0 10  /  1 20  /  2 30
}

for a, b in zip([1, 2, 3], [10, 20, 30]) {
    print(a, b)          # 1 10  /  2 20  /  3 30
}

print(any([False, True, False]))   # True
print(all([True, False]))          # False

Introspection

print(repr("hi"))        # 'hi'
print(repr(42))          # 42
print(chr(65))           # A
print(ord("A"))          # 65

isinstance works for class hierarchies, checking against a base type:

class Animal {
    name: str
    def(n: str) { self.name = n }
}
class Dog(Animal) {
    def(n: str) { super(n) }
}

const d: Animal = Dog("Rex")
print(isinstance(d, Animal))   # True

isinstance against builtin primitive types returns False.

isinstance(5, int), isinstance("x", str), and isinstance(3.0, float)

all return False today - it is reliable only for user-defined class

hierarchies, and only when the runtime value matches (or subclasses) the

type being tested against the declared base.

Number-base formatting

print(hex(255))          # 0xff
print(oct(8))            # 0o10
print(bin(5))            # 0b101

Collection constructors

const s: set[int] = set([1, 2, 2, 3])
print(s)                 # {1, 2, 3}

const d: dict[str, int] = dict()
print(len(d))            # 0

list() always yields list[Any]. It cannot be assigned to a

concretely-typed binding such as list[int] (you get

cannot assign 'list[Any]' to variable of type 'list[int]'). For a typed

empty list use the literal: const xs: list[int] = []. The list(iterable)

copy form is likewise not yet wired - copy with a comprehension,

[x for x in src].

Numeric and functional builtins

These mirror Python's names in the forms the typed model supports. A few carry a caveat worth knowing, noted in the table.

Not yet available

These names are recognized by the grammar (they highlight as builtins) but do not compile-and-run today. Each was tested; the error is shown so you know exactly where the boundary is.

The dynamic-reflection names (eval, exec, compile, getattr, setattr, vars, globals, locals) are excluded on purpose: they are the dynamic crutches Dragon rejects, not gaps waiting to be filled. A comprehension ([f(x) for x in xs], [x for x in xs if cond]) is still the idiomatic and faster form even though map/filter now work.

At a glance

For the operators (**, //, in, not in, comparison, bitwise) see the operators appendix; for keywords see the keywords appendix; and for everything behind an import see the stdlib appendix.