anchor.diff:  
   abstract class Conveyor<F, O> extends FunctorOps<Conveyor/*<F, dynamic>*/, O> with ApplicativeOps<Conveyor/*<F, dynamic>*/, O>, ApplicativePlusOps<Conveyor/*<F, dynamic>*/, O>, MonadOps<Conveyor/*<F, dynamic>*/, O>, MonadPlusOps<Conveyor/*<F, dynamic>*/, O> {
   
  -  /*=A*/ interpret/*<A>*/(/*=A*/ ifEmit(O head, Conveyor<F, O> tail), /*=A*/ ifAwait(F req, Function1<Either<Object, dynamic>, Conveyor<F, O>> recv), /*=A*/ ifHalt(Object err));
  -
  -  static Conveyor/*<F, O>*/ emit/*<F, O>*/(/*=O*/ head, [Conveyor/*<F, O>*/ tail]) => new _Emit(head, tail ?? halt(End));
  -  static Conveyor/*<F, O>*/ await/*<F, A, O>*/(/*=F*/ req, Function1<Either<Object, dynamic/*=A*/>, Conveyor/*<F, O>*/> recv) => new _Await/*<F, A, O>*/(req, recv);
  +  /*=A*/ interpret/*<A>*/(/*=A*/ ifProduce(O head, Conveyor<F, O> tail), /*=A*/ ifConsume(F req, Function1<Either<Object, dynamic>, Conveyor<F, O>> recv), /*=A*/ ifHalt(Object err));
  +
  +  static Conveyor/*<F, O>*/ produce/*<F, O>*/(/*=O*/ head, [Conveyor/*<F, O>*/ tail]) => new _Produce(head, tail ?? halt(End));
  +  static Conveyor/*<F, O>*/ consume/*<F, A, O>*/(/*=F*/ req, Function1<Either<Object, dynamic/*=A*/>, Conveyor/*<F, O>*/> recv) => new _Consume/*<F, A, O>*/(req, recv);
     static Conveyor/*<F, O>*/ halt/*<F, O>*/(Object err) => new _Halt(err);
   
     static final End = new _End();
     static final Kill = new _Kill();
   
  -  Conveyor<F, dynamic/*=B*/> pure/*<B>*/(/*=B*/ b) => emit(b);
  +  Conveyor<F, dynamic/*=B*/> pure/*<B>*/(/*=B*/ b) => produce(b);
   
     Conveyor<F, dynamic/*=O2*/> map/*<O2>*/(/*=O2*/ f(O o)) =>
  -      interpret((h, t) => Try(() => emit(f(h), t.map/*<O2>*/(f))),
  -          (req, recv) => await(req, (ea) => recv(ea).map/*<O2>*/(f)),
  +      interpret((h, t) => Try(() => produce(f(h), t.map/*<O2>*/(f))),
  +          (req, recv) => consume(req, (ea) => recv(ea).map/*<O2>*/(f)),
             halt);
   
     Conveyor<F, O> lazyPlus(Conveyor<F, O> p()) =>
  
positive.code: class Pipe {
    static final From _get = new From();
  
    static Conveyor<From/*<I>*/, dynamic/*=O*/> emit/*<I, O>*/(/*=O*/ h, [Conveyor/*<From<I>, O>*/ t]) =>
        Conveyor.emit(h, t);
  
    static Conveyor<From/*<I>*/, dynamic/*=O*/> await/*<I, O>*/(Function1/*<I, Conveyor<From<I>, O>>*/ recv, [Function0/*<Conveyor<From<I>, O>>*/ fallback]) =>
        Conveyor.await(_get as dynamic/*=From<I>*/, (ea) => ea.fold((err) => err == Conveyor.End ? (fallback == null ? halt() : fallback()) : Conveyor.halt(err), (/*=I*/ i) => Conveyor.Try(() => recv(i))));
  
    static Conveyor<From/*<I>*/, dynamic/*=O*/> halt/*<I, O>*/() => Conveyor.halt(Conveyor.End);
  
    static Conveyor<From/*<I>*/, dynamic/*=O*/> lift/*<I, O>*/(Function1/*<I, O>*/ f) => await((/*=I*/ i) => emit(f(i))).repeat();
  
    static Conveyor<From/*<I>*/, dynamic/*=I*/> take/*<I>*/(int n) => n <= 0 ? halt() : await((i) => emit(i, take/*<I>*/(n-1)));
  
    static Conveyor<From/*<I>*/, dynamic/*=I*/> takeWhile/*<I>*/(bool f(/*=I*/ i)) => await((i) => f(i) ? emit(i, takeWhile/*<I>*/(f)) : halt());
  
    static Conveyor<From/*<I>*/, dynamic/*=I*/> filter/*<I>*/(bool f(/*=I*/ i)) => await/*<I, I>*/((i) => f(i) ? emit(i) : halt()).repeat();
  
    static Conveyor<From/*<I>*/, dynamic/*=O*/> scan/*<I, O>*/(/*=O*/ z, Function2/*<O, I, O>*/ f) {
      Conveyor/*<From<I>, O>*/ go(/*=O*/ previous) => await((/*=I*/ i) {
        final current = f(previous, i);
        return emit(current, go(current));
      });
      return go(z);
    }
  }
  
  final MonadPlus<Conveyor> ConveyorMP = new MonadPlusOpsMonadPlus<Conveyor>((a) => Conveyor.emit(a), () => Conveyor.halt(Conveyor.End));
  MonadPlus<Conveyor/*<F, O>*/> conveyorMP/*<F, O>*/() => ConveyorMP;
  
negative.code:       onHalt((err) => err == End ? p().asFinalizer() : p().asFinalizer().plus(halt(err)));
  
    Conveyor<F, O> asFinalizer() =>
        interpret((h, t) => produce(h, t.asFinalizer()),
            (req, recv) => consume(req, (ea) => ea == left(Kill) ? asFinalizer() : recv(ea)),
            halt);
  
    Conveyor<F, O> onHalt(Conveyor<F, O> f(Object err)) =>
        interpret((h, t) => produce(h, t.onHalt(f)),
            (req, recv) => consume(req, (ea) => recv(ea).onHalt(f)),
            (err) => Try(() => f(err)));
  
    Conveyor<F, O> onHaltEnd(Conveyor<F, O> f()) =>
  