A modern programming language that makes developers happier.

kotlinlang

How do I get a list of two random numbers 6 times? This doesn't work:
```sequence&lt;Int&gt; { yield(Random.nextInt(0..15)) }
    .chunked(2)
    .take(6)```

My goal is something like `listOf(listOf(0, 3), listOf(5, 15), ...)`  with six inner lists

`List(6) { List(2) { Random.nextInt() } }`

Your example doesn't work because the sequence will only yield once. I think you could fix it by adding an infinite loop.

`sequence&lt;Int&gt; { yield(Random.nextInt(0..15)) }` only ever emits a single element, and then quits. Sequences aren’t automatic generator functions, you’ll need to do the iteration within `sequence { }` yourself.

Try this, with manual iteration: <https://pl.kotl.in/R_efr6krJ>
Or with `generateSequence`: <https://pl.kotl.in/tudLVa1wA>

```generateSequence { Random.nextInt(15) }
    .chunked(2)
    .take(6)```

Thanks, that was a bit confusing at first, now it's clear!

```sequence {
    repeat(6) {
        yield(listOf(Random.nextInt(15), Random.nextInt(15)))
    }
}```
is more readable IMO

More readable than
```sequence {
    repeat(6) {
        yield(List(2) { Random.nextInt(15) })
    }
}```
or
```List(6) { List(2) { Random.nextInt(15) } }```
? o_O

Ahah no, I meant than the `generateSequence` one. Indeed that double `List` factory one is great

It's not lazy, but it doesn't look like that was the question anyway

Yeah, just wanted to stay near to original code to show how to do it properly that way in case it was oversimplified. :slightly_smiling_face:

Yeah there are a few chained operators after that sequence generation, so a list would just recreate another list for each operation... That's why maybe the sequence version might be better here... Thanks all for the great ideas :grin:, different techniques are always useful for different contexts