diff --git a/Redcraft.Utility/Source/Private/Testing/TemplatesTesting.cpp b/Redcraft.Utility/Source/Private/Testing/TemplatesTesting.cpp
index 98b256c..018f684 100644
--- a/Redcraft.Utility/Source/Private/Testing/TemplatesTesting.cpp
+++ b/Redcraft.Utility/Source/Private/Testing/TemplatesTesting.cpp
@@ -1155,6 +1155,87 @@ void TestFunction()
 		always_check(FunctionDebug.Output[10] == 720);
 		always_check(FunctionDebug.Output[11] == 5040);
 	}
+
+	{
+		TFunction<bool(bool)> Identity = TIdentity<>();
+		TFunction<bool(bool)> NotIdentity = NotFn(Identity);
+	
+		always_check(Identity(true));
+		always_check(NotIdentity(false));
+	}
+
+	{
+		always_check(TPlus      <int32>()(4, 2) == 6);
+		always_check(TMinus     <int32>()(4, 2) == 2);
+		always_check(TMultiplies<int32>()(4, 2) == 8);
+		always_check(TDivides   <int32>()(4, 2) == 2);
+		always_check(TModulus   <int32>()(4, 2) == 0);
+		always_check(TNegate    <int32>()(4   ) == -4);
+
+		always_check(TEqualTo     <int32>()(4, 2) == false);
+		always_check(TNotEqualTo  <int32>()(4, 2) == true);
+		always_check(TGreater     <int32>()(4, 2) == true);
+		always_check(TLess        <int32>()(4, 2) == false);
+		always_check(TGreaterEqual<int32>()(4, 2) == true);
+		always_check(TLessEqual   <int32>()(4, 2) == false);
+
+		always_check(TLogicalAnd<int32>()(4, 2) == true);
+		always_check(TLogicalOr <int32>()(4, 2) == true);
+		always_check(TLogicalNot<int32>()(4   ) == false);
+
+		always_check(TBitAnd<int32>()(4, 2) == 0);
+		always_check(TBitOr <int32>()(4, 2) == 6);
+		always_check(TBitXor<int32>()(4, 2) == 6);
+		always_check(TBitNot<int32>()(4   ) == -5);
+	}
+	
+	{
+		TFunction<int32(int32, int32)> TempA = TPlus      <>();
+		TFunction<int32(int32, int32)> TempB = TMinus     <>();
+		TFunction<int32(int32, int32)> TempC = TMultiplies<>();
+		TFunction<int32(int32, int32)> TempD = TDivides   <>();
+		TFunction<int32(int32, int32)> TempE = TModulus   <>();
+		TFunction<int32(int32       )> TempF = TNegate    <>();
+		
+		always_check(TempA(4, 2) == 6);
+		always_check(TempB(4, 2) == 2);
+		always_check(TempC(4, 2) == 8);
+		always_check(TempD(4, 2) == 2);
+		always_check(TempE(4, 2) == 0);
+		always_check(TempF(4   ) == -4);
+		
+		TFunction<bool(int32, int32)> TempG = TEqualTo     <>();
+		TFunction<bool(int32, int32)> TempH = TNotEqualTo  <>();
+		TFunction<bool(int32, int32)> TempI = TGreater     <>();
+		TFunction<bool(int32, int32)> TempJ = TLess        <>();
+		TFunction<bool(int32, int32)> TempK = TGreaterEqual<>();
+		TFunction<bool(int32, int32)> TempL = TLessEqual   <>();
+		
+		always_check(TempG(4, 2) == false);
+		always_check(TempH(4, 2) == true);
+		always_check(TempI(4, 2) == true);
+		always_check(TempJ(4, 2) == false);
+		always_check(TempK(4, 2) == true);
+		always_check(TempL(4, 2) == false);
+		
+		TFunction<bool(int32, int32)> TempM = TLogicalAnd<>();
+		TFunction<bool(int32, int32)> TempN = TLogicalOr <>();
+		TFunction<bool(int32       )> TempO = TLogicalNot<>();
+	
+		always_check(TempM(4, 2) == true);
+		always_check(TempN(4, 2) == true);
+		always_check(TempO(4   ) == false);
+		
+		TFunction<int32(int32, int32)> TempP = TBitAnd<>();
+		TFunction<int32(int32, int32)> TempQ = TBitOr <>();
+		TFunction<int32(int32, int32)> TempR = TBitXor<>();
+		TFunction<int32(int32       )> TempS = TBitNot<>();
+	
+		always_check(TempP(4, 2) == 0);
+		always_check(TempQ(4, 2) == 6);
+		always_check(TempR(4, 2) == 6);
+		always_check(TempS(4   ) == -5);
+	}
 }
 
 NAMESPACE_UNNAMED_BEGIN
diff --git a/Redcraft.Utility/Source/Public/Templates/Function.h b/Redcraft.Utility/Source/Public/Templates/Function.h
index 1fcfeb3..40482dd 100644
--- a/Redcraft.Utility/Source/Public/Templates/Function.h
+++ b/Redcraft.Utility/Source/Public/Templates/Function.h
@@ -2,12 +2,17 @@
 
 #include "CoreTypes.h"
 #include "Memory/Memory.h"
+#include "Concepts/Same.h"
 #include "Templates/Any.h"
 #include "Templates/Tuple.h"
 #include "Templates/Invoke.h"
+#include "Templates/Utility.h"
 #include "Templates/Container.h"
+#include "Concepts/Comparable.h"
+#include "Concepts/Convertible.h"
 #include "TypeTraits/TypeTraits.h"
 #include "Miscellaneous/TypeInfo.h"
+#include "Concepts/BooleanTestable.h"
 #include "Miscellaneous/AssertionMacros.h"
 
 NAMESPACE_REDCRAFT_BEGIN
@@ -454,6 +459,203 @@ static_assert(sizeof(TFunctionRef<void()>)    == 16, "The byte size of TFunction
 static_assert(sizeof(TFunction<void()>)       == 64, "The byte size of TFunction is unexpected");
 static_assert(sizeof(TUniqueFunction<void()>) == 64, "The byte size of TUniqueFunction is unexpected");
 
+template <typename T = void>
+struct TIdentity
+{
+	using Type = T;
+
+	constexpr T&& operator()(T&& InValue) const
+	{
+		return Forward<T>(InValue);
+	}
+};
+
+template <>
+struct TIdentity<void>
+{
+	using Type = void;
+
+	template<typename T>
+	constexpr T&& operator()(T&& InValue) const
+	{
+		return Forward<T>(InValue);
+	}
+};
+
+NAMESPACE_PRIVATE_BEGIN
+
+template <typename F>
+struct NotFunctionType
+{
+	F Func;
+
+	NotFunctionType(const NotFunctionType&) = default;
+	NotFunctionType(NotFunctionType&&) = default;
+
+	template <typename InF>
+	constexpr NotFunctionType(InF&& InFunc) : Func(Forward<InF>(InFunc)) { }
+
+	template <typename... Types> requires TIsInvocable<F&, Types&&...>::Value
+		constexpr auto operator()(Types&&... Args) &
+		-> decltype(!Invoke(Func, Forward<Types>(Args)...))
+	{
+		return !Invoke(Func, Forward<Types>(Args)...);
+	}
+
+	template <typename... Types> requires TIsInvocable<F&&, Types&&...>::Value
+		constexpr auto operator()(Types&&... Args) &&
+		-> decltype(!Invoke(MoveTemp(Func), Forward<Types>(Args)...))
+	{
+		return !Invoke(MoveTemp(Func), Forward<Types>(Args)...);
+	}
+
+	template <typename... Types> requires TIsInvocable<const F&, Types&&...>::Value
+		constexpr auto operator()(Types&&... Args) const&
+		-> decltype(!Invoke(Func, Forward<Types>(Args)...))
+	{
+		return !Invoke(Func, Forward<Types>(Args)...);
+	}
+
+	template <typename... Types> requires TIsInvocable<const F&&, Types&&...>::Value
+		constexpr auto operator()(Types&&... Args) const&&
+		-> decltype(!Invoke(MoveTemp(Func), Forward<Types>(Args)...))
+	{
+		return !Invoke(MoveTemp(Func), Forward<Types>(Args)...);
+	}
+};
+
+NAMESPACE_PRIVATE_END
+
+template <typename F>
+constexpr NAMESPACE_PRIVATE::NotFunctionType<typename TDecay<F>::Type> NotFn(F&& Func)
+{
+	return NAMESPACE_PRIVATE::NotFunctionType<typename TDecay<F>::Type>(Forward<F>(Func));
+}
+
+#define FUNCTOR_UNARY_OPERATOR_IMPL(Name, Operator, ReturnType, ConceptT, ConceptU) \
+	template <typename T = void> requires (CSameAs<T, void> || ConceptT)            \
+	struct Name                                                                     \
+	{                                                                               \
+		constexpr ReturnType operator()(const T& InValue) const {                   \
+			return Operator InValue;                                                \
+		}                                                                           \
+	};                                                                              \
+	                                                                                \
+	template <>                                                                     \
+	struct Name<void>                                                               \
+	{                                                                               \
+		template <typename U> requires ConceptU                                     \
+		constexpr auto operator()(U&& InValue) const                                \
+			-> decltype(Operator Forward<U>(InValue))                               \
+		{                                                                           \
+			return Operator Forward<U>(InValue);                                    \
+		}                                                                           \
+	}
+
+#define FUNCTOR_BINARY_OPERATOR_IMPL(Name, Operator, ReturnType, ConceptT, ConceptTU) \
+	template <typename T = void> requires (CSameAs<T, void> || ConceptT)              \
+	struct Name                                                                       \
+	{                                                                                 \
+		constexpr ReturnType operator()(const T& LHS, const T& RHS) const             \
+		{                                                                             \
+			return LHS Operator RHS;                                                  \
+		}                                                                             \
+	};                                                                                \
+	                                                                                  \
+	template <>                                                                       \
+	struct Name<void>                                                                 \
+	{                                                                                 \
+		template <typename T, typename U> requires ConceptTU                          \
+		constexpr auto operator()(T&& LHS, U&& RHS) const                             \
+			-> decltype(Forward<T>(LHS) Operator Forward<U>(RHS))                     \
+		{                                                                             \
+			return Forward<T>(LHS) Operator Forward<U>(RHS);                          \
+		}                                                                             \
+	}
+
+#define FUNCTOR_UNARY_OPERATOR_A_IMPL(Name, Operator)                                \
+	FUNCTOR_UNARY_OPERATOR_IMPL                                                      \
+	(                                                                                \
+		Name, Operator, T,                                                           \
+		(requires(const T& InValue) { { Operator InValue } -> CConvertibleTo<T>; }), \
+		(requires(U&& InValue) { Operator Forward<U>(InValue); })                    \
+	)
+
+#define FUNCTOR_BINARY_OPERATOR_A_IMPL(Name, Operator)                                         \
+	FUNCTOR_BINARY_OPERATOR_IMPL                                                               \
+	(                                                                                          \
+		Name, Operator, T,                                                                     \
+		(requires(const T& LHS, const T& RHS) { { LHS Operator RHS } -> CConvertibleTo<T>; }), \
+		(requires(T&& LHS, U&& RHS) { Forward<T>(LHS) Operator Forward<U>(RHS); })             \
+	)
+	
+#define FUNCTOR_UNARY_OPERATOR_B_IMPL(Name, Operator)                                     \
+	FUNCTOR_UNARY_OPERATOR_IMPL                                                           \
+	(                                                                                     \
+		Name, Operator, bool,                                                             \
+		(requires(const T& InValue) { { Operator InValue } -> CBooleanTestable; }),       \
+		(requires(U&& InValue) { { Operator Forward<U>(InValue) } -> CBooleanTestable; }) \
+	)
+
+#define FUNCTOR_BINARY_OPERATOR_B_IMPL(Name, Operator)                                                     \
+	FUNCTOR_BINARY_OPERATOR_IMPL                                                                           \
+	(                                                                                                      \
+		Name, Operator, bool,                                                                              \
+		(requires(const T& LHS, const T& RHS) { { LHS Operator RHS } -> CBooleanTestable; }),              \
+		(requires(T&& LHS, U&& RHS) { { Forward<T>(LHS) Operator Forward<U>(RHS) } -> CBooleanTestable; }) \
+	)
+	
+#define FUNCTOR_BINARY_OPERATOR_C_IMPL(Name, Operator) \
+	FUNCTOR_BINARY_OPERATOR_IMPL                       \
+	(                                                  \
+		Name, Operator, bool,                          \
+		(CEqualityComparable<T>),                      \
+		(CEqualityComparableWith<T, U>)                \
+	)
+	
+#define FUNCTOR_BINARY_OPERATOR_D_IMPL(Name, Operator) \
+	FUNCTOR_BINARY_OPERATOR_IMPL                       \
+	(                                                  \
+		Name, Operator, bool,                          \
+		(CTotallyOrdered<T>),                          \
+		(CTotallyOrderedWith<T, U>)                    \
+	)
+	
+FUNCTOR_BINARY_OPERATOR_A_IMPL(TPlus,       +);
+FUNCTOR_BINARY_OPERATOR_A_IMPL(TMinus,      -);
+FUNCTOR_BINARY_OPERATOR_A_IMPL(TMultiplies, *);
+FUNCTOR_BINARY_OPERATOR_A_IMPL(TDivides,    /);
+FUNCTOR_BINARY_OPERATOR_A_IMPL(TModulus,    %);
+FUNCTOR_UNARY_OPERATOR_A_IMPL (TNegate,     -);
+
+FUNCTOR_BINARY_OPERATOR_C_IMPL(TEqualTo,      ==);
+FUNCTOR_BINARY_OPERATOR_C_IMPL(TNotEqualTo,   !=);
+FUNCTOR_BINARY_OPERATOR_D_IMPL(TGreater,      > );
+FUNCTOR_BINARY_OPERATOR_D_IMPL(TLess,         < );
+FUNCTOR_BINARY_OPERATOR_D_IMPL(TGreaterEqual, >=);
+FUNCTOR_BINARY_OPERATOR_D_IMPL(TLessEqual,    <=);
+
+FUNCTOR_BINARY_OPERATOR_B_IMPL(TLogicalAnd, &&);
+FUNCTOR_BINARY_OPERATOR_B_IMPL(TLogicalOr,  ||);
+FUNCTOR_UNARY_OPERATOR_B_IMPL (TLogicalNot, ! );
+
+FUNCTOR_BINARY_OPERATOR_A_IMPL(TBitAnd, &);
+FUNCTOR_BINARY_OPERATOR_A_IMPL(TBitOr,  |);
+FUNCTOR_BINARY_OPERATOR_A_IMPL(TBitXor, ^);
+FUNCTOR_UNARY_OPERATOR_A_IMPL (TBitNot, ~);
+
+#undef FUNCTOR_BINARY_OPERATOR_D_IMPL
+#undef FUNCTOR_BINARY_OPERATOR_C_IMPL
+
+#undef FUNCTOR_BINARY_OPERATOR_B_IMPL
+#undef FUNCTOR_UNARY_OPERATOR_B_IMPL
+
+#undef FUNCTOR_BINARY_OPERATOR_A_IMPL
+#undef FUNCTOR_UNARY_OPERATOR_A_IMPL
+
+#undef FUNCTOR_BINARY_OPERATOR_IMPL
+#undef FUNCTOR_UNARY_OPERATOR_IMPL
+
 NAMESPACE_MODULE_END(Utility)
 NAMESPACE_MODULE_END(Redcraft)
 NAMESPACE_REDCRAFT_END
diff --git a/Redcraft.Utility/Source/Public/Templates/Invoke.h b/Redcraft.Utility/Source/Public/Templates/Invoke.h
index 34e213f..844a9b4 100644
--- a/Redcraft.Utility/Source/Public/Templates/Invoke.h
+++ b/Redcraft.Utility/Source/Public/Templates/Invoke.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "CoreTypes.h"
+#include "Templates/Utility.h"
 #include "TypeTraits/TypeTraits.h"
 
 NAMESPACE_REDCRAFT_BEGIN
@@ -13,6 +14,7 @@ struct InvokeFunction
 {
 	template <typename F, typename... Types>
 	static auto Invoke(F&& Object, Types&&... Args)
+		-> decltype(Forward<F>(Object)(Forward<Types>(Args)...))
 	{
 		return Forward<F>(Object)(Forward<Types>(Args)...);
 	}
@@ -21,15 +23,15 @@ struct InvokeFunction
 struct InvokeMemberFunction
 {
 	template <typename F, typename ObjectType, typename... Types>
-	static auto Invoke(F&& Func, ObjectType&& Object, Types&&... Args) ->
-		decltype((Forward<ObjectType>(Object)->*Func)(Forward<Types>(Args)...))
+	static auto Invoke(F&& Func, ObjectType&& Object, Types&&... Args)
+		-> decltype((Forward<ObjectType>(Object)->*Func)(Forward<Types>(Args)...))
 	{
 		return (Forward<ObjectType>(Object)->*Func)(Forward<Types>(Args)...);
 	}
 
 	template <typename F, typename ObjectType, typename... Types>
-	static auto Invoke(F&& Func, ObjectType&& Object, Types&&... Args) ->
-		decltype((Forward<ObjectType>(Object).*Func)(Forward<Types>(Args)...))
+	static auto Invoke(F&& Func, ObjectType&& Object, Types&&... Args)
+		-> decltype((Forward<ObjectType>(Object).*Func)(Forward<Types>(Args)...))
 	{
 		return (Forward<ObjectType>(Object).*Func)(Forward<Types>(Args)...);
 	}
@@ -38,15 +40,15 @@ struct InvokeMemberFunction
 struct InvokeMemberObject
 {
 	template <typename F, typename ObjectType>
-	static auto Invoke(F&& Func, ObjectType&& Object) ->
-		decltype(Forward<ObjectType>(Object)->*Func)
+	static auto Invoke(F&& Func, ObjectType&& Object)
+		-> decltype(Forward<ObjectType>(Object)->*Func)
 	{
 		return (Forward<ObjectType>(Object)->*Func);
 	}
 
 	template <typename F, typename ObjectType>
-	static auto Invoke(F&& Func, ObjectType&& Object) ->
-		decltype(Forward<ObjectType>(Object).*Func)
+	static auto Invoke(F&& Func, ObjectType&& Object)
+		-> decltype(Forward<ObjectType>(Object).*Func)
 	{
 		return (Forward<ObjectType>(Object).*Func);
 	}