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.

One caveat threads through this page. A builtin (or operator) that

returns a value works reliably when you bind it to a typed variable first,

then use that variable. Passing certain expressions inline to print(...)

can mis-render, because the inline result does not always carry its type to

the print site. When in doubt, write const r: T = f(...) then print(r).

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 list[T]; bind the result to a typed variable before printing, otherwise the inline print(sorted(...)) mis-renders:

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].

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.

Workarounds for the most common gaps:

• pow(a, b) - use the exponent operator a ** b, or math.pow from the math stdlib.
• round, divmod - implement inline (q = a // b, r = a % b) or reach for the math module.
• map, filter - use a comprehension: [f(x) for x in xs] and [x for x in xs if cond]. These are also the faster, more idiomatic Dragon form.
• tuple(xs) - build the tuple literal directly: (a, b, c).

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.