# equatable 3.0.0-dev.0
A Dart package that helps to implement value based equality without needing to explicitly override == and hashCode.
## Installing
```
export PUB_HOSTED_URL=https://pub.mirror.p-hatan.com
flutter pub add 'equatable:3.0.0-dev.0'
```
Published: 2024-10-16T02:06:20.810131Z
Expected archive SHA-256: 4f531ad0dc4076cab07fec5ef112d6244c217cc97c2c211d5a27f3e20783980a
Available in cache; verification: upstream_checksum
## Direct dependencies
- collection: ^1.0.0
- macros: ^0.1.0-main.5
## Package README (untrusted upstream documentation)
Simplify Equality Comparisons
---
## Overview
Being able to compare objects in `Dart` often involves having to override the `==` operator as well as `hashCode`.
Not only is it verbose and tedious, but failure to do so can lead to inefficient code which does not behave as we expect.
By default, `==` returns true if two objects are the same instance.
Let's say we have the following class:
```dart
class Person {
const Person(this.name);
final String name;
}
```
We can create instances of `Person` like so:
```dart
void main() {
final Person bob = Person("Bob");
}
```
Later if we try to compare two instances of `Person` either in our production code or in our tests we will run into a problem.
```dart
print(bob == Person("Bob")); // false
```
For more information about this, you can check out the official [Dart Documentation](https://www.dartlang.org/guides/language/effective-dart/design#equality).
In order to be able to compare two instances of `Person` we need to change our class to override `==` and `hashCode` like so:
```dart
class Person {
const Person(this.name);
final String name;
@override
bool operator ==(Object other) =>
identical(this, other) ||
other is Person &&
runtimeType == other.runtimeType &&
name == other.name;
@override
int get hashCode => name.hashCode;
}
```
Now if we run the following code again:
```dart
print(bob == Person("Bob")); // true
```
it will be able to compare different instances of `Person`.
You can see how this can quickly become a hassle when dealing with complex classes. This is where `Equatable` comes in!
## What does Equatable do?
`Equatable` overrides `==` and `hashCode` for you so you don't have to waste your time writing lots of boilerplate code.
## Usage
First, we need to do add `equatable` to the dependencies of the `pubspec.yaml`
```yaml
dependencies:
equatable: ^3.0.0-dev.0
```
Next, we need to install it:
```sh
# Dart
dart pub get
# Flutter
flutter packages get
```
Lastly, we need to add the `@Equatable` annotation.
```dart
import 'package:equatable/equatable.dart';
@Equatable()
class Person {
const Person(this.name);
final String name;
}
```
We can now compare instances of `Person` just like before without the pain of having to write all of that boilerplate.
**Note:** Equatable is designed to only work with immutable objects so all member variables must be final (This is not just a feature of `Equatable` - [overriding a `hashCode` with a mutable value can break hash-based collections](https://dart.dev/guides/language/effective-dart/design#avoid-defining-custom-equality-for-mutable-classes)).
## Recap
### Without Equatable
```dart
class Person {
const Person(this.name);
final String name;
@override
bool operator ==(Object other) =>
identical(this, other) ||
other is Person &&
runtimeType == other.runtimeType &&
name == other.name;
@override
int get hashCode => name.hashCode;
}
```
### With Equatable
```dart
import 'package:equatable/equatable.dart';
@Equatable()
class Person {
const Person(this.name);
final String name;
}
```
## Benchmarks
You can check out and run performance benchmarks by heading over to [benchmarks](./benchmarks);
## Maintainers
- [Felix Angelov](https://github.com/felangel)
## Changelog
# 3.0.0-dev.0
- **BREAKING** feat!: rewrite using [macros](https://dart.dev/language/macros)
**Before**
```dart
class Person extends Equatable {
const Person({required this.name});
final String name;
@override
List
