Do Equatable actually need to be immutable about equatable HOT 1 CLOSED

void main() {
  final setWithImmutable = HashSet<_EquatableTest>();
  final setWithMutable = HashSet<_EquatableTestNonImmutable>();

  final immutableObj = _EquatableTest(values: HashSet.from([1, 2, 3]));
  final mutableObj = _EquatableTestNonImmutable(values: HashSet.from([1, 2, 3]));

  // Add objects to sets
  setWithImmutable.add(immutableObj);
  setWithMutable.add(mutableObj);

  print('Before mutation:');
  print('Immutable set contains object: ${setWithImmutable.contains(immutableObj)}');  // Should print true
  print('Mutable set contains object: ${setWithMutable.contains(mutableObj)}');  // Should print true

  // Mutate the internal state of the objects
  final mutatedImmutableObj = immutableObj.copyWith(values: HashSet.from([4, 5, 6]));
  mutableObj.values = HashSet.from([4, 5, 6]);

  print('After mutation:');
  print('Immutable set contains object: ${setWithImmutable.contains(immutableObj)}');  // Should still print true
  print('Mutable set contains object: ${setWithMutable.contains(mutableObj)}');  // Should print false
}

class _EquatableTest extends Equatable {
  final HashSet values;

  const _EquatableTest({required this.values});

  @override
  List<Object?> get props => [values];

  _EquatableTest copyWith({
    HashSet? values,
  }) {
    return _EquatableTest(
      values: values ?? this.values,
    );
  }
}

class _EquatableTestNonImmutable extends Equatable {
  HashSet values;

  _EquatableTestNonImmutable({required this.values});

  @override
  List<Object?> get props => [values];
}

void main() {
  // Mutable object test
  final mutableSet = <_Mutable>{};
  final mutable = _Mutable(value: 1);
  
  // Add mutable object to set
  mutableSet.add(mutable);
  print('Mutable contains before mutation: ${mutableSet.contains(mutable)}'); // Output: true
  
  // Mutate object
  mutable.value = 2;
  
  // Check if set still contains the object
  print('Mutable contains after mutation: ${mutableSet.contains(mutable)}'); // Output: false

  // Immutable object test
  final immutableSet = <_Immutable>{};
  var immutable = _Immutable(value: 1);

  // Add immutable object to set
  immutableSet.add(immutable);
  print('Immutable contains before mutation: ${immutableSet.contains(immutable)}'); // Output: true

  // "Mutate" object by creating a new one
  immutable = immutable.copyWith(value: 2);

  // Check if set still contains the object
  print('Immutable contains after mutation: ${immutableSet.contains(immutable)}'); // Output: false

  // Check if set still contains the original object
  print('Immutable contains original after mutation: ${immutableSet.contains(_Immutable(value: 1))}'); // Output: true
}

class _Mutable {
  int value;
  _Mutable({required this.value});
  
  @override
  int get hashCode => value;
  
  @override
  bool operator ==(Object other) =>
      identical(this, other) || (other is _Mutable && other.value == value);
}

class _Immutable {
  final int value;
  _Immutable({required this.value});

  _Immutable copyWith({int? value}) {
    return _Immutable(value: value ?? this.value);
  }
  
  @override
  int get hashCode => value;
  
  @override
  bool operator ==(Object other) =>
      identical(this, other) || (other is _Immutable && other.value == value);
}