Clay: A new language for generic programming (based on LLVM)(tachyon.in)

    record Square {
    side : Double;
    }

    record Circle {
        radius : Double;
    }

    variant Shape = Square | Circle;

    procedure show;
    overload show(x:Square) { println("Square(", x.side, ")"); }
    overload show(x:Circle) { println("Circle(", x.radius, ")"); }

    interface Shape {
        abstract procedure show(self);
    }

    record Square : Shape  {
        side : Double;
        show(self) { println("Square(", self.side, ")"); }
    }

    record Circle: Shape {
        radius : Double;
        show(self) { println("Circle(", self.radius, ")"); }
    }
    variant Shape = Square | Circle;

    procedure foo;
    
    [T1,T2]
    overload foo(a:T1, b:T2) {
        // by default, convert both arguments
        // to the type of first argument.
        foo(T1(a), T1(b));
    }
    
    // the following overload specializes for the case
    // when both arguments are of the same type.
    [T]
    overload foo(a:T, b:T) {
        ...
        implement the logic here
        ...
    }

    record Point[T] {
        x : T;
        y : T;
    }
    
    updateViaPointer(ptr) {
        ptr^.x += 1;
        ptr^.y += 2;
    }
    
    test() {
        var p = Point(10, 20);  // type will be inferred as Point[Int]
        updateViaPointer(&p);
    }