Static/compile time function arguments

[ss2165]

Guppy typically exists inside hosted Python. We have the py expression to allow compile-time known values to be captured from the outer python scope. So for instance to generate a statically sized array:

N = guppy.nat_var("N")

@guppy
def foo(ar: array[qubit, N] @owned): ...

n = 2

@guppy
def main() -> None:
    foo(array(qubit() for _ in range(py(n)))

However, there are many cases where you want the guppy function to be python-parametric - an example being string formatting in result tags where I want to call a function with a specific thing to add to my static result tag.

There are few ways to achieve this, but taking inspiration from Zig comptime I suggest compile-time-only arguments to functions would be a neat way.

So that example would look something like:

@guppy
def print_numbered_result(i: int @comptime, value: int):
    result("c" + str(i)), value)

index = 1
@guppy
def main() -> None:
    q1, q2 = qubit(), qubit()
    print_numbered_result(0, measure(q1))
    print_numbered_result(py(index), measure(q2)) 

here any expression over comptime arguments can be evaluated as pure python

Open to alternatives on syntax for this, e.g.:

@guppy
def print_numbered_result(i: Literal[int], value: int): ...

[jake-arkinstall]

I realise this is pinpointing on the example rather than the overall concept of compile time function arguments, but:

Might there be a possibility for alternatives to result that take additional arguments and formats them in an implementation-defined manner?

e.g.:

@guppy
def example() -> None:
    qs = ...
    x = 3.14159
    while some_condition(qs):
        float_tagged_result("thing", x, measure_reset(qs[0]))
        x = sqrt(x)

where it accepts an additional runtime value to help build the tag?

(I chose a while loop because a for loop over a qubit array would be doable with array printing when it lands, but a nondeterministic number of prints would be harder)

[ss2165]

the result tag has to be statically known so can't take runtime parameters

[jake-arkinstall]

That's if it goes through result().

I'm proposing an alternative function that is invoked at runtime and given a string prefix (or format string) and e.g. an integer, such that formatting is done by the implementation itself. This way one could provide a runtime value such as a loop iteration index.

[jake-arkinstall]

OTOH this might not be necessary. I was thinking that modifying the tag would be needed, but this assumes one interprets results as individual entities. That needn't be the case. One could construct a sequence of result prints that get reinterpreted and combined later on.

A trivial example is that the loop iteration index is itself a result, not part of the tag. Values within the loop are output as they already are. If dummy results are emitted before and after the loop, the values between them could be parsed and combined with inferred structure.

I would not be surprised if this permits fully structured outputs. It would require a helper library for emitting the structure tokens and reparsing it, but I think this could be a standalone library and needn't be a guppy concern in itself.

As such, I think this thread of mine can be ignored.

OTOH, I would like to draw attention to one aspect, which is that compile time values have limitations in this new dynamic regime, and that a user that isn't fully aquatinted with the concepts of compile time and runtime contexts in guppy may get confused by examples such as printing compile time integers if we cannot offer the same for runtime through some form or another too.