RFC: Assert statements should be Pure, performance issue

[cduck]

Two kinds of assertion:

• Compile-time assertion (during fold) - this should be pure
• Runtime assertion

Maybe add a new statement for this in the debug dialect to represent compile-time assertions that are ignored during runtime.

Motivation: Assertions inside functions involved in functional control flow prevent fold from happening (assert is not pure). This significantly affects the performance of the compiler.

Co-written with @weinbe58.

[Roger-luo]

can we have an example of compile-time assertion? what is this? I don't think we have compile-time assertion. @weinbe58

[cduck]

Example below. When I use assert, I don't intend it to be checked during runtime, I expect inline and constant propagation to simplify assert statements to either assert True or assert False and then a pass that cleans up the assert statements will check the condition, deleting if True and raising a compiler error if False.

@kernel
def my_func(arr):
    ...
    compile_time_assert len(arr) == 5
    ....

@kernel
def main():
    my_func([1,2,3,4,5])  # Inline succeeds
    my_func([1])  # Compiler error after inline pass

[Roger-luo]

but if your program behaviour relays on constant propagation this sounds like a problem should be address by type system instead of assertion. For example, in the above example, you should write

@kernel
def my_func(arr: IList[Int, Literal(5)]):
    ...

which will give the compile error you want.

[cduck]

Fair. My use cases can be handled by type validation. Here are my use cases that I want to make sure to catch errors if the user provides the wrong argument:

@kernel
def zip_list_strict(arr_list):
    list_cnt = len(arr_list)
    list_len = len(arr_list[0])

    def outer_map(i):
        def inner_map(j):
            assert len(arr_list[j]) == list_len, "mismatched sublist lengths"
            return arr_list[j][i]

        return Map(inner_map, range(list_cnt))

    return Map(outer_map, range(list_len))

@kernel
def my_func(list1, list2):
    assert len(list1) == len(list2)
    ...

How can I do the following?

@kernel
def zip_list_strict(arr_list: IList[IList[Any, <type var 2>], <type var 1>]) -> IList[IList[Any, <type var 1>], <type var 2>]:
    ...

@kernel
def my_func(list1: IList[Any, <type var>], list2: IList[Any, <type var>]):
    ...