please help me read the following meta looper system:
/*A meta obj is a bind of a meta_function and an obj, each time it is invoked, it update itself to a new type,
use ::type to get the inner obj*/
template<class MMO(Obj), class F/*Define how to Update an obj*/>
struct meta_object
{
	using type = MMO(Obj);
	template<class ...Arg>
	using apply = meta_object<meta_invoke<F, MMO(Obj), Arg...>, F>;

	template<class Outer_Obj>
	using meta_set = meta_object<Outer_Obj, F>;
};

template<class MMO(Obj), class F, class Ret>
struct meta_ret_object
{
	using ret = meta_invoke<Ret, MMO(Obj)>;
	using type = MMO(Obj);
	template<class ...Arg>
	using apply = meta_ret_object<meta_invoke<F, MMO(Obj), Arg...>, F, Ret>;

	template<class Outer_Obj>
	using meta_set = meta_ret_object<Outer_Obj, F, Ret>;
};

template<size_t times, class MMO(Obj), class F, class break_f = meta_always_continue>
struct meta_timer_object
{
	using timer = meta_invoke<meta_break_if<break_f, quick_value_i_greater<times, 0>>, MMO(Obj)>;

	using type = MMO(Obj);
	template<class ...Arg>
	using apply = meta_timer_object<times - 1, meta_invoke<F, MMO(Obj), Arg...>, F, break_f>;

	template<class Outer_Obj>
	using meta_set = meta_timer_object<times, Outer_Obj, F, break_f>;

	template<size_t reset_time>
	using reset = meta_timer_object<reset_time, MMO(Obj), F, break_f>;
};

template<class MMO(Obj), size_t N, class break_f> struct To_Timer {};
template<class obj, class F, size_t N, class break_f> struct To_Timer<meta_object<obj, F>, N, break_f>
{
	using type = meta_timer_object<N, obj, F, break_f>;
};

template<class MMO(Obj), size_t N, class break_f = meta_always_continue> using to_timer = typename To_Timer<MMO(Obj), N, break_f>::type;

template<class mo, class F> struct Break_If {};
template<size_t N, class MMO(Obj), class MO_F, class F> struct Break_If<meta_timer_object<N, MMO(Obj), MO_F>, F>
{
	using type = meta_timer_object<N, MMO(Obj), MO_F, F>;
};

template<class MTO, class BF> using break_if = get_type<Break_If<MTO, BF>>;

template<class MMO(From), class MMO(To)>
struct meta_transfer {
	using type = typename MMO(To)::template meta_set<typename MMO(From)::type>;
};

//transfer timer if invoke to a meta_timer_oject
template<size_t times, class obj, class F, class MMO(To), class B>
struct meta_transfer<meta_timer_object<times, obj, F, B>, MMO(To)> {
	using type = typename MMO(To)::template meta_set<typename meta_timer_object<times, obj, F, B>::timer>;
};

//transfer returns if invoke to a meta_ret_object
template<class Ret, class obj, class F, class MMO(To)>
struct meta_transfer<meta_ret_object<obj, F, Ret>, MMO(To)> {
	using type = typename MMO(To)::template meta_set<typename meta_ret_object<obj, F, Ret>::ret>;
};

//the meta_object is itself a meta_function
//if two meta_objects invoked, invoke the first object with type in second object
template<class MMO(Obj1), class MMO(Obj2)>
struct Meta_Object_Invoke { using type = meta_invoke< MMO(Obj1), typename MMO(Obj2)::type>; };

//if invoke with meta_ret_object, invoke the first object with returns
template<class MMO(Obj1), class Obj2, class F, class Ret>
struct Meta_Object_Invoke<MMO(Obj1), meta_ret_object<Obj2, F, Ret>>
{
	using type = meta_invoke<MMO(Obj1), typename meta_ret_object<Obj2, F, Ret>::ret>;
};
template<class MMO(Obj1), class MMO(Obj2)>
using meta_object_invoke = typename Meta_Object_Invoke< MMO(Obj1), MMO(Obj2)>::type;




//transfer obj between MO, Fn not included.
template<class MMO(From), class MMO(To)>
using meta_transfer_object = typename  meta_transfer<MMO(From), MMO(To)>::type;

//use meta_object_invoke to invoke two meta objects if true
//meta object must be invoked with another meta object being argument
//if false, return original meta object
template<bool con> struct invoke_object_if
{
	template<bool, class MO1, class MO2> struct meta_o_branch
	{
		using type = MO1;
	};
	template<class MO1, class MO2> struct meta_o_branch<true, MO1, MO2>
	{
		using type = meta_object_invoke<MO1, MO2>;
	};

	template<class MO1, class MO2> using apply = typename meta_o_branch<con, MO1, MO2>::type;
};

//using meta_invoke to invoke a meta function with arguments if true
//if false, return the invoked meta function itself
//this is designed for meta_object, because if it returns the function itself
//it returns the object with not being invoked
template<bool con> struct invoke_meta_function_if
{
	template<bool, class F, class ...Args> struct meta_function_branch
	{
		using type = F;
	};
	template<class F, class ...Args> struct meta_function_branch<true, F, Args...>
	{
		using type = meta_invoke<F, Args...>;
	};

	template<class F, class ...Args> using apply = typename meta_function_branch<con, F, Args...>::type;
};




//Note: looper returns a meta object, not the context itself
//Note: with the macro MMO, it requires the template class to be a meta_object
template<bool, class MMO(Condition), class MMO(Obj), class MMO(Generator) = meta_object<meta_empty, meta_empty_fn>> struct meta_looper
{


	template<class ...Args> struct apply {

		//transfer current obj to  condition_obj to judge
		//transfer different context based on types of meta_object
		using _continue_t = typename meta_invoke<meta_transfer_object<MMO(Obj), MMO(Condition)>>::type;
		static const bool _continue_ = _continue_t::value;

		//invoke generator object if condition is true
		using generator_stage_o = typename invoke_meta_function_if<_continue_>::template apply<MMO(Generator), Args...>;

		//invoke Obj object if condition is true
		using result_stage_o = typename invoke_object_if<_continue_>::template apply<MMO(Obj), generator_stage_o>;

		//for debug
		using next_stage = meta_looper<_continue_, MMO(Condition), result_stage_o, generator_stage_o>;

		//recursively loop for result
		using track_apply_t = meta_invoke<invoke_meta_function_if<_continue_>, meta_looper<
			_continue_,
			MMO(Condition),
			result_stage_o,
			generator_stage_o
		>, Args...>;
		using type = typename track_apply_t::type;
	};
};

template<class Cond, class MO, class Generator> struct meta_looper<false, Cond, MO, Generator>
{
	static constexpr bool _continue_ = false;
	using type = MO;
};
template<class MMO(Condition), class MMO(Obj), class MMO(Generator) = meta_object<meta_empty, meta_empty_fn>>
using meta_looper_t = typename meta_invoke<meta_looper<true, MMO(Condition), MMO(Obj), MMO(Generator)>>::type;