import io:*;

typedef NoTraits {};

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

template <T> |void| OneTwoFunc(|T| obj) {
    println("No Traits");
}

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

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

template <T(FirstTrait, SecondTrait)> |void| OneTwoFunc(|T| obj) {
    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

typedef template<T> OneTwoObj (FirstTrait) {};
typedef template<T(FirstTrait)> OneTwoObj (SecondTrait) {};
typedef template<T(SecondTrait)> OneTwoObj (FirstTrait, SecondTrait) {};
typedef template<T(FirstTrait, SecondTrait)> OneTwoObj {};
/*
 *typedef template<AlreadySpecilized> OneTwoObj {
 *    void proveSpecilized() {
 *        println("I'm specilized!");
 *    }
 *};
 */

|int| main() {
    |NoTraits| a;
    |Trait1| b;
    |Trait2| c;
    |TwoTrait| d;
    |AlreadySpecilized| e;

    OneTwoFunc<NoTraits>(a);
    OneTwoFunc<Trait1>(b);
    OneTwoFunc<Trait2>(c);
    OneTwoFunc<TwoTrait>(d);
//    OneTwoFunc<AlreadySpecilized>(e);

    println();

    |OneTwoObj<NoTraits>| alpha;
    |OneTwoObj<Trait1>| beta;
    |OneTwoObj<Trait2>| gamma;
    |OneTwoObj<TwoTrait>| delta;
//    |OneTwoObj<AlreadySpecilized>| epsilon;

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

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

    return 0;
}