A modern programming language that makes developers happier.

kotlinlang

I have this code snippet
```.forEach {
    val (k, v) = it.split(':')
    meta[k.trim()] = v.trim()
}```
I though I could make it more concise with `associateTo`, but I still need two lines
```.associateTo(meta) {
    val (k, v) = it.split(':')
    k.trim() to v.trim()
}```
unless I'm missing something, I'd revert to the first version

you probably could do
```.gropuingBy { it.substringBefore(':').trim() }
.aggregateTo(meta) { _, _, it, _ -&gt; it.split(':')[1].trim() }```
but that you have now is fine and clear enough

```.associateTo(meta) { it.split(':').map(String::trim).zipWithNext().single() }```
This also checks that your value doesn't contain `':'` - not sure if you've dealt with that possibility. You might want `.split(':', limit = 2)`.

there's also the possibility that there is no `:` in the string, in which case the code will fail

Do you really need a mutable map for this? Plain old `associate` is a bit cleaner.

The other advantage of `associateTo` is that it returns the map, but I can’t tell if you’d need that without seeing more context

I didn't know about the split limit option, good to know

in case you may want to have the context, I'm porting <https://github.com/scifio/scifio-lifesci/blob/master/src/main/java/io/scif/lifesci/SDTInfo.java#L470|this code> to Kotlin MP

then
```.filter { ':' in it }
.associateTo(meta) {
    it.substringBefore(':').trim() to
        it.substringAfter(':').trim()
}
```
would be closer to that behavior

I often see using `let` in such situations
```.associateTo(meta) {
    it.split(':').let { (k, v) -&gt; k.trim() to v.trim() }
}```


I don't see a reason to use let instead of val destructuring, but my point was that if the string doesn't contain `:` then the original code treats it as an empty value while split+bind will throw