Precomputed factorial at compile-time

[DayDun]

fn factorial_comptime(n: Int) -> Int:
    @parameter
    fn gen_table() -> StaticIntTuple[21]:
        var tbl = StaticIntTuple[21]()
        var n = 1
        var i = 0
        while i < 21:
            tbl[i] = n
            i += 1
            n *= i
        return tbl
    
    alias table = gen_table()
    debug_assert(0 <= n <= 20, "input value causes an overflow")
    return table[n]

Computes the lookup table at compile-time, as opposed to at coding-time 🙃 like the standard library currently does:

@always_inline
fn factorial(n: Int) -> Int:
    """Compute the factorial of the integer.

    Args:
      n: The input value.

    Returns:
      The factorial of the input.
    """
    let table = StaticIntTuple[21](
        1,
        1,
        2,
        6,
        24,
        120,
        720,
        5040,
        40320,
        362880,
        3628800,
        39916800,
        479001600,
        6227020800,
        87178291200,
        1307674368000,
        20922789888000,
        355687428096000,
        6402373705728000,
        121645100408832000,
        2432902008176640000,
    )
    debug_assert(0 <= n <= 20, "input value causes an overflow")
    return table[n]

Could also compute the overflow bounds at compile-time, which would actually even be a bit practical since Int changes size based on the target. But I don't think the standard library has any convenience functions for overflowing arithmetic yet, so I didn't bother.

[lattner]

Wow, nice!