Object equality vs uniqueness

In my hobby Kotlin project I've run into dilema how to implement equals() method in case of a class like:

// I'm using Kotlin-like syntax    
class ConfigurationParameter {
	val name: String	// used for command line option, *.conf file parameter, ENV variable, ...
	val allowedValues: Set<String>		// the valid values of the configuration parameter
	val description: String		// used in --help, as a comment above parameter in *.conf file, ...
}

Equality

Now, from my POV, two objects of this class are equal only if they are equal in all their properties. Otherwise they would beheave differently:

• In case of name ... that's completely other parameter.
• In case of allowedValues ... the validation would differ.
• In case of description ... the printed usage help would differ.

Uniqueness

At the same time I don't want two objects with just the same name (but possibly with distinct allowedValues or description) to appear in one set (Set<ConfigurationParameter>).
That would lead to problems like duplicate command line options and the like.

This should not happen

I'm aware of there should not be created two configuration parameters with the same name and distinct other properties in the application in the first place. But let's consider this to be some internal self-check mechanism.

Solution

The only solution I've come at yet is to create a brand new ConfigurationParameterSet (not based on Set) that treats the "sameness" of its items by their name and not by their equals() method.

The problem with this solution is that there must be such a new Set class for every entity class that has equality distinct from its uniqueness.

Question

Is there any well-established generic solution to this equality vs uniqueness dilema?

Instead of your custom set-like class, you can use a Map that uses the name property as the keys. You could also add extension functions so you can use it kind of like a Set. In Java, you'd have to extend the class to add these.

fun MutableMap<String, ConfigurationParameter>.add(parameter: ConfigurationParameter) =
    put(parameter.name, parameter)

fun MutableMap<String, ConfigurationParameter>.remove(parameter: ConfigurationParameter) =
    remove(parameter.name, parameter)

operator fun Map<String, ConfigurationParameter>.contains(parameter: ConfigurationParameter) =
    containsValue(parameter)

If you have lots of classes like this where you want to store them by a name property, you could make an interface with a name property that they can all use and then create the above extension function for any map that uses values that implement the interface:

interface NamedItem { val name: String }

class ConfigurationParameter: NamedItem {
    override val name: String,
    val allowedValues: Set<String>,
    val description: String
}

fun <T: NamedItem> MutableMap<String, T>.add(parameter: T) =
    put(parameter.name, parameter)

fun <T: NamedItem> MutableMap<String, T>.remove(parameter: T) =
    remove(parameter.name, parameter)

operator fun <T: NamedItem> Map<String, T>.contains(parameter: T) =
    containsValue(parameter)

I'm not well versed in Kotlin, but this problem sounds exactly the same in Java. In Java you have two types of equality: (1) reference equality (a == b) where a and b are both references to the same object and (2) hashCode/equals equality. I suspect when you are talking about "uniqueness" that you don't mean reference equality but rather a notion of hash/equals equality where all fields are the same.

What you have isn't a language problem. It's a design problem. You need to decide what makes two objects equal OR take another approach.

So, one way to do this would be to define a method like:

enum Similarity { FULL, NAME }
boolean same(Object object, Similarity similarity)

Then you can call same() from equals() to give the default kind of similarity. You can also imagine making the object sort of modal, where it has a similarity state and the equals method uses that state to decide which kind of similarity to use. The downside of this state is (1) the concern of similarity/equality isn't necessarily best defined by methods in the class itself (separation of concerns) and (2) mutable state is not the best if you can avoid it.

Another, possibly better, approach might be to create two Comparator implementations, where one comparator uses just the name and the other uses all values. This is a very common approach in Java and should be just as easy in Kotlin. Comparators give sort order, but a return value of 0 indicates equality. If you prefer a boolean, you could use the same technique but create an interface like:

interface SimilarityComparator
{
    boolean same(Object a, Object b)
}

BTW, if you implement the comparator as a nested class, you can increase encapsulation by obviating the need to expose property values or fields to allow comparison (property getters and setters are bad, see Alan Holub).

https://www.baeldung.com/java-comparator-comparable

Hopefully this helps.

Jon