cynic-parser: implement PartialEq for Type and Value (#924)

I am conflicted on whether this should be PartialEq or a method, but
since there is only one useful way to compare {types,values}, I went
with PartialEq, as well as Eq for types (Value has a Float variant).

cynic-parser/src/executable/types.rs

@@ -16,6 +16,14 @@ pub struct TypeRecord {
 #[derive(Clone, Copy)]
 pub struct Type<'a>(ReadContext<'a, TypeId>);
 
+impl PartialEq for Type<'_> {
+ fn eq(&self, other: &Self) -> bool {
+ self.name() == other.name() && self.wrappers().eq(other.wrappers())
+ }
+}
+
+impl Eq for Type<'_> {}
+
 impl<'a> Type<'a> {
  pub fn name(&self) -> &'a str {
  self.0

cynic-parser/src/executable/value.rs

@@ -33,6 +33,32 @@ pub enum Value<'a> {
  Object(Vec<(&'a str, Value<'a>)>),
 }
 
+impl PartialEq for Value<'_> {
+ fn eq(&self, other: &Self) -> bool {
+ match (self, other) {
+ (Value::Int(a), Value::Int(b)) => a == b,
+ (Value::Variable(a), Value::Variable(b)) => a == b,
+ (Value::Float(a), Value::Float(b)) => a == b,
+ (Value::String(a), Value::String(b)) => a == b,
+ (Value::Boolean(a), Value::Boolean(b)) => a == b,
+ (Value::Null, Value::Null) => true,
+ (Value::Enum(a), Value::Enum(b)) => a == b,
+ (Value::List(a), Value::List(b)) => a == b,
+ (Value::Object(a), Value::Object(b)) => {
+ a.len() == b.len()
+ && a.iter().all(|(name, value)| {
+ let Some((_, b_value)) = b.iter().find(|(b_name, _)| b_name == name) else {
+ return false;
+ };
+
+ value == b_value
+ })
+ }
+ _ => false,
+ }
+ }
+}
+
 impl ExecutableId for ValueId {
  type Reader<'a> = Value<'a>;
 }

cynic-parser/src/type_system/types.rs

@@ -14,6 +14,14 @@ pub struct TypeRecord {
 #[derive(Clone, Copy)]
 pub struct Type<'a>(ReadContext<'a, TypeId>);
 
+impl PartialEq for Type<'_> {
+ fn eq(&self, other: &Self) -> bool {
+ self.name() == other.name() && self.wrappers().eq(other.wrappers())
+ }
+}
+
+impl Eq for Type<'_> {}
+
 impl<'a> Type<'a> {
  pub fn name(&self) -> &'a str {
  self.0

cynic-parser/src/type_system/values.rs

@@ -29,6 +29,35 @@ pub enum Value<'a> {
  Object(Vec<(&'a str, Value<'a>)>),
 }
 
+impl PartialEq for Value<'_> {
+ fn eq(&self, other: &Self) -> bool {
+ match (self, other) {
+ (Value::Int(a), Value::Int(b)) => a == b,
+ (Value::Variable(a), Value::Variable(b)) => a == b,
+ (Value::Float(a), Value::Float(b)) => a == b,
+ (Value::String(a), Value::BlockString(b))
+ | (Value::String(a), Value::String(b))
+ | (Value::BlockString(a), Value::String(b))
+ | (Value::BlockString(a), Value::BlockString(b)) => a == b,
+ (Value::Boolean(a), Value::Boolean(b)) => a == b,
+ (Value::Null, Value::Null) => true,
+ (Value::Enum(a), Value::Enum(b)) => a == b,
+ (Value::List(a), Value::List(b)) => a == b,
+ (Value::Object(a), Value::Object(b)) => {
+ a.len() == b.len()
+ && a.iter().all(|(name, value)| {
+ let Some((_, b_value)) = b.iter().find(|(b_name, _)| b_name == name) else {
+ return false;
+ };
+
+ value == b_value
+ })
+ }
+ _ => false,
+ }
+ }
+}
+
 impl<'a> Value<'a> {
  pub fn as_str(&self) -> Option<&'a str> {
  match self {