Describes push streams by emitting values of type `A`.

Describes pull streams by reading values of type `A`.

The producer can decide to `stop` emitting values.

Signal from a producer to a consumer that there are no further values.

Like `for[A, R]`, but ignores the result of the stream, and consequently
works for any type. Use this to annotate the type of stream elements
`A` without having to also annotate `R`.

e.g. for[Int] { prog() } { el => println(el) }

Applies the given function on each emitted element and reemits the result.

e.g. map[Int,String]{ x => x.show } { range(0, 5) }

Runs the given action whenever the given reader reads an element.

e.g. var i = -1; with tap { i = i + 1; i }; reader()

Runs the stream as a message queue,
handling each of its elements that can produce new elements ("messages"),
until a fixed point is reached.

Turns a `list` into a producer of a push stream
by emitting each contained value left-to-right.

Turns an `array` into a producer of a push stream
by emitting each contained value from 0 to length - 1.

Turns `bytes` into a producer of a push stream
by emitting each contained value from 0 to length - 1.

Turns a `map` into a producer of a push stream
of `(key, value)` pairs by emitting each contained *in order*.

Turns a `map` into a producer of a push stream
of its keys by emitting each contained *in order*.

Turns a `map` into a producer of a push stream
of its values by emitting each contained.

Turns a `set` into a producer of a push stream
by emitting each contained *in order*.

Run `program` forever until `stop` is thrown.

In Effekt lower bounds are inclusive and upper bounds are exclusive

If `number` is zero or negative it does nothing

If `number` is zero or negative it does nothing

Creates an infinite iterated stream given by an `initial` seed and a `step` function:
iterate(a){f} ~> a, f(a), f(f(a)), f(f(f(a))), ...

Combines two streams together producing a stream of pairs in lockstep.
Terminates when either of them terminates.

Use cons to handle prod, but also emit to the outside.
The outside controls iteration, i.e., if cons aborts, the rest of prod will still be emitted.

Starts by executing cons. Will stop cons during execution if the outside stops consuming.

Example, printing all values consumed by the outside:

    with teeing{ {s} => for{s}{ e => println(e) } }
    prod() // some producer

Laws-ish (hopefully):
- hnd{ prd() } === hnd{ teeing{t}{ prd() } } for all hnd and t that calls its argument at most once (and has no other captures)

Binds a `teeing`-like function in the body, stopping the inner producer once all consumers in tees are done consuming.

Example of use, equivalent to `tee[A]{cns1}{cns2}{prd}`:

    manyTee[A] { {tee} =>
      with tee{cns1}
      with tee{cns2}
      prd()
    }

Streams prod to both cons1 and cons2. Stops once both cons1 and cons2 stopped.
Only runs prod once, resuming at most once at each emit.

    var sumRes = 0
    var productRes = 0
    tee{ s => sumRes = sum{s} }{ s => productRes = product{s} }{ range(0, 10) }
    assertEquals(sum{ range(0, 10) }, sumRes)
    assertEquals(product{ range(0, 10) }, productRes)

Canonical handler of push streams that performs `action` for every
value emitted by `stream`.

If `number` is zero or negative it does nothing