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");
}
/*
template <AlreadySpecilized> |void| OneTwoFunc(|AlreadySpecilized| obj) {
    println("Already Specilized");
}
*/
//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)> {};
/*
 *obj template<AlreadySpecilized> OneTwoObj {
 *    void proveSpecilized() {
 *        println("I'm specilized!");
 *    }
 *};
 */

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<AlreadySpecilized>(e);
    OneTwoFunc<TwoTrait*>(f);
    println();

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

    var alpha: OneTwoObj<NoTraits>;
    var beta: OneTwoObj<Trait1>;
    var gamma: OneTwoObj<Trait2>;
    var delta: OneTwoObj<TwoTrait>;
//    |OneTwoObj<AlreadySpecilized>| epsilon;
    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;
}