Here's a fun list/map etc challenge i came across ...

# announcements

[Nir]

Here's a fun list/map etc challenge i came across in a question in the python slack. Someone was asking how to do this in a dict comprehension, instead of with looping in python:

[
        ("carrot", ["orange"]),
        ("banana", ["green", "yellow", "black"]),
        ("lemon", ["green", "yellow"]),
        ("apple", ["red", "green"]),
]

to

{
    'orange': ['carrot'],
   'green': ['banana', 'lemon', 'apple'],
   'yellow': ['banana', 'lemon'],
   'black': ['banana'],
   'red': ['apple']
}

I was able to get it but it's pretty ugly. I tried to think whether there's anything substantially nicer in kotlin, and I couldn't think of anything. Curious to see what folks come up with 🙂

[Hullaballoonatic]

There's no tuple type in kotlin, so assuming those are comping in as a list of pairs, this is as simple as:

elements.toMap()

[Shawn]

that’s not the transform at all though

[Hullaballoonatic]

oh, i guess i didn't read the contents, ha

[Hullaballoonatic]

yeah, i should read <_<

[Nir]

Just assume the first thing is a list of pairs of string, list of string

[Nir]

Second is a map from string to list of string

[Hullaballoonatic]

elements.map { it.second }
        .flatten()
        .associateBy { k -> elements.filter { k in it.second }
                                    .map { it.first } }

that's my first go 😮

[Hullaballoonatic]

i think there's probably a more efficient way to do it with grouping or something

[Nir]

I was thinking about it. It's not easy though. The classic for loop and mutation looks pretty good here

[Hullaballoonatic]

yeah, i think the best way to do it and by-far the easiest to read is a for-loop

[Mark Spindler]

Casey, I think you might have meant "associateWith" for the map to go in the right direction. But other than that I came up with an identical approach.

[Hullaballoonatic]

It's annoying that JB called these methods associate instead of just toMap

[Nir]

Probably worried that it was too similar to map

[Hullaballoonatic]

yep, overloaded word!

[Nir]

The real tragedy is that the data structures produced by map and associate are "basically" immutable

[Nir]

Since they are the only reference to the produced structure, and they are read only

[Nir]

Yet it's not reflected in the type system

[Nir]

map should return an ImmutableList

[Nir]

Which is an interface that refines List

[Hullaballoonatic]

could have done the sql/c# naming for map :`select`
or the c#/python naming for Map :`Dictionary`

[Nir]

I do like dictionary

[Hullaballoonatic]

same

[Hullaballoonatic]

Or maybe just Mapping

[Nir]

Mapping is what python calls the interfaces

[Mark Spindler]

Confusingly (when I switch between things), " Select " is what Mathematica calls filter, but Association is basically mapOf (and then AssociationMap is associateWith ).

[Hullaballoonatic]

yeah i understand calling filter select, but then you have c# calling filter where and map select and suddenly going between languages gets really annoying

[Ruckus]

There are only two hard things in Computer Science: cache invalidation and naming things.

-- Phil Karlton

[Pit]

elements
        .flatMap { (fruit, colours) -> colours.map { fruit to it } }
        .groupBy(Pair<*, String>::second, Pair<String, *>::first)

the types are a bit ugly though