anchor.diff:  import '../utils/utils.dart';
   import 'recycle_context.dart';
   
  +/// Use [AdapterSource] instead of [List<ItemBean>]
  +// @deprecated
   class ItemBean {
     final String type;
     final Object data;
  
positive.code:           final ContextSys<Object> subCtx = recycleCtx.reuseOrCreate(
              Tuple2<Type, Object>(
                result.runtimeType,
                result.key(itemBean.data),
              ),
              () => result.createContext(
                    recycleCtx.store,
                    recycleCtx.context,
                    _subGetter(() => connector.get(recycleCtx.state), index),
                    bus: recycleCtx.bus,
                    enhancer: recycleCtx.enhancer,
                  ),
            );
            adapters.add(result.buildAdapter(subCtx));
          } else if (result is AbstractComponent<Object>) {
            adapters.add(ListAdapter((BuildContext buildContext, int _) {
              return result.buildComponent(
                recycleCtx.store,
                _subGetter(() => connector.get(recycleCtx.state), index),
                bus: recycleCtx.bus,
                enhancer: recycleCtx.enhancer,
              );
  
negative.code:       ItemBean(type ?? this.type, data ?? this.data);
  }
  
  abstract class AdapterSource {
    int get itemCount;
  
    String getType(int index);
  
    Object getData(int index);
  
    AdapterSource update(int index, Object data, bool isStateCopied);
  }
  
  abstract class MutableSource extends AdapterSource {
    @mustCallSuper
    @override
    MutableSource update(int index, Object data, bool isStateCopied) {
      final MutableSource result = isStateCopied ? this : clone();
      return result..setData(index, data);
    }
  
    void setData(int index, Object data);
  
    MutableSource clone();
  }
  
  abstract class ImmutableSource extends AdapterSource {
    @mustCallSuper
    @override
    ImmutableSource update(int index, Object data, bool isStateCopied) =>
        setData(index, data);
  
    ImmutableSource setData(int index, Object data);
  
    ImmutableSource clone();
  }
  
  class _Conn<T> implements AbstractConnector<T, AdapterSource> {
    final AbstractConnector<T, List<ItemBean>> connector;
  
    _Conn(this.connector);
  
    @override
    AdapterSource get(T state) => _ListSource(connector.get(state));
  
    @override
    SubReducer<T> subReducer(Reducer<AdapterSource> reducer) {
      return connector.subReducer((List<ItemBean> list, Action action) {
        /// maybe a long loop
        final _ListSource listSource = reducer(_ListSource(list), action);
        return listSource.list;
      });
    }
  }
  
  class _ListSource extends MutableSource {
    /// ignore:deprecated_member_use_from_same_package
    final List<ItemBean> list;
  
    _ListSource(this.list);
  
    @override
    MutableSource clone() => _ListSource(list.toList());
  
    @override
    Object getData(int index) => list[index].data;
  
    @override
    String getType(int index) => list[index].type;
  
    @override
    int get itemCount => list.length;
  
    @override
    void setData(int index, Object data) =>
        list[index] = ItemBean(list[index].type, data);
  }
  
  /// template is a map, driven by array
  class DynamicFlowAdapter<T> extends Logic<T> with RecycleContextMixin<T> {
    final Map<String, AbstractLogic<Object>> pool;
  
    final AbstractConnector<T, AdapterSource> sourceConn;
  
    DynamicFlowAdapter({
      @required this.pool,
  
      /// ignore:deprecated_member_use_from_same_package
      @deprecated AbstractConnector<T, List<ItemBean>> connector,
      @required AbstractConnector<T, AdapterSource> sourceConn2,
      ReducerFilter<T> filter,
      Reducer<T> reducer,
      Effect<T> effect,
  