What would be the idiomatic/semantic way to define a limited size length of a collection? Given a

data class ChatConversation

, where a chat conversation is always between two users (userId), which type would fit the most? I was thinking about a

val userIds: Set<Int>

but that doesn't enforce the min 2, max 2. Also thought about a

val userIds: Pair<Int, Int>

, but the fact that

Pair(1, 2) == Pair(2, 1)

equals to false makes it a inproper fit given the case here, since a conversation between Bob and Alice should be considered the same as a conversation between Alice and Bob. EDIT: Possible option:

data class TwoSizedSet<T>(val value: Set<T>) {
    init {
        require(value.size == 2)
    }
}

Why use a collection at all? Seems ill-fitted if you know the size ahead of time.

Because it makes querying easier and more semantic I think?

Trying to understand why prefer a collection over

data class TwoSize<T>(val first: T, val second: T)

Wouldn't that be the same as a

Pair<T>

?

although the

equal

semantic of the class I just wrote will be similar to

Pair

so you probably don’t want that

Why would ordering matter in this case?

That was your own requirement:

the fact that

Pair(1, 2) == Pair(2, 1)

equals to false makes it a inproper fit given the case here, since a conversation between Bob and Alice should be considered the same as a conversation between Alice and Bob.

Perhaps there is a misunderstanding in my wording there. I'm basically saying that I wanted that

Pair(1, 2) == Pair(2, 1)

equals to true, which isn't the case. That makes the requirement unordered, instead of ordered. Right?

Never mind

It's a tricky one, isn't it😁.