A modern programming language that makes developers happier.

kotlinlang

Is it possible to create Kotlin `Map` where key is `String` and case insensitive?

If anything, you might just want to process it before like `mapName[keyName.toLowerCase()]` or something

Maybe make your own Map doing that preprocessing

You could also create you own key type:
```
class LowerCase(val value: String) {
  // write your own equals and hashCode to make it case insensitive
}
```
and have some nice toplevel or extension function to create a LowerCase from a String

Just wrap the String into a data class that extends from Comparator and then implement the compators

`Comparator`? That's not really necessary here, right?

The thing is, AWS does some magic when mapping requests to the open class request contract. Can’t find a way to intervene that process. Going to check key type <@U72C3TBDH> – looks promising

On Android be very careful with toLowerCase(). It'll use the default locale and on e.g. Turkish devices the `i` will be replaced with `ı`.

Sorry I had a lapsus, it is enough with hashCode and Equeals

```
data class HeaderName(val key: String) {

    override fun hashCode() = key.toLowerCase().hashCode()

    override fun equals(other: Any?): Boolean {
        return this.hashCode() == other.hashCode()
    }
}
```

Looks good?

Also now you're using the default locale instead of a fixed one.

I mean, depending on the use, they could be unique enough, right?

And you don't do type checking in `equals` at all, there's a bunch of stuff you need to check there.

Now I’m really confused. I opened REPL and made to strings that are similar, and did hashCode(), they are the same.

<@U78L28DMX> Depending on hashcodes of strings being distinct is a terrible idea, there are lots of 3-letter collision examples.

What you have now will always say equal strings are equal, but there are also non-equal things that it's going to say are equal.

Yeah, to <@U5UU34LPK> point, I'm not sure why there are unique keys being made if they're not case sensitive

I think this is correct:
```class HeaderName(val key: String) {
	override fun hashCode() = key.toLowerCase(Locale.ROOT).hashCode()

	override fun equals(other: Any?): Boolean {
		if (this === other) return true
		if (javaClass != other?.javaClass) return false
		other as HeaderName
		
		return key.toLowerCase(Locale.ROOT) == other.key.toLowerCase(Locale.ROOT)
	}
}
```

You can also keep the `toLowerCase` result:
```
class HeaderName(key: String) {
	val key = key.toLowerCase(Locale.ROOT)
	
	override fun hashCode() = key.hashCode()

	override fun equals(other: Any?): Boolean {
		if (this === other) return true
		if (javaClass != other?.javaClass) return false
		other as HeaderName

		return key == other.key
	}
}
```