Compiler directives

[ss2165]

Let's use this issue to collect ideas for compiler directives in guppy.

I propose using optional arguments to @guppy decorators to collect compiler directives.

Some will be directives for the guppy compiler, some will be passed down. Those passed down can be collected using reserved keys in hugr metadata. We could even opaquely include LLVM directives?

Examples:

@guppy(inline=True)
def foo(...):
    pass

# add order edges to preserve ordering between operations (what about nested operations?)
@guppy(preserve_order=True)
def bar(...):
   pass

# disallow non-unitary operations
@guppy(unitary=True)
def circ(qs: array<qubit>):
    pass

Related issues:

• @unitary decorator for guppy #361
• "verbatim" functions #178
• User overloadable unitary modifiers (dagger, control, power) #585

[acl-cqc]

I'm proposing something like

@guppy(only_uses=[result, qalloc_state])
def foo(...):

the "list" is probably really a set, and the rule is that functions with such an annotation can make calls only to functions also with that annotation and the same or fewer things on RHS. (For example, the functions result, qalloc and qfree, use the thing above). Other possible names: resources, globals (we will eventually allow user-defined globals to be elements of the list), effects (type theoretic), tokens (eventual hugr implementation so not sure we want to make that public).

Functions without the annotation can call anything.

[ss2165]

I think "use" is too generic, it is a specific kind-of-thing that is being used.

I like "effects", if it ain't broke don't fix it. People will get used to it soon enough and our type fans will be happy.

the "list" is probably really a set
why not use a set then?