Equals method
From CodeCodex
Contents
Implementations[edit]
C++[edit]
class Foo { private: string str; int i; [...] public: bool operator==(const Foo& x) { if (str != x.str) return false; if (i != x.i) return false; [...] return true; } [...] }
Haskell[edit]
Haskell has a type class called Eq which says that a type can be compared for equality. It specifies the operators "==" (equals) and "/=" (not equals); you only need to override one of them.
If you want Haskell to automatically generate a default equality operator for your type, you can simply "derive" the Eq class when you define the type:
data Foo = Bar | Baz deriving (Eq)
If you want to provide your own equality operator, you can instead instantiate the Eq class yourself:
instance Eq Foo where Bar == Bar = True Baz == Baz = True _ == _ = False
Java[edit]
class Foo { private String name; private int i; [...] public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Foo)) return false; Foo other = (Foo) o; if (name != null ? !name.equals(other.name) : other.name != null) return false; if (i != other.i) return false; [...] return true; } // Note: after overriding the equals() method, you must also override the hashCode() // method to be consistent with equals() (i.e. two objects' hashCode() need to be the // same if they are equal. }
Objective-C[edit]
@interface Foo { NSString *name; int i; } [...] @end @implementation Foo - (BOOL)isEqual:(id)o { if (self == o) return YES; if (![o isKindOfClass:[Foo class]]) return NO; Foo *other = (Foo *) o; if (name != nil ? ![name isEqual:other->name] : other->name != nil) return NO; if (i != other->i) return NO; [...] return YES; } // Note: after overriding the isEqual: method, you must also override the hash // method to be consistent with isEqual: (i.e. two objects' hashes need to be the // same if they are equal. @end
OCaml[edit]
OCaml has built-in polymorphic structural equality:
# (=);; - : 'a -> 'a -> 'bool = <fun>
which has the advantage that you do not need to declare equality for types but has the disadvantage that you cannot overload equality for certain types (e.g. balanced binary trees, where structural equality and semantic equality are not the same). Instead, you must discipline yourself to use the appropriate equality function.
Ruby[edit]
Equality―At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendant classes to provide class-specific meaning.
Unlike ==, the equal? method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b) if a is the same object as b).
The eql? method returns true if obj and anObject have the same value. Used by Hash to test members for equality. For objects of class Object, eql? is synonymous with ==. Subclasses normally continue this tradition, but there are exceptions. Numeric types, for example, perform type conversion across ==, but not across eql?
Original source : [1]
class Foo attr_accessor :value # The equivalence confirmation def ==(other) @value == other.value end # The equivalence confirmation (Numeric doesn't do a type conversion). def eql?(other) @value.eql?(other.value) end end a = Foo.new a.value = 1 b = Foo.new b.value = 1.0 p a == b #=> true p a.equal?(b) #=> false p a.eql?(b) #=> false
Standard ML[edit]
Standard ML has built-in polymorphic structural equality:
- op =; stdIn:1.1-1.5 Warning: calling polyEqual val it = fn : ''a * ''a -> bool
You can only use "=" on types that are declared to be "eqtypes". The two quotes before the type variable denotes that the type variable must be an eqtype. Most common types are eqtypes, and most datatypes that you define should be declared to be eqtypes. Note that "real" (the floating-point type) is not an eqtype, so cannot be compared with "=".
Another disadvantage with this setup is that you cannot overload equality for certain types (e.g. balanced binary trees, where structural equality and semantic equality are not the same). If you wanted to define a custom equality, you would typically make your type not an eqtype (so that they won't accidentally use "="), and then define a separate operator, like "==".