anchor.diff:    F state(S s) => _FM.map(_run(s), (t) => t.value2);
   
     @override StateT/*<F, S, B>*/ pure/*<B>*/(/*=B*/ b) => new StateT(_FM, (S s) => _FM.pure(new Tuple2<B, S>(b, s)));
  -
  +  @override StateT/*<F, S, B>*/ map/*<B>*/(/*=B*/ f(A a)) => new StateT(_FM, (S s) => _FM.map(_run(s), (Tuple2<A, S> t) => t.map1(f)));
     @override StateT/*<F, S, B>*/ bind/*<B>*/(StateT/*<F, S, B>*/ f(A a)) => new StateT(_FM, (S s) => _FM.bind(_FM.pure(() => _run(s)), (F tt()) {
       return _FM.bind(tt(), (Tuple2<A, S> t) => f(t.value1)._run(t.value2));
     }));
  
positive.code: class StateMonad<S> extends MonadOpsMonad<State<S, dynamic>> {
    StateMonad() : super((a) => new State((S s) => new Tuple2(a, s)));
  
    State<S, S> get() => new State((S s) => new Tuple2(s, s));
    State<S, Unit> put(S newS) => new State((S s) => new Tuple2(unit, newS));
    State<S, Unit> modify(S f(S s)) => get().bind((S s) => put(f(s)));
  }
  
  final StateMonad StateM = new StateMonad();
  
  class StateT<F, S, A> extends FunctorOps<StateT/*<F, S, dynamic>*/, A> with ApplicativeOps<StateT/*<F, S, dynamic>*/, A>, MonadOps<StateT/*<F, S, dynamic>*/, A> {
    final Monad<F> _FM;
  
negative.code:   State(this._run);
  
    @override State/*<S, B>*/ pure/*<B>*/(/*=B*/ b) => new State((s) => new Tuple2(b, s));
    @override State/*<S, B>*/ map/*<B>*/(/*=B*/ f(A a)) => new State((S s) => run(s).map1(f));
    @override State/*<S, B>*/ bind/*<B>*/(State/*<S, B>*/ f(A a)) => new State/*<S, B>*/((S s) {
      final ran = run(s);
      return f(ran.value1).run(ran.value2);
  