A modern programming language that makes developers happier.

kotlinlang

Are there any generalized functions like joinToString ? Currently I just need something like a forEach but with a sideeffect between elements.

Something like this?
```.zipWithNext().forEach { (a, b) -&gt; }```


I cant quite get that to work ie.
```listOf(1,2,3).zipWithNext().forEach {  println(it.first); println("-"); println(it.second) }```
Gives
```1-22-3```


There’s also `Iterable&lt;T&gt;.joinTo` where you can provide an appendable buffer to put elements into

<@U1JP5M6LU>, I'm a bit confused, what did you want to get instead of
```1-2
2-3```
?

Oh, I see, then <@U579VR96E>’s answer is correct

Not really. His answer does not take the question into context

I ended up making my own:
```private inline fun &lt;T&gt; Iterable&lt;T&gt;.intersperseEach(separator: () -&gt; Unit = {}, before: () -&gt; Unit = {}, after: () -&gt; Unit = {}, action: (T) -&gt; Unit): Unit {
    val ite = iterator()
    var first = true
    before()
    while (ite.hasNext()) {
        if (first) {
            first = false
        } else {
            separator()
        }
        action(ite.next())
    }
    after()
}```
Seems like it fits in the stdlib imo.

Oh, I see, I'm a bit slow today it seems, sorry :slightly_smiling_face:

I just wanted to ask if there was another function in the stdlib that was close enough.

Yeah I just mentioned another method somewhat relevant to joining. But I’m curious what’s the use case for the method above? It just performs some side effects during iteration, right?

The current case is printing line separators between elements in kotlinx.html ie.:
```&lt;div&gt;&lt;/div&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;/div&gt;```
Pretty standard stuff

Maybe flatten it a little? I am just golfing, now :slightly_smiling_face:
```    val ite = iterator()
    before()
    if (!ite.hasNext()) { after(); return }
    action(ite.next())
    while (ite.hasNext()) {
        separator()
        action(ite.next())
    }
    after()```

And since I am not working with strings joinToString is no good

```val result = mutableListOf&lt;String&gt;()

val input = listOf(1, 2, 3)

val iter = input.iterator()
iter.forEachRemaining {
	result.add(it.toString())
	if (iter.hasNext()) result.add("-")
}
println(result) // gives: [1, -, 2, -, 3]```
Isn't this what you're looking for then?

```fun &lt;T&gt; Iterable&lt;T&gt;.intersperseEach(
   separator: () -&gt; Unit = {},
   before: () -&gt; Unit = {},
   after: () -&gt; Unit = {},
   action: (T) -&gt; Unit
) {
   before()
   val iterator = iterator()
   iterator.forEachRemaining {
      action(it)
      if (iterator.hasNext()) separator()
   }
   after()
}

listOf("&lt;div&gt;&lt;/div&gt;", "&lt;div&gt;&lt;/div&gt;").intersperseEach(
	separator = { println("&lt;br /&gt;") },
	action = ::println
)
// prints:
// &lt;div&gt;&lt;/div&gt;
// &lt;br /&gt;
// &lt;div&gt;&lt;/div&gt;```

<https://youtrack.jetbrains.com/issue/KT-36647> if anyone wants to watch :wink:

thanks for the attribution :slightly_smiling_face:

Is there a point to `before` and `after`? Those could each be replaced with `also`.