import io:*;

obj NoTraits {};

obj Trait1 (FirstTrait) {};
obj Trait2 (SecondTrait) {};
obj TwoTrait (FirstTrait, SecondTrait) {};
obj AlreadySpecilized (FirstTrait, SecondTrait) {};

fun OneTwoFunc<T>(obj: T): void {
    println("No Traits");
}

fun OneTwoFunc<T(FirstTrait)>(obj: T): void {
    println("First Trait");
}

fun OneTwoFunc<T(SecondTrait)>(obj: T): void {
    println("Second Trait");
}

fun OneTwoFunc<T(FirstTrait, SecondTrait)>(obj: T): void {
    println("Both Traits");
}
//This should work for objects too!
//To test, we cycle the mapping of traits

obj OneTwoObj<T> (FirstTrait) {};
obj OneTwoObj<T(FirstTrait)> (SecondTrait) {};
obj OneTwoObj<T(SecondTrait)> (FirstTrait, SecondTrait) {};
obj OneTwoObj<T(FirstTrait, SecondTrait)> {};

fun main(): int {
    var a: NoTraits;
    var b: Trait1;
    var c: Trait2;
    var d: TwoTrait;
    var e: AlreadySpecilized;
    var f: *TwoTrait;

    OneTwoFunc<NoTraits>(a);
    OneTwoFunc<Trait1>(b);
    OneTwoFunc<Trait2>(c);
    OneTwoFunc<TwoTrait>(d);
    OneTwoFunc<*TwoTrait>(f);
    println();

    OneTwoFunc(a);
    OneTwoFunc(b);
    OneTwoFunc(c);
    OneTwoFunc(d);
    OneTwoFunc(f);
    println();

    var alpha: OneTwoObj<NoTraits>;
    var beta: OneTwoObj<Trait1>;
    var gamma: OneTwoObj<Trait2>;
    var delta: OneTwoObj<TwoTrait>;
    var zeta: OneTwoObj<*TwoTrait>;

    OneTwoFunc<OneTwoObj<NoTraits>>(alpha);
    OneTwoFunc<OneTwoObj<Trait1>>(beta);
    OneTwoFunc<OneTwoObj<Trait2>>(gamma);
    OneTwoFunc<OneTwoObj<TwoTrait>>(delta);
    OneTwoFunc<OneTwoObj<*TwoTrait>>(zeta);
    println()

    OneTwoFunc(alpha);
    OneTwoFunc(beta);
    OneTwoFunc(gamma);
    OneTwoFunc(delta);
    OneTwoFunc(zeta);

    //We can't pass along our inner part, so let's just make sure that it is the right object.
    //epsilon.proveSpecilized();

    return 0;
}