anchor.diff:    }
   }
   
  -class Connector<T, P> extends ImmutableConn<T, P> {
  +abstract class ImmutableConn<T, P> implements AbstractConnector<T, P> {
  +  const ImmutableConn();
  +
  +  T set(T state, P subState);
  +
  +  @override
  +  SubReducer<T> subReducer(Reducer<P> reducer) {
  +    return (T state, Action action, bool isStateCopied) {
  +      final P props = get(state);
  +      if (props == null) {
  +        return state;
  +      }
  +      final P newProps = reducer(props, action);
  +      final bool hasChanged = newProps != props;
  +      if (hasChanged) {
  +        return set(state, newProps);
  +      }
  +      return state;
  +    };
  +  }
  +}
  +
  +mixin ConnOpMixin<T, P> on AbstractConnector<T, P> {
  +  Dependent<T> operator +(Logic<P> logic) => createDependent<T, P>(this, logic);
  +}
  +
  +class Connector<T, P> extends MutableConn<T, P> {
     final P Function(T) _getter;
     final void Function(T, P) _setter;
   
  
positive.code:   }
  }
  
  abstract class ImmutableConn<T, P> implements AbstractConnector<T, P> {
    const ImmutableConn();
  
    void set(T state, P subState);
  
  
negative.code:   void set(T state, P subState) => _setter(state, subState);
  }
  
  class ConnOp<T, P> extends Connector<T, P> with ConnOpMixin<T, P> {
    ConnOp({P Function(T) get, void Function(T, P) set})
        : super(get: get, set: set);
  }
  
  abstract class MapLike {
  