package;
import Type;
/**
 * ...
 * @author Mr.Cheater
 */
 
class PolymorphFunction
{
        static public function create(args:Array<Array<Dynamic>>)
        {
                var hashTable = new Hash<Dynamic>();
                for (i in args) hashTable.set(Std.string(i[0]), i[1]);
                return Reflect.makeVarArgs(function (args:Array<Dynamic>):Dynamic
                {
                        return Reflect.callMethod(null, hashTable.get({
                                var signature = new Array<String>();
                                for (i in args) signature.push(Std.string(Type.typeof(i)));
                                Std.string(signature);
                        }), args);
                });
        }
}

class Main
{
        static var myfunc:Dynamic =  PolymorphFunction.create([
                //The addition of 2 Ints
                [[ValueType.TInt, ValueType.TInt],
                function(a:Int, b:Int)
                {
                        return a + b;
                }]
                ,
                //The addition of 3 Ints
                [[ValueType.TInt, ValueType.TInt, ValueType.TInt],
                function(a:Int, b:Int, c:Int)
                {
                        return a + b + c;
                }]
                ,
                //Hello %username%!
                [[ValueType.TClass(String)],
                function(value:String)
                {
                        return "Hello, " + value + "!";
                }]
                ,
                //%first% -> %two%!
                [[ValueType.TClass(String), ValueType.TClass(String)],
                function(first:String, two:String)
                {
                        return first + " -> " + two;
                }]
        ]);
        static function main()
        {
                trace(myfunc(10,20)); //30
                trace(myfunc(1,2,3)); //6
                trace(myfunc("Mr.Cheater")); //Hello, Mr.Cheater!
                trace(myfunc("CAT", "DOG")); //CAT -> DOG
        }
}