JavaScript で配列遅延評価ライブラリを実装する方法

const over = シンボル();

定数isOver = 関数(_over) {
  _over === over を返します。
}

const範囲 = 関数 (から、まで) {
  i = からとします。
  関数を返す（）{
    もし（i < to）{
      私は++
      console.log('範囲\t', i);
      戻る
    }
    戻る;
  }
}

const map = 関数 (フロー、変換) {
  関数を返す（）{
    定数データ = フロー();
    console.log('map\t', データ);
    isOver(data) を返します ? data : transform(data);
  }
}

const filter = 関数 (フロー、条件) {
  関数を返す（）{
    while(true) {
      定数データ = フロー();
      if (isOver(データ)) {
        データを返します。
      }
      if(条件(データ)) {
        console.log('filter\t', データ);
        データを返します。
      }
    }
  }
}

const stop = 関数 (フロー、条件) {
  _stop = false とします。
  関数を返す（）{
    if (_stop) は戻ります;
    定数データ = フロー();
    if (isOver(データ)) {
      データを返します。
    }
    _stop = 条件(データ);
    データを返します。
  }
}

const take = function(flow, num) {
  i = 0 とします。
  戻り値 stop(flow, (data) => {
    ++i >= num を返します。
  });
}

const join = 関数 (フロー) {
  定数配列 = [];
  while(true) {
    定数データ = フロー();
    if (isOver(データ)) {
      壊す;
    }
    配列.push(データ);
  }
  配列を返します。
}

const nums = join(take(filter(map(range(0, 20), n => n * 10), n => n % 3 === 0), 2));
console.log(数値);

const範囲 = 関数* (から、まで) {
  for(i = from; i < to; i++) {
    console.log('範囲\t', i);
    利回り i;
  }
}

const map = function* (flow, transform) {
  for(フローのconstデータ) {
    console.log('map\t', データ);
    yield(変換(データ));
  }
}

const filter = function* (フロー, 条件) {
  for(フローのconstデータ) {
    console.log('filter\t', データ);
    if (条件(データ)) {
      収量データ;
    }
  }
}

const stop = function*(flow, condition) {
  for(フローのconstデータ) {
    収量データ;
    if (条件(データ)) {
      壊す;
    }
  }
}

const take = 関数 (フロー、数値) {
  count = 0 とします。
  const _filter = 関数 (データ) {
    カウント++
    count >= 数値を返します。
  }
  stop(flow, _filter) を返します。
}

クラス _Lazy{
  コンストラクタ() {
    this.iterator = null;
  }

  範囲(...引数) {
    this.iterator = range(...args);
    これを返します。
  }

  マップ(...引数) {
    this.iterator = map(this.iterator, ...args);
    これを返します。
  }

  フィルター(...引数) {
    this.iterator = フィルター(this.iterator, ... 引数);
    これを返します。
  }

  （...引数）を取る{
    this.iterator = take(this.iterator, ...args);
    これを返します。
  }

  [シンボル.イテレータ]() {
    this.iterator を返します。
  }

}

関数遅延（）{
  新しい_Lazy() を返します。
}

const nums = lazy().range(0, 100).map(n => n * 10).filter(n => n % 3 === 0).take(2);

for(let n of nums) {
  console.log('num:\t', n, '\n');
}