#include <iostream>
#include <type_traits>


namespace
{
    struct basic_traits {};

    template<
        typename Traits,
        typename T
    > class core
    {
    public:
        using traits_type = Traits;
        using value_type = T;
    };

    template< typename T > using basic = core< basic_traits, T >;

    template<
        template< typename > class Traits
    > class wrapper
    {
    public:
        template< typename O > using traits_type = Traits< O >;
    };
}


namespace test
{
    template<
        typename Traits,
        typename T,
        typename Scale
    > class unit
    {
    public:
        using traits_type = Traits;
        using  value_type = T;
        using  scale_type = Scale;
    };

    template<
        template< typename > class Numer_Unit,
        template< typename > class Denom_Unit,
        typename T
    > class per
    {
    public:
        template< typename O > using numer_unit = Numer_Unit< O >;
        template< typename O > using denom_unit = Denom_Unit< O >;
        using value_type = T;
    };

    struct unit_scale {};

    struct  foot_traits;
    struct meter_traits;

    template< typename T > using   feet = unit<  foot_traits, T, unit_scale >;
    template< typename T > using meters = unit< meter_traits, T, unit_scale >;

    struct foot_traits {};
    struct meter_traits {};
}


int main( int, char*[] )
{
    using test_fpm = test::per< test::feet, test::meters, double >;

    std::cout
        << std::boolalpha
        << std::is_same<
            core< basic_traits, int >,
            wrapper< basic >::traits_type< int >
        >::value
        << std::endl
        << std::is_same<
            test_fpm,
            test::per<
                test_fpm::numer_unit,
                test_fpm::denom_unit,
                test_fpm::value_type
            >
        >::value
        << std::endl
    ;

    return 0;
}