As we discussed previously, there is a limitation in both sequences and iterators: they can't suspend during execution. This is a big limitation for many use cases, because often what would be ideal is to be able to suspend while waiting for other operations to complete.

To overcome this limitation, we have to use producers. Their philosophy and usage are close to the ones of suspending sequences and iterators, but with a few small differences. The following are some important details on producers:

• A producer suspends after a value is produced, and resumes when a new value is requested – similar to suspending sequences and iterators
• A producer can be built with a specific CoroutineContext
• The body of the suspending lambda that is passed can suspend at any point
• Because it can suspend at any point, a value from a producer can only be received in a suspending computation
• Because it works using a channel, you can think of it like a stream of data, in which receiving an element also removes the element from the stream