anchor.diff:    bool _isCons() => false;
     A _unsafeHead() => throw new UnsupportedError("_unsafeHead called on _Nil");
     IList<A> _unsafeTail() => throw new UnsupportedError("_unsafeTail called on _Nil");
  +  void _unsafeSetTail(IList<A> newTail) => throw new UnsupportedError("_unsafeSetTail called on _Nil");
   
     @override Option<A> get headOption => none();
   
  
positive.code:   }
  
    @override IList/*<B>*/ bind/*<B>*/(IList/*<B>*/ f(A a)) {
      List/*<B>*/ mresult = [];
      var current = this;
      while (current._isCons()) {
        final IList/*<B>*/ sublist = f(current._unsafeHead());
        var subcurrent = sublist;
        while (subcurrent._isCons()) {
          mresult.add(subcurrent._unsafeHead());
          subcurrent = subcurrent._unsafeTail();
        }
        current = current._unsafeTail();
      }
  
      IList/*<B>*/ result = nil();
      for (int i = mresult.length - 1; i >= 0; i--) {
        result = new Cons(mresult[i], result);
      }
      return result;
    }
  
    @override IList/*<B>*/ flatMap/*<B>*/(IList/*<B>*/ f(A a)) => bind(f);
  
    @override IList /*<B>*/ map/*<B>*/(/*=B*/ f(A a)) {
      List /*<B>*/ mresult = [];
      var current = this;
      while (current._isCons()) {
        mresult.add(f(current._unsafeHead()));
        current = current._unsafeTail();
      }
  
      IList /*<B>*/ result = nil();
      for (int i = mresult.length - 1; i >= 0; i--) {
        result = new Cons(mresult[i], result);
      }
      return result;
    }
  
negative.code: 
    IList<A> _unsafeTail();
  
    void _unsafeSetTail(IList<A> newTail);
  
    IList();
  
    factory IList.from(Iterable<A> iterable) {
      final IList<A> aNil = Nil as dynamic/*=IList<A>*/;
      final Iterator<A> it = iterable.iterator;
      if (!it.moveNext()) {
        return aNil;
      }
      Cons<A> result = new Cons(it.current, aNil);
      final IList<A> resultHead = result;
      while(it.moveNext()) {
        final next = new Cons(it.current, aNil);
        result._unsafeSetTail(next);
        result = next;
      }
      return resultHead;
    }
  
    @override IList/*<B>*/ pure/*<B>*/(/*=B*/ b) => new Cons(b, nil());
  
    @override /*=G*/ traverse/*<G>*/(Applicative/*<G>*/ gApplicative, /*=G*/ f(A a)) {
      IList resultHead = Nil;
      dynamic/*=G*/ result = gApplicative.pure(resultHead);
      IList<A> current = this;
      while (current._isCons()) {
        final gb = f(current._unsafeHead());
        result = gApplicative.map2(result, gb, (/*=IList*/ a, h) {
          if (a._isCons()) {
            final next = new Cons(h, Nil);
            a._unsafeSetTail(next);
            return next;
          } else {
            resultHead = new Cons(h, Nil);
            return resultHead;
          }
        });
        current = current._unsafeTail();
      }
      return gApplicative.map(result, (_) => resultHead);
    }
  
    @override /*=G*/ traverse_/*<G>*/(Applicative/*<G>*/ gApplicative, /*=G*/ f(A a)) {
  