I’m confused by something. HashMap has a filterKeys (among others) method. But they’re defined as Map interface things. It seems I then have to cast the result back to HashMap, e.g. this.modifyRegistry { registry -> registry.filterKeys { oid -> keepOIDs.contains(oid) } as HashMap } I don’t understand why it doesn’t know that registry is a HashMap<PlanID, Plan>. I’ve typed it that way everywhere. But without that

as Hashmap

I get warnings/errors. I feel like I’m missing some piece of the puzzle that it wasn’t obvious/apparent to me to put the as Hashmap there.

Usually when you apply this kind of transformations you are creating a new collection and you usually can’t assume that the return type will be the same as the original one

If you want a specific resulting collection, you can use the

xxxTo

methods, such as:

val result = myCollection.filterTo(HashMap()) { it > 5 }

No, .toMutableMap() does not work.

Yes,

toMutableMap

will give you a generic

MutableMap

.

yeah, usually there is no reason in directly exposing implementation types

At some point though, if I want to create an actual something, I can’t use an interface, can I? e.g. val Registry = HashMap<PlanID, Plan>() If I replace HashMap with Map, I get a no constructors error. As I then write methods around that, it doesn’t like it if I don’t specify HashMap

mutableMapOf

will give you some map implementation, you don't know which.

It depends if you actually need the hashmap or not

The only guarantee you get is "The returned map preserves the entry iteration order."

yeah, but it depends on the requirements

I need a MutableMap in this case (I’m using [] and remove on it). But I could change those. But the the lightbulb is the declaring it as an interface, but creating it with a concrete type. Sort of a duh actually.