anchor.diff:  
     Conveyor<F, O> repeat() => lazyPlus(repeat);
   
  -  Conveyor<F, O> repeatNotEmpty() =>
  -      interpret((h, t) => produce(h, t.lazyPlus(repeatNotEmpty)),
  -          (req, recv) => consume(req, (ea) => ea.fold((l) => recv(left(l)), (r) => recv(right(r)).lazyPlus(repeatNotEmpty))),
  -          halt);
  +  Conveyor<F, O> repeatUntilExhausted() =>
  +      interpret((h, t) => produce(h, t.lazyPlus(repeatUntilExhausted)),
  +          (req, recv) => consume(req, (ea) => ea.fold((l) => recv(left(l)), (r) => recv(right(r)).lazyPlus(repeatUntilExhausted))),
  +          halt);
  +
  +  Conveyor<F, O> repeatNonEmpty() {
  +    final cycle = this.map(some).lazyPlus(() => produce(none())).repeat();
  +    final sentinel = tuple2(some(none()), none());
  +    final trimmed = cycle.pipe(Pipe.window2()).takeWhile((pair) => pair != sentinel);
  +    return trimmed.map((t) => t.value2).flatMap((o) => o.fold(() => halt(End), (v) => produce(v)));
  +  }
   
     F/*=FLA*/ runLog/*<FLA extends F>*/(MonadCatch<F> monadCatch) {
       F go(Conveyor<F, O> cur, IList<O> acc) =>
  
positive.code:   static Conveyor<Both/*<L, R>*/, dynamic/*=O*/> halt/*<L, R, O>*/() => Conveyor.halt(Conveyor.End);
  
    static Conveyor<Both/*<L, R>*/, dynamic/*=O*/> zipWith/*<L, R, O>*/(Function2/*<L, R, O>*/ f) =>
        consumeL/*<L, R, O>*/((/*=L*/ l) => consumeR((/*=R*/ r) => produce(f(l, r)))).repeatNotEmpty();
  
    static Conveyor<Both/*<L, R>*/, Tuple2/*<L, R>*/> zip/*<L, R>*/() => zipWith(tuple2);
  
    static Conveyor<Both/*<I, I>*/, dynamic/*=I*/> interleave/*<I>*/() =>
        consumeL/*<I, I, I>*/((/*=I*/ i1) => consumeR((/*=I*/ i2) => produce(i1, produce(i2)))).repeatNotEmpty();
  
  }
  
  
negative.code:       (StreamIterator/*<A>*/ it) => Source.eval_(new Task(() => new Future.value(unit).then((_) => it.cancel()))));
  
    static Conveyor/*<F, O>*/ constant/*<F, O>*/(Monad/*<F>*/ monad, /*=O*/ o) => eval/*<F, O>*/(monad.pure(o)).repeat();
  
    static Conveyor/*<F, int>*/ intsFrom/*<F, O>*/(Monad/*<F>*/ monad, int from) => constant(monad, 1).pipe(Pipe.scan(from-1, (int a, int b) => a+b));
  }
  
  class From<A> {}
  