Numeric literals

There are no numeric literal suffixes. Its type is always deduced from its context.

In inferred variable type assignments numeric literals are i64 for integers and f64 for floats.

func main():
    a = 1  # 1 is i64
    b = 1.0  # 1.0 is f64

Comparisions and arithmetics makes numeric literals the same type as the other value’s type.

func main():
    a: u64 = 1  # 1 is u64
    b: u8 = 1 + 1  # 1 and 1 are u8
    c = u8(1 + 1)  # 1 and 1 are u8
    d = u8(1 + i16(-1))  # 1 and -1 are i16

    if a == 2:  # 2 is u64
        pass

    if (1 + 3) * a == 8:  # 1, 3 and 8 are u64
        pass

    if (1 + 3) * 2 == 8:  # 1, 3, 2 and 8 are i64
        pass

    if u8(1 + 3) == 8:  # 1, 3 and 8 are u8
        pass

Passing numeric literals to functions makes them the same type as the parameter types. First defined matching function is called.

func foo(a: i16, b: f32):
    pass

# bar 1
func bar(a: u8) -> i16:
    return i16(a)

# bar 2
func bar(a: u16) -> i32:
    return i32(a)

func main():
    foo(-44, 3.2)  # -44 is i16 and 3.2 is f32

    if bar(1 + 3) == 8:  # 1 and 3 are u8 and 8 is i16 (bar 1)
        pass

    if bar(1 + u16(3)) == 8:  # 1 and 3 are u16 and 8 is i32 (bar 2)
        pass

    if bar(1 + 3) == i32(8):  # 1 and 3 are u16 and 8 is i32 (bar 2)
        pass