diff --git a/include/asenum/asenum.h b/include/asenum/asenum.h
index 2650360..27f34ea 100644
--- a/include/asenum/asenum.h
+++ b/include/asenum/asenum.h
@@ -60,8 +60,11 @@ namespace asenum
         
         template <typename T, typename Enum, typename ConcreteAsEnum, Enum... Types>
         class AsMap;
+		
+		template <typename ConcreteAsEnum, typename... T_Cases>
+		struct Comparator;
     }
-    
+	
     /**
      @class Associated Enum type.
      AsEnum should be specialized with single or multiple 'Case/Case11' types that represent associations.
@@ -138,6 +141,20 @@ namespace asenum
 		 */
         template <typename T>
 		details::AsMap<T, Enum, AsEnum<T_Cases...>> doMap() const;
+		
+		/**
+		 Compares two AsEnum instances. Instance meant to be equal if and only if
+		 1) Underlying enum cases are equal;
+		 2) Underlying values are equal.
+		 */
+		bool operator==(const AsEnum& other) const;
+		
+		/**
+		 Compares two AsEnum instances. Instance meant to be equal if and only if
+		 1) Underlying enum cases are equal;
+		 2) Underlying values are equal.
+		 */
+		bool operator!=(const AsEnum& other) const;
         
     private:
         AsEnum(const Enum relatedCase, std::shared_ptr<void> value);
@@ -299,7 +316,41 @@ namespace asenum
             using type = typename TypeMap<Value, Dummy, Cases...>::type;
             static_assert(!std::is_same<type, Dummy>::value, "Type is missing for specified enum value.");
         };
-        
+		
+		template <typename ConcreteAsEnum, typename T_Case>
+		struct Comparator<ConcreteAsEnum, T_Case>
+		{
+			template <typename T>
+			static bool	compare(const ConcreteAsEnum& first, const ConcreteAsEnum& second)
+			{
+				return first.template forceAsCase<T_Case::Code>() == second.template forceAsCase<T_Case::Code>();
+			}
+			
+			template <>
+			static bool	compare<void>(const ConcreteAsEnum&, const ConcreteAsEnum&)
+			{
+				return true;
+			}
+			
+			static bool	compare(const ConcreteAsEnum& first, const ConcreteAsEnum& second)
+			{
+				if (first.enumCase() != T_Case::Code || second.enumCase() != T_Case::Code)
+				{
+					return false;
+				}
+				
+				return compare<typename T_Case::Type>(first, second);
+			}
+		};
+		
+		template <typename ConcreteAsEnum, typename T_Case, typename... T_Cases>
+		struct Comparator<ConcreteAsEnum, T_Case, T_Cases...>
+		{
+			static bool compare(const ConcreteAsEnum& first, const ConcreteAsEnum& second)
+			{
+				return Comparator<ConcreteAsEnum, T_Case>::compare(first, second) || Comparator<ConcreteAsEnum, T_Cases...>::compare(first, second);
+			}
+		};
     }
 }
 
@@ -381,6 +432,18 @@ asenum::details::AsMap<T, typename asenum::AsEnum<T_Cases...>::Enum, asenum::AsE
 	return details::AsMap<T, Enum, AsEnum<T_Cases...>>(*this);
 }
 
+template <typename... T_Cases>
+bool asenum::AsEnum<T_Cases...>::operator==(const AsEnum& other) const
+{
+	return details::Comparator<AsEnum, T_Cases...>::compare(*this, other);
+}
+
+template <typename... T_Cases>
+bool asenum::AsEnum<T_Cases...>::operator!=(const AsEnum& other) const
+{
+	return !(*this == other);
+}
+
 
 // AsEnum private
 
@@ -404,7 +467,6 @@ typename std::enable_if<!std::is_same<T, void>::value, void>::type asenum::AsEnu
     handler(*reinterpret_cast<const T*>(value));
 }
 
-
 // Private details - AsSwitch
 
 template <typename Enum, typename ConcreteAsEnum, Enum... Types>
diff --git a/tests/AsEnumTest.cpp b/tests/AsEnumTest.cpp
index 20505da..75385f5 100644
--- a/tests/AsEnumTest.cpp
+++ b/tests/AsEnumTest.cpp
@@ -203,13 +203,30 @@ TEST(AsEnum, Map_All_Cases)
 
 TEST(AsEnum, ForceAsCase)
 {
-    const TestAsEnum value1 = TestAsEnum::create<TestEnum::StringOpt>("test");
-    // TestEnum::VoidOpt doesn't have 'forceAsEnum' method because associated type is 'void'.
-    const TestAsEnum value3 = TestAsEnum::create<TestEnum::Unknown>(-100500);
+	const TestAsEnum value1 = TestAsEnum::create<TestEnum::StringOpt>("test");
+	// TestEnum::VoidOpt doesn't have 'forceAsEnum' method because associated type is 'void'.
+	const TestAsEnum value3 = TestAsEnum::create<TestEnum::Unknown>(-100500);
+	
+	EXPECT_EQ(value1.forceAsCase<TestEnum::StringOpt>(), "test");
+	EXPECT_THROW(value1.forceAsCase<TestEnum::Unknown>(), std::invalid_argument);
+	
+	EXPECT_THROW(value3.forceAsCase<TestEnum::StringOpt>(), std::invalid_argument);
+	EXPECT_EQ(value3.forceAsCase<TestEnum::Unknown>(), -100500);
+}
+
+TEST(AsEnum, Compare)
+{
+	const TestAsEnum value1 = TestAsEnum::create<TestEnum::StringOpt>("test");
+	const TestAsEnum value2 = TestAsEnum::create<TestEnum::StringOpt>("test");
+	const TestAsEnum value3 = TestAsEnum::create<TestEnum::StringOpt>("test2");
+	const TestAsEnum value4 = TestAsEnum::create<TestEnum::VoidOpt>();
+	const TestAsEnum value5 = TestAsEnum::create<TestEnum::Unknown>(-100500);
 	
-    EXPECT_EQ(value1.forceAsCase<TestEnum::StringOpt>(), "test");
-    EXPECT_THROW(value1.forceAsCase<TestEnum::Unknown>(), std::invalid_argument);
+	EXPECT_EQ(value1, value1);
+	EXPECT_EQ(value1, value2);
+	EXPECT_NE(value1, value3);
+	EXPECT_NE(value1, value4);
+	EXPECT_NE(value1, value5);
 	
-    EXPECT_THROW(value3.forceAsCase<TestEnum::StringOpt>(), std::invalid_argument);
-    EXPECT_EQ(value3.forceAsCase<TestEnum::Unknown>(), -100500);
+	EXPECT_EQ(value4, TestAsEnum::create<TestEnum::VoidOpt>());
 }