filterRows(evalFn?: Function) {
    const columns = this.columnManager.columns;

    this.createFilterExpression();

    if (!this.filterExpression) {
      this.rows = toArray(this.rowsIterator.clone());
      this.columnManager.dataGrid.resize();

      return;
    }

    const formatFns = {};
    formatFns[COLUMN_TYPES.index] = columns[COLUMN_TYPES.index].map(column => column.formatFn);
    formatFns[COLUMN_TYPES.body] = columns[COLUMN_TYPES.body].map(column => column.formatFn);

    try {
      this.rows = toArray(filter(
        this.rowsIterator.clone(),
        (row) => evalFn ? evalFn(row, formatFns) : this.evaluateFilterExpression(row, formatFns)
      ));
      this.sortedBy && this.sortByColumn(this.sortedBy);
      this.columnManager.dataGrid.resize();
    } catch (e) {}
  }

  addMinMaxValues() {
    let stringMinMax;
    let minMax;
    let dataType = this.getDataType();
    let displayType = this.getDisplayType();
    let valuesIterator = this.dataGrid.model.getColumnValuesIterator(this);
    let valueResolver = this.dataGrid.model.getColumnValueResolver(
      displayType === ALL_TYPES.html ? displayType : dataType
    );

    if (dataType === ALL_TYPES.html || displayType === ALL_TYPES.html) {
      this.resizeHTMLRows(valuesIterator);
    } else if (dataType === ALL_TYPES.string || dataType === ALL_TYPES['formatted integer']) {
      stringMinMax = minmax(valuesIterator, ColumnValuesIterator.longestString(valueResolver));
    } else {
      minMax = minmax(
        filter(valuesIterator, (value) => !Number.isNaN(valueResolver(value))),
        ColumnValuesIterator.minMax(valueResolver)
      );
    }

    this.minValue = minMax ? minMax[0] : null;
    this.maxValue = minMax ? minMax[1] : null;

    if (stringMinMax) {
      this.longestStringValue = stringMinMax[1];
    }
  }

/**
 * Iterate through all matching linked output views
 */
function* outputViews(app: JupyterFrontEnd, path: string) {
  let linkedViews = filter(
    app.shell.widgets(),
    w => w.id.startsWith('LinkedOutputView-') && (w as any).path === path
  );
  for (let view of toArray(linkedViews)) {
    for (let outputs of toArray(view.children())) {
      for (let output of toArray(outputs.children())) {
        if (output instanceof WidgetRenderer) {
          yield output;
        }
      }
    }
  }
}

 testIterator(() => {
   let expected = [0, 2, 4];
   let data = [0, 1, 2, 3, 4, 5];
   let it = filter(data, n => n % 2 === 0);
   return [it, expected];
 });