View difference between Paste ID: Ac0j8m1T and X4jzhmfK

 #include <cstddef>
 #include <type_traits>
 #include <utility>
 #include <ostream>
 
 namespace fizzbuzz {
 	template< typename... T >
 	struct typelist {
 		static constexpr std::size_t size = sizeof...( T );
 	};
 
 	namespace detail {
 		template< typename... T >
 		struct concat_impl {
 		};
 		template<>
 		struct concat_impl<> {
 			using t = typelist<>;
 		};
 		template< typename... head, typename... tail >
 		struct concat_impl< typelist< head... >, typelist< tail... > > {
 			using t = typelist< head..., tail... >;
 		};
 		template< typename... head, typename... tail >
 		struct concat_impl< typelist< head... >, tail... > {
 			using t = typename concat_impl< typelist< head... >, typename concat_impl< tail... >::t >::t;
 		};
 		template< typename head, typename... tail >
 		struct concat_impl< head, tail... > {
 			using t = typename concat_impl< typelist< head >, tail... >::t;
 		};
 	}
 	template< typename... T >
 	using concat = typename detail::concat_impl< T... >::t;
 
 	template< char c >
 	struct char_ {
 		static constexpr auto v = c;
 	};
 	template< int i >
 	struct int_ {
 		static constexpr auto v = i;
 	};
 
 	namespace detail {
 		template< typename list >
 		struct discard_trailing_zeroes {
 		};
 		template< typename head, typename... tail >
 		struct discard_trailing_zeroes< typelist< head, tail... > > {
 			using t = concat< head, typename discard_trailing_zeroes< typelist< tail... > >::t >;
 		};
 		template< typename... tail >
 		struct discard_trailing_zeroes< typelist< char_< '\0' >, tail... > > {
 			using t = typelist<>;
 		};
 		template<>
 		struct discard_trailing_zeroes< typelist<> > {
 			using t = typelist<>;
 		};
 	}
 #define LITERAL2LIST_1( str, i )	\
 	::fizzbuzz::char_< ( sizeof( str ) / sizeof( *str ) > ( i ) ? str[ ( i ) ] : '\0' ) >
 #define LITERAL2LIST_2( str, i )	\
 	LITERAL2LIST_1( str, i + 0 ),	\
 	LITERAL2LIST_1( str, i + 1 )
 #define LITERAL2LIST_4( str, i )	\
 	LITERAL2LIST_2( str, i + 0 ),	\
 	LITERAL2LIST_2( str, i + 2 )
 #define LITERAL2LIST_8( str, i )	\
 	LITERAL2LIST_4( str, i + 0 ),	\
 	LITERAL2LIST_4( str, i + 4 )
 #define LITERAL2LIST_16( str, i )	\
 	LITERAL2LIST_8( str, i + 0 ),	\
 	LITERAL2LIST_8( str, i + 8 )
 #define LITERAL2LIST( str ) std::enable_if_t< ( sizeof( str ) - 1 < 16 ), ::fizzbuzz::detail::discard_trailing_zeroes< ::fizzbuzz::typelist< LITERAL2LIST_16( str, 0 ) > >::t >
 
 	inline std::ostream& operator<<( std::ostream& stream, typelist<> ) {
 		return stream;
 	}
 	template< char... c >
 	std::ostream& operator<<( std::ostream& stream, typelist< char_< c >... > ) {
 		constexpr char s[] = { c... };
 		return stream.write( s, sizeof( s ) / sizeof( *s ) );
 	}
 	template< int head, int... tail >
 	std::ostream& operator<<( std::ostream& stream, typelist< int_< head >, int_< tail >... > ) {
 		return stream << head << ' ' << typelist< int_< tail >... >{};
 	}
 	template< int head >
 	std::ostream& operator<<( std::ostream& stream, typelist< int_< head > > ) {
 		return stream << head;
 	}
 
 	namespace detail {
 		template< std::size_t n, int a0, int d >
 		struct arithmetic_progression_impl {
 			using t = concat< typename arithmetic_progression_impl< n / 2, a0, d >::t, typename arithmetic_progression_impl< n - n / 2, a0 + n / 2 * d, d >::t >;
 		};
 		template< int d, int a0 >
 		struct arithmetic_progression_impl< 0, a0, d > {
 			using t = typelist<>;
 		};
 		template< int d, int a0 >
 		struct arithmetic_progression_impl< 1, a0, d > {
 			using t = typelist< int_< a0 > >;
 		};
 	}
 	template< std::size_t n, int a0 = 0, int d = 1 >
 	using arithmetic_progression = typename detail::arithmetic_progression_impl< n, a0, d >::t;
 
 	namespace detail {
 		template< typename list, typename separator >
 		struct separate_impl {
 		};
 		template< typename head, typename... tail, typename separator >
 		struct separate_impl< typelist< head, tail... >, separator > {
 			using t = concat< head, separator, typename separate_impl< typelist< tail... >, separator >::t >;
 		};
 		template< typename head, typename separator >
 		struct separate_impl< typelist< head >, separator > {
 			using t = typelist< head >;
 		};
 	}
 	template< typename list, typename separator >
 	using separate = typename detail::separate_impl< list, separator >::t;
 
 	namespace detail {
 		template< typename list, template< typename > class meta_functor >
 		struct transform_impl {
 		};
 		template< typename head, typename... tail, template< typename > class meta_functor >
 		struct transform_impl< typelist< head, tail... >, meta_functor > {
 			using t = concat< typename meta_functor< head >::t, typename transform_impl< typelist< tail... >, meta_functor >::t >;
 		};
 		template< template< typename > class meta_functor >
 		struct transform_impl< typelist<>, meta_functor > {
 			using t = typelist<>;
 		};
 	}
 	template< typename list, template< typename > class meta_functor >
 	using transform = typename detail::transform_impl< list, meta_functor >::t;
 
 	namespace detail {
 		template< unsigned i >
 		struct log10_impl {
 			static constexpr int v = 1 + log10_impl< i / 10 >::v;
 		};
 		template<>
 		struct log10_impl< 0 > {
 			static constexpr int v = -1;
 		};
 	}
 	template< unsigned i >
 	static constexpr int log10 = detail::log10_impl< i >::v;
 
 	namespace detail {
 		template< unsigned i >
 		struct pow10_impl {
 			static constexpr unsigned v = pow10_impl< i / 2 >::v * pow10_impl< i - i / 2 >::v;
 		};
 		template<>
 		struct pow10_impl< 1 > {
 			static constexpr unsigned v = 10;
 		};
 		template<>
 		struct pow10_impl< 0 > {
 			static constexpr unsigned v = 1;
 		};
 	}
 	template< unsigned i >
 	static constexpr unsigned pow10 = detail::pow10_impl< i >::v;
 
 	namespace detail {
 		template< int i, typename = std::make_integer_sequence< int, 1 + log10< i > > >
 		struct int2str_impl_impl {
 		};
 		template< int i, int... indices >
 		struct int2str_impl_impl< i, std::integer_sequence< int, indices... > > {
 			using t = typelist< char_< '0' + i / pow10< sizeof...( indices ) - 1 - indices > % 10 >... >;
 		};
 
 		template< int i, bool neg = ( i < 0 ) >
 		struct int2str_impl {
 			using t = concat< char_< '-' >, typename int2str_impl< -i >::t >;
 		};
 		template< int i >
 		struct int2str_impl< i, false > {
 			using t = typename int2str_impl_impl< i >::t;
 		};
 		template<>
 		struct int2str_impl< 0, false > {
 			using t = typelist< char_< '0' > >;
 		};
 	}
 	template< typename T >
 	struct int2str {
 		using t = T;
 	};
 	template< int i >
 	struct int2str< int_< i > > {
 		using t = typename detail::int2str_impl< i >::t;
 	};
 
 	template< int i, typename T >
 	struct divisibility_replacement_rule {
 		static constexpr auto v = i;
 		using t = T;
 	};
 	template< typename ruleset >
 	struct divisibility_replacer {
 		template< int x, typename = ruleset >
 		struct match {
 		};
 		template< int x, typename head, int... i, typename... tail >
 		struct match< x, typelist< head, divisibility_replacement_rule< i, tail >... > > {
 			using tail_rec = match< x, typelist< divisibility_replacement_rule< i, tail >... > >;
 			static constexpr bool matched_here = ( x % head::v == 0 );
 			static constexpr bool matched = matched_here || tail_rec::matched;
 			using t_here = std::conditional_t< matched_here, typename head::t, typelist<> >;
 			using t = concat< t_here, typename tail_rec::t >;
 		};
 		template< int x >
 		struct match< x, typelist<> > {
 			static constexpr bool matched = false;
 			using t = typelist<>;
 		};
 
 		template< typename U >
 		struct functor {
 			using t = U;
 		};
 		template< int x >
 		struct functor< int_< x > > {
 			using match_result = match< x >;
 			using t = std::conditional_t< match_result::matched, typename match_result::t, int_< x > >;
 		};
 	};
 
 	struct fizzbuzz_replacer :
 		divisibility_replacer<
 			typelist<
 				divisibility_replacement_rule< 3, LITERAL2LIST( "Fizz" ) >,
 				divisibility_replacement_rule< 5, LITERAL2LIST( "Buzz" ) >
 			>
 		>
 	{
 	};
 
 	template< int min = 1, int max = 100, typename = std::enable_if_t< ( min < max ) > >
 	using fizzbuzz = transform< transform< separate< arithmetic_progression< max - min + 1, min, 1 >, LITERAL2LIST( ", " ) >, fizzbuzz_replacer::functor >, int2str >;
 }
 
 #include <iostream>
 
 int main() {
 	std::cout << fizzbuzz::fizzbuzz<>{} << '\n';
 }