Refactor Value's PartialEq into single match expression

Author: arbroween

src/value.rs

@@ -1,13 +1,13 @@
 use crate::environment::Environment;
 use crate::ifn::IFn;
+use crate::keyword::Keyword;
 use crate::lambda;
 use crate::maps::MapEntry;
 use crate::persistent_list::PersistentList::Cons;
 use crate::persistent_list::{PersistentList, ToPersistentList, ToPersistentListIter};
 use crate::persistent_list_map::{PersistentListMap, ToPersistentListMapIter};
 use crate::persistent_vector::PersistentVector;
 use crate::symbol::Symbol;
-use crate::keyword::Keyword;
 use crate::type_tag::TypeTag;
 
 extern crate rand;
@@ -70,110 +70,29 @@ impl PartialEq for Value {
  // @TODO implement our generic IFns some other way? After all, again, this isn't Java
  fn eq(&self, other: &Value) -> bool {
  //
- if let I32(i) = self {
- if let I32(i2) = other {
- return i == i2;
- }
- }
-
- if let F64(d) = self {
- if let F64(d2) = other {
- return d == d2;
- }
- }
-
- if let Boolean(b) = self {
- if let Boolean(b2) = other {
- return b == b2;
- }
- }
-
- if let Symbol(sym) = self {
- if let Symbol(sym2) = other {
- return sym == sym2;
- }
- }
-
-if let Keyword(kw) = self {
- if let Keyword(kw2) = other {
- return kw == kw2;
- }
- }
- // Equality not defined on functions, similar to Clojure
- // Change this perhaps? Diverge?
- if let IFn(_) = self {
- if let IFn(_) = other {
- return false;
- }
- }
- // Is it misleading for equality to sometimes work?
- if let LexicalEvalFn = self {
- if let LexicalEvalFn = other {
- return true;
- }
- }
-
- if let PersistentList(plist) = self {
- if let PersistentList(plist2) = other {
- return plist == plist2;
- }
- }
-
- if let PersistentVector(pvector) = self {
- if let PersistentVector(pvector2) = other {
- return *pvector == *pvector2;
- }
+ match (self, other) {
+ (I32(i), I32(i2)) => i == i2,
+ (F64(d), F64(d2)) => d == d2,
+ (Boolean(b), Boolean(b2)) => b == b2,
+ (Symbol(sym), Symbol(sym2)) => sym == sym2,
+ (Keyword(kw), Keyword(kw2)) => kw == kw2,
+ // Equality not defined on functions, similar to Clojure
+ // Change this perhaps? Diverge?
+ (IFn(_), IFn(_)) => false,
+ // Is it misleading for equality to sometimes work?
+ (LexicalEvalFn, LexicalEvalFn) => true,
+ (PersistentList(plist), PersistentList(plist2)) => plist == plist2,
+ (PersistentVector(pvector), PersistentVector(pvector2)) => *pvector == *pvector2,
+ (PersistentListMap(plistmap), PersistentListMap(plistmap2)) => *plistmap == *plistmap2,
+ (Condition(msg), Condition(msg2)) => msg == msg2,
+ (QuoteMacro, QuoteMacro) => true,
+ (DefmacroMacro, DefmacroMacro) => true,
+ (DefMacro, DefMacro) => true,
+ (LetMacro, LetMacro) => true,
+ (String(string), String(string2)) => string == string2,
+ (Nil, Nil) => true,
+ _ => false,
  }
-
- if let PersistentListMap(plistmap) = self {
- if let PersistentListMap(plistmap2) = other {
- return *plistmap == *plistmap2;
- }
- }
-
- if let Condition(msg) = self {
- if let Condition(msg2) = other {
- return msg == msg2;
- }
- }
-
- if let QuoteMacro = self {
- if let QuoteMacro = other {
- return true;
- }
- }
-
- if let DefmacroMacro = self {
- if let DefmacroMacro = other {
- return true;
- }
- }
-
- if let DefMacro = self {
- if let DefMacro = other {
- return true;
- }
- }
-
- if let LetMacro = self {
- if let LetMacro = other {
- return true;
- }
- }
-
- if let String(string) = self {
- if let String(string2) = other {
- return string == string2;
- }
- }
-
- if let Nil = self {
- if let Nil = other {
- return true;
- }
- }
-
- false
  }
 }
 
@@ -197,7 +116,7 @@ impl Hash for Value {
  F64(d) => d.to_value().hash(state),
  Boolean(b) => b.hash(state),
  Symbol(sym) => sym.hash(state),
- Keyword(kw) => kw.hash(state),
+  Keyword(kw) => kw.hash(state),
  IFn(_) => {
  let mut rng = rand::thread_rng();
  let n2: u16 = rng.gen();
@@ -235,7 +154,7 @@ impl fmt::Display for Value {
  F64(val) => val.to_string(),
  Boolean(val) => val.to_string(),
  Symbol(sym) => sym.to_string(),
- Keyword(kw) => kw.to_string(),
+  Keyword(kw) => kw.to_string(),
  IFn(_) => std::string::String::from("#function[]"),
  LexicalEvalFn => std::string::String::from("#function[lexical-eval*]"),
  PersistentList(plist) => plist.to_string(),
@@ -275,7 +194,7 @@ impl Value {
  Value::F64(_) => TypeTag::F64,
  Value::Boolean(_) => TypeTag::Boolean,
  Value::Symbol(_) => TypeTag::Symbol,
- Value::Keyword(_) => TypeTag::Keyword,
+  Value::Keyword(_) => TypeTag::Keyword,
  Value::IFn(_) => TypeTag::IFn,
  Value::LexicalEvalFn => TypeTag::IFn,
  Value::PersistentList(_) => TypeTag::PersistentList,