Replaced function template parameters with auto.

include/xemmai/ast.h

@@ -563,8 +563,7 @@ struct t_emit
 		--v_stack;
 		return *this;
 	}
-	template<typename T>
-	t_emit& operator<<(T a_operand)
+	t_emit& operator<<(auto a_operand)
 	{
 		v_code->v_instructions.push_back(reinterpret_cast<void*>(a_operand));
 		return *this;

include/xemmai/boolean.h

@@ -9,22 +9,20 @@ namespace xemmai
 template<>
 struct t_type_of<bool> : t_uninstantiatable<t_bears<bool>>
 {
-	template<typename T0>
+	template<typename T>
 	struct t_as
 	{
-		template<typename T1>
-		static bool f_call(T1&& a_object)
+		static bool f_call(auto&& a_object)
 		{
 			return a_object.f_boolean();
 		}
 	};
-	template<typename T0>
+	template<typename T>
 	struct t_is
 	{
-		template<typename T1>
-		static bool f_call(T1&& a_object)
+		static bool f_call(auto&& a_object)
 		{
-			return reinterpret_cast<uintptr_t>(f_object(std::forward<T1>(a_object))) == e_tag__BOOLEAN;
+			return reinterpret_cast<uintptr_t>(f_object(std::forward<decltype(a_object)>(a_object))) == e_tag__BOOLEAN;
 		}
 	};
 

include/xemmai/class.h

@@ -1,7 +1,7 @@
 #ifndef XEMMAI__CLASS_H
 #define XEMMAI__CLASS_H
 
-#include "object.h"
+#include "sharable.h"
 
 namespace xemmai
 {
@@ -29,17 +29,15 @@ using t_class = t_type_of<t_type>;
 
 struct t_builder : t_owned
 {
-	template<typename T>
-	static void f_do(t_fields& a_fields, T a_do);
+	static void f_do(t_fields& a_fields, auto a_do);
 
 	t_fields* v_fields;
 };
 
 template<>
 struct t_type_of<t_builder> : t_uninstantiatable<t_finalizes<t_derives<t_builder>>>
 {
-	template<typename... T_an>
-	t_type_of(T_an&&... a_an) : t_base(std::forward<T_an>(a_an)...)
+	t_type_of(auto&&... a_xs) : t_base(std::forward<decltype(a_xs)>(a_xs)...)
 	{
 		v_get = static_cast<t_pvalue (t_type::*)(t_object*, t_object*, size_t&)>(&t_type_of::f_do_get);
 		v_put = f_do_put;

include/xemmai/convert.h

@@ -72,11 +72,11 @@ struct t_signature
 	{
 		return A_function(a_library, a_self, std::forward<T_an>(a_n)...);
 	}
-	template<t_pvalue(*A_function)(t_library*, const t_pvalue&, T_an&&...), typename T_a0, typename... T_am, typename... T_ak>
-	static t_pvalue f__call(t_library* a_library, const t_pvalue& a_self, t_pvalue* a_stack, T_ak&&... a_k)
+	template<t_pvalue(*A_function)(t_library*, const t_pvalue&, T_an&&...), typename T_a0, typename... T_am>
+	static t_pvalue f__call(t_library* a_library, const t_pvalue& a_self, t_pvalue* a_stack, auto&&... a_k)
 	{
 		++a_stack;
-		return f__call<A_function, T_am...>(a_library, a_self, a_stack, std::forward<T_ak>(a_k)..., f_as<T_a0>(*a_stack));
+		return f__call<A_function, T_am...>(a_library, a_self, a_stack, std::forward<decltype(a_k)>(a_k)..., f_as<T_a0>(*a_stack));
 	}
 	template<t_pvalue(*A_function)(t_library*, const t_pvalue&, T_an&&...)>
 	static void f_call(t_library* a_library, const t_pvalue& a_self, t_pvalue* a_stack)
@@ -110,11 +110,11 @@ struct t_call_construct<t_pvalue(*)(t_type*, T_an...), A_function>
 	{
 		return A_function(a_class, std::forward<T_an>(a_n)...);
 	}
-	template<typename T_a0, typename... T_am, typename... T_ak>
-	static t_pvalue f__do(t_type* a_class, t_pvalue* a_stack, T_ak&&... a_k)
+	template<typename T_a0, typename... T_am>
+	static t_pvalue f__do(t_type* a_class, t_pvalue* a_stack, auto&&... a_k)
 	{
 		++a_stack;
-		return f__do<T_am...>(a_class, a_stack, std::forward<T_ak>(a_k)..., f_as<T_a0>(*a_stack));
+		return f__do<T_am...>(a_class, a_stack, std::forward<decltype(a_k)>(a_k)..., f_as<T_a0>(*a_stack));
 	}
 	static t_pvalue f_do(t_type* a_class, t_pvalue* a_stack, size_t a_n)
 	{
@@ -300,10 +300,9 @@ struct t_member
 		using t_self = typename t_call_member<T_library, T_function>::t_self;
 		using t_signature = typename t_call_member<T_library, T_function>::t_signature;
 
-		template<typename... T_an>
-		static t_pvalue f_function(t_library* a_library, const t_pvalue& a_self, T_an&&... a_n)
+		static t_pvalue f_function(t_library* a_library, const t_pvalue& a_self, auto&&... a_xs)
 		{
-			return t_call_member<T_library, T_function>::template f_call<A_function>(a_library, a_self, std::forward<T_an>(a_n)...);
+			return t_call_member<T_library, T_function>::template f_call<A_function>(a_library, a_self, std::forward<decltype(a_xs)>(a_xs)...);
 		}
 		static void f_call(t_library* a_library, t_pvalue* a_stack, size_t a_n)
 		{
@@ -384,10 +383,9 @@ struct t_static
 	{
 		using t_signature = typename t_call_static<T_library, T_function>::t_signature;
 
-		template<typename... T_an>
-		static t_pvalue f_function(t_library* a_library, const t_pvalue& a_self, T_an&&... a_n)
+		static t_pvalue f_function(t_library* a_library, const t_pvalue& a_self, auto&&... a_xs)
 		{
-			return t_call_static<T_library, T_function>::template f_call<A_function>(static_cast<T_library*>(a_library), std::forward<T_an>(a_n)...);
+			return t_call_static<T_library, T_function>::template f_call<A_function>(static_cast<T_library*>(a_library), std::forward<decltype(a_xs)>(a_xs)...);
 		}
 		static void f_call(t_library* a_library, t_pvalue* a_stack, size_t a_n)
 		{
@@ -511,8 +509,7 @@ class t_define
 		v_fields.v_instance.push_back(a_name);
 		return *this;
 	}
-	template<typename T_value>
-	t_define& operator()(t_object* a_name, T_value a_value)
+	t_define& operator()(t_object* a_name, auto a_value)
 	{
 		v_fields.v_class.emplace_back(a_name, v_library->f_as(a_value));
 		return *this;
@@ -542,10 +539,9 @@ class t_define
 	{
 		return (*this)(a_name, t_overload<t_static<T_function, A_function>, T_overload0, T_overloadn...>::template t_bind<T_library>::f_call);
 	}
-	template<typename... T_an>
-	t_define& operator()(std::wstring_view a_name, T_an&&... a_n)
+	t_define& operator()(std::wstring_view a_name, auto&&... a_xs)
 	{
-		return (*this)(t_symbol::f_instantiate(a_name), std::forward<T_an>(a_n)...);
+		return (*this)(t_symbol::f_instantiate(a_name), std::forward<decltype(a_xs)>(a_xs)...);
 	}
 };
 
@@ -559,8 +555,7 @@ struct t_enum_of : t_derivable<t_bears<T, t_type_of<intptr_t>>>
 	{
 		return a_library->template f_type<typename t_fundamental<T>::t_type>()->template f_new<intptr_t>(static_cast<intptr_t>(a_value));
 	}
-	template<typename T_fields>
-	static t_object* f_define(t_library* a_library, T_fields a_fields)
+	static t_object* f_define(t_library* a_library, auto a_fields)
 	{
 		t_define{a_library}.template f_derive<T, intptr_t>();
 		t_define fields(a_library);

include/xemmai/engine.h

@@ -140,8 +140,7 @@ class t_engine
 		f_debug_wait_and_leave(a_lock);
 	}
 	void f_debug_safe_point(std::unique_lock<std::mutex>& a_lock);
-	template<typename T>
-	void f_debug_break_point(std::unique_lock<std::mutex>& a_lock, T a_do);
+	void f_debug_break_point(std::unique_lock<std::mutex>& a_lock, auto a_do);
 	void f_debug_break_point(std::unique_lock<std::mutex>& a_lock);
 	void f_debug_script_loaded(t_debug_script& a_debug);
 	void f_debug_safe_region_leave(std::unique_lock<std::mutex>& a_lock);
@@ -200,8 +199,7 @@ class t_engine
 	}
 	t_object* f_fork(const t_pvalue& a_callable, size_t a_stack);
 	intptr_t f_run(t_debugger* a_debugger);
-	template<typename T>
-	void f_threads(T a_callback)
+	void f_threads(auto a_callback)
 	{
 		for (auto p = v_thread__internals; p; p = p->v_next) if (p->v_done == 0) a_callback(p->v_thread);
 	}
@@ -222,8 +220,7 @@ class t_engine
 	void f_debug_continue(t_thread* a_stepping = nullptr);
 };
 
-template<typename T>
-void t_engine::f_debug_break_point(std::unique_lock<std::mutex>& a_lock, T a_do)
+void t_engine::f_debug_break_point(std::unique_lock<std::mutex>& a_lock, auto a_do)
 {
 	while (v_debug__stopping) f_debug_enter_leave(a_lock);
 	++v_debug__safe;
@@ -354,24 +351,12 @@ inline void t_thread::t_internal::f_epoch_resume()
 #endif
 }
 
-inline void f__new_value(t_svalue* a_p)
-{
-}
-
-template<typename T_x, typename... T_xs>
-inline void f__new_value(t_svalue* a_p, T_x&& a_x, T_xs&&... a_xs)
-{
-	new(a_p) t_svalue(std::forward<T_x>(a_x));
-	f__new_value(++a_p, std::forward<T_xs>(a_xs)...);
-}
-
-template<typename... T_xs>
-inline t_object* f_new_value(t_type* a_type, T_xs&&... a_xs)
+inline t_object* f_new_value(t_type* a_type, auto&&... a_xs)
 {
 	assert(a_type->v_fields_offset == t_object::f_fields_offset(0));
 	assert(a_type->v_instance_fields == sizeof...(a_xs));
 	auto p = f_engine()->f_allocate(sizeof(t_svalue) * sizeof...(a_xs));
-	f__new_value(p->f_fields(0), std::forward<T_xs>(a_xs)...);
+	f__construct(p->f_fields(0), std::forward<decltype(a_xs)>(a_xs)...);
 	p->f_be(a_type);
 	return p;
 }

include/xemmai/fiber.h

@@ -94,8 +94,8 @@ struct t_fiber
 
 	static t_object* f_current();
 	static t_object* f_instantiate(const t_pvalue& a_callable, size_t a_stack);
-	template<typename T_context, typename T_main>
-	static intptr_t f_main(T_main a_main);
+	template<typename T_context>
+	static intptr_t f_main(auto a_main);
 	template<typename T_context>
 	static void f_run();
 
@@ -162,10 +162,9 @@ struct t_context
 		std::fill(v_base + v_lambda->f_as<t_lambda>().v_arguments, v_base + v_lambda->f_as<t_lambda>().v_privates, 0);
 #endif
 	}
-	template<typename T>
-	XEMMAI__PORTABLE__ALWAYS_INLINE void f_return(T&& a_value)
+	XEMMAI__PORTABLE__ALWAYS_INLINE void f_return(auto&& a_value)
 	{
-		v_base[-2] = std::forward<T>(a_value);
+		v_base[-2] = std::forward<decltype(a_value)>(a_value);
 		f_stack__(v_previous);
 	}
 	XEMMAI__PORTABLE__ALWAYS_INLINE void f_tail(t_pvalue* a_stack, size_t a_n)
@@ -221,10 +220,9 @@ class t_scoped_stack
 		v_p = f_stack();
 		f_stack__(v_p + a_n);
 	}
-	template<typename T_x, typename... T>
-	t_scoped_stack(size_t a_n, T_x&& a_x, T&&... a_xs) : t_scoped_stack(a_n, std::forward<T>(a_xs)...)
+	t_scoped_stack(size_t a_n, auto&& a_x, auto&&... a_xs) : t_scoped_stack(a_n, std::forward<decltype(a_xs)>(a_xs)...)
 	{
-		v_p[a_n - sizeof...(a_xs) - 1] = std::forward<T_x>(a_x);
+		v_p[a_n - sizeof...(a_xs) - 1] = std::forward<decltype(a_x)>(a_x);
 	}
 	~t_scoped_stack()
 	{
@@ -237,20 +235,18 @@ class t_scoped_stack
 };
 
 template<typename T_tag>
-template<typename... T>
-inline t_pvalue t_value<T_tag>::operator()(T&&... a_arguments) const
+inline t_pvalue t_value<T_tag>::operator()(auto&&... a_arguments) const
 {
-	t_scoped_stack stack(sizeof...(a_arguments) + 2, std::forward<T>(a_arguments)...);
+	t_scoped_stack stack(sizeof...(a_arguments) + 2, std::forward<decltype(a_arguments)>(a_arguments)...);
 	stack[1] = nullptr;
 	f_call(stack, sizeof...(a_arguments));
 	return stack[0];
 }
 
 template<typename T_tag>
-template<typename... T>
-inline t_pvalue t_value<T_tag>::f_invoke(t_object* a_key, size_t& a_index, T&&... a_arguments) const
+inline t_pvalue t_value<T_tag>::f_invoke(t_object* a_key, size_t& a_index, auto&&... a_arguments) const
 {
-	t_scoped_stack stack(sizeof...(a_arguments) + 2, std::forward<T>(a_arguments)...);
+	t_scoped_stack stack(sizeof...(a_arguments) + 2, std::forward<decltype(a_arguments)>(a_arguments)...);
 	stack[1] = nullptr;
 	f_call(a_key, a_index, stack, sizeof...(a_arguments));
 	return stack[0];
@@ -339,19 +335,17 @@ inline t_pvalue t_value<T_tag>::f_complement() const
 	}
 }
 
-template<typename... T>
-inline t_pvalue t_object::f_invoke_class(size_t a_index, T&&... a_arguments)
+inline t_pvalue t_object::f_invoke_class(size_t a_index, auto&&... a_arguments)
 {
-	t_scoped_stack stack(sizeof...(a_arguments) + 2, std::forward<T>(a_arguments)...);
+	t_scoped_stack stack(sizeof...(a_arguments) + 2, std::forward<decltype(a_arguments)>(a_arguments)...);
 	stack[1] = nullptr;
 	v_type->f_invoke_class(this, a_index, stack, sizeof...(a_arguments));
 	return stack[0];
 }
 
-template<typename... T>
-inline t_pvalue t_object::f_invoke(t_object* a_key, size_t& a_index, T&&... a_arguments)
+inline t_pvalue t_object::f_invoke(t_object* a_key, size_t& a_index, auto&&... a_arguments)
 {
-	t_scoped_stack stack(sizeof...(a_arguments) + 2, std::forward<T>(a_arguments)...);
+	t_scoped_stack stack(sizeof...(a_arguments) + 2, std::forward<decltype(a_arguments)>(a_arguments)...);
 	stack[1] = nullptr;
 	f_call(a_key, a_index, stack, sizeof...(a_arguments));
 	return stack[0];

include/xemmai/float.h

@@ -16,15 +16,14 @@ struct t_fundamental<float>
 template<>
 struct t_type_of<double> : t_derivable<t_bears<double>, t_derived_primitive<double>>
 {
-	template<typename T0>
+	template<typename T>
 	struct t_as
 	{
-		using t_type = typename t_fundamental<T0>::t_type;
+		using t_type = typename t_fundamental<T>::t_type;
 
-		template<typename T1>
-		static t_type f_call(T1&& a_object)
+		static t_type f_call(auto&& a_object)
 		{
-			auto p = f_object(std::forward<T1>(a_object));
+			auto p = f_object(std::forward<decltype(a_object)>(a_object));
 			switch (reinterpret_cast<uintptr_t>(p)) {
 			case e_tag__INTEGER:
 				return a_object.f_integer();
@@ -39,14 +38,13 @@ struct t_type_of<double> : t_derivable<t_bears<double>, t_derived_primitive<doub
 			return a_object->f_as<double>();
 		}
 	};
-	template<typename T0>
+	template<typename T>
 	struct t_is
 	{
-		template<typename T1>
-		static bool f_call(T1&& a_object)
+		static bool f_call(auto&& a_object)
 		{
-			auto p = f_object(std::forward<T1>(a_object));
-			if (!std::is_same_v<typename t_fundamental<T0>::t_type, double>) return reinterpret_cast<uintptr_t>(p) >= e_tag__OBJECT && p->f_type()->template f_derives<typename t_fundamental<T0>::t_type>();
+			auto p = f_object(std::forward<decltype(a_object)>(a_object));
+			if (!std::is_same_v<typename t_fundamental<T>::t_type, double>) return reinterpret_cast<uintptr_t>(p) >= e_tag__OBJECT && p->f_type()->template f_derives<typename t_fundamental<T>::t_type>();
 			switch (reinterpret_cast<uintptr_t>(p)) {
 			case e_tag__NULL:
 			case e_tag__BOOLEAN: