> = {
  childClass: new (props: ChildPropsType) => ChildInstanceType;
  instance?: ChildInstanceType;
  propsFactory: (
    parentProps: ParentPropsType,
    parentState: ParentStateType
  ) => ChildPropsType;
};

  > = {
    childClass: new (props: ChildPropsType) => ChildInstanceType;
    instance?: ChildInstanceType;
    propsFactory: (
      parentProps: ParentPropsType,
      parentState: ParentStateType
    ) => ChildPropsType;
  };
class ChildrenArray<P extends Props, S extends State> {
  private _values: ChildInstructions<any, any, P, S>[] = [];
  public push<CIT, CPT>(c: ChildInstructions<CIT, CPT, P, S>) {
    this._values.push(c);
  }
  public remove<CIT>(c: CIT) {
    this._values.splice(this._values.findIndex(it => it.instance === c), 1);
  }
  public forEach(callbackfn: (
    value: ChildInstructions<any, any, P, S>,
    index: number,
    array: ChildInstructions<any, any, P, S>[],
  ) => void) {
    this._values.forEach(callbackfn);
  }
}

  protected _staleProps: P; // need it for args
  private _children: ChildInstructions<any, any, P, S>[];

  protected _staleProps: P; // NOTE(bowei): need it for args for now; maybe we can extract out args?
  private _children: ChildrenArray<P, S> = new ChildrenArray();

    this._children = []; // child implementation should register child class and props factory in constructor?

  _didConstruct(props: P) {

  private _didConstruct(props: P) {

  useState(initialState: S) {

  protected useState(initialState: S) {

  public _update(nextProps: P) {

  public _update(nextProps: P) { // nextProps is guaranteed to be referentially a distinct object (might be shallow copy though)

    this.updateChildren(nextProps); // implementation should call children._update in here

    this._updateChildren(nextProps); // implementation should call children._update in here

    this._setStaleProps(nextProps);

    this._staleProps = nextProps;

  private _updateChildren(nextProps: P) {
    this._children.forEach(({ instance, propsFactory }) => {
      instance._update(propsFactory(nextProps, this.state));
    });
  }

  protected updateChildren(nextProps: P) {
    this._children.forEach(({ instance, propsFactory }) => {
      instance._update(propsFactory(nextProps, this.state));
    });
  }

  _setStaleProps(nextProps: P) {
    this._staleProps = nextProps;
  }