anchor.diff:    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();
  +      consumeL/*<L, R, O>*/((/*=L*/ l) => consumeR((/*=R*/ r) => produce(f(l, r)))).repeatUntilExhausted();
   
     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();
  +      consumeL/*<I, I, I>*/((/*=I*/ i1) => consumeR((/*=I*/ i2) => produce(i1, produce(i2)))).repeatUntilExhausted();
   
   }
   
  
positive.code:     return go(z);
    }
  
    static Conveyor<From/*<I>*/, dynamic/*=I*/> intersperse/*<I>*/(/*=I*/ sep) => Pipe.consume/*<I, I>*/((i) => Pipe.produce(i, Pipe.produce(sep))).repeatNotEmpty();
  }
  
  class Both<L, R> {}
  
negative.code: 
    Conveyor<F, O> repeat() => lazyPlus(repeat);
  
    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) =>
  