generic-functions.dua

nomangle int printf(str message, ...);

void print(int num) { printf("%d", num); }


// Case Basic generic function
// Outputs "i64 i32 X "

class X {}

void func<T>() {
    printf("%s ", typename(T));
}

int main()
{
    func<i64>();
    func<i32>();
    func<X>();
}


// Case Empty template parameters list
// Outputs "Hello"

void func<>() {
    printf("Hello");
}

int main()
{
    func<>();
}


// Case Calling a templated function multiple times
// Outputs "i32 i32 i32 "

void func<T>() {
    printf("%s ", typename(T));
}

int main()
{
    func<int>();
    func<int>();
    func<int>();
}


// Case Function with multiple template parameters
// Outputs "i32 i64"

void func<T, U>() {
    printf("%s %s", typename(T), typename(U));
}

int main()
{
    func<int, long>();
}


// Case Same function name with different template params
// Outputs "i32 i32 i64"

void func<T>() {
    printf("%s ", typename(T));
}

void func<T, U>() {
    printf("%s %s", typename(T), typename(U));
}

int main()
{
    func<int>();
    func<int, long>();
}


// Case Templated method
// Outputs "i32 123"

class X
{
    int num = 123;

    void func<T>() {
        printf("%s %d", typename(T), num);
    }
}

int main()
{
    X x;
    x.func<int>();
}


// Case Templated function reference
// Outputs "i32 i64 "

void func<T>() {
    printf("%s ", typename(T));
}

int main()
{
    var x = func<int>;
    var y = func<long>;

    x();
    y();
}


// Case Templated method reference
// Outputs "i32 i64 "

class Z
{
    void func<T>() {
        printf("%s ", typename(T));
    }
}

int main()
{
    Z z;
    var x = z.func<int>;
    var y = z.func<long>;

    x(z);
    y(z);
}


// Case Using the template arg as parameter type
// Outputs "B3 L4"

void print(byte b) { printf("B%d " , (int)b); }
void print(long l) { printf("L%lld", l); }

void func<T>(T t) {
    print(t);
}

int main()
{
    func<byte>(3);
    func<long>(4);
}


// Case Templated function implicit casting
// Outputs "Hello"

void func<T>(T t) {
    printf("Hello");
}

int main()
{
    func<byte>(1);
}


// Case Templated function overloading
// Outputs "i32 i64"

void func<T>(int i) {
    printf("i32 ");
}

void func<T>(long l) {
    printf("i64");
}

int main()
{
    func<byte>(1);
    func<byte>(1L);
}


// Case Redefinition of the templated function with the same signature
// Panics

void func<T>(int i) {
    printf("i32 ");
}

void func<T>(int i) {
    printf("i32 ");
}

int main()
{
    func<byte>(1);
    func<byte>(1);
}


// Case Nested templated function call
// Outputs "i16 i32 i64 "

void func<T>(T t)
{
    if (t == 1)
        func<i32>(2);
    else if (t == 2)
        func<i16>(3);
    printf("%s ", typename(T));
}

int main()
{
    func<i64>(1);
}


// Case Calling a templated method without referencing self
// Outputs "i32"

class X
{
    void a() {
        b<int>();
    }

    void b<T>() {
        printf("%s", typename(T));
    }
}

int main()
{
    X x;
    x.a();
}


// Case Templated and non-templated functions with the same name
// Outputs "Non-templated\nTemplated\n"

void func() {
    printf("Non-templated\n");
}

void func<T>() {
    printf("Templated\n");
}

int main()
{
    func();
    func<int>();
}


// Case Repeating a template parameter
// Panics

void func<T, T>() { }

int main() { }


// Case Referencing an unreachable variable 1
// Panics

class X<T>
{
    void f<T>() {
        int num = 3;
        self.t<int>();
    }

    void t<T>() {
        int num = 3;
        func<int>();
    }
}

void func<T>() {
    int x = num;
}

int main()
{
    X<int> x;
    x.f<int>();
}


// Case Returning the template type
// Outputs "5"

T func<T>(T val)
{
    return val;
}

int main()
{
    printf("%d", func<int>(5));
}

// Case Referencing an unreachable variable 2
// Panics

class X<T>
{
    void func<T>() {
        // This should panic
        int i = num;
    }
}

void func()
{
    int num = 3;
    X<int> x;
    x.func<int>();
}

int main()
{
    func();
}


// Case Referencing non-existent variables in a templated function, but not instantiating it

void func<T>()
{
    x = y;
    z = 3;
}

int main()
{

}