alias:: トランスデューサー: 強(qiáng)力な関數(shù)構(gòu)成パターン
ノートブック:: トランスデューサー: 一種強(qiáng)大的関數(shù)數(shù)集合モード

マップとフィルター

map のセマンティクスは「マッピング」です。これは、セット內(nèi)のすべての要素に対して変換を 1 回実行することを意味します。

  const list = [1, 2, 3, 4, 5]

  list.map(x => x + 1)
  // [ 2, 3, 4, 5, 6 ]

  function map(f, xs) {
    const ret = []
    for (let i = 0; i < xs.length; i++) {
      ret.push(f(xs[i]))
    }
    return ret
  }

  map(x => x + 1, [1, 2, 3, 4, 5])
  // [ 2, 3, 4, 5, 6 ]

上記では、マップの実裝がコレクション型に依存していることを明確に表現(xiàn)するために、意図的に for ステートメントを使用しています。
順次実行;
怠惰ではなく即時評価。
フィルタを見てみましょう:

  function filter(f, xs) {
    const ret = []
    for (let i = 0; i < xs.length; i++) {
      if (f(xs[i])) {
        ret.push(xs[i])
      }
    }
    return ret
  }

  var range = n => [...Array(n).keys()]

  filter(x => x % 2 === 1, range(10))
  // [ 1, 3, 5, 7, 9 ]

同様に、フィルターの実裝も特定のコレクション タイプに依存し、現(xiàn)在の実裝では xs が配列である必要があります。
マップはどのようにしてさまざまなデータ型をサポートできるのでしょうか?たとえば、Set、Map、カスタム データ タイプなどです。
従來の方法があります。コレクションのインターフェイス (プロトコル) に依存します。
言語が異なれば実裝も異なります。JS のネイティブ サポートはこの點(diǎn)では比較的弱いですが、これも可能です。
Symbol.iterator を使用して反復(fù)処理します。
Object#constractor を使用してコンストラクターを取得します。
では、プッシュでさまざまなデータ型を抽象的にサポートするにはどうすればよいでしょうか?
ramdajs ライブラリを模倣し、カスタム @@transducer/step 関數(shù)に依存できます。

  function map(f, xs) {
    const ret = new xs.constructor()  // 1. construction
    for (const x of xs) { // 2. iteration
      ret['@@transducer/step'](f(x))  // 3. collection
    }
    return ret
  }

  Array.prototype['@@transducer/step'] = Array.prototype.push
  // [Function: push]

  map(x => x + 1, [1, 2, 3, 4, 5])
  // [ 2, 3, 4, 5, 6 ]

  Set.prototype['@@transducer/step'] = Set.prototype.add
  // [Function: add]

  map(x => x + 1, new Set([1, 2, 3, 4, 5]))
  // Set (5) {2, 3, 4, 5, 6}

この方法を使用すると、マップ、フィルターなど、より軸的な機(jī)能を?qū)g裝できます。
重要なのは、構(gòu)築、反復(fù)、コレクションなどの操作を特定のコレクション クラスに委任することです。これらの操作を完了する方法を知っているのはコレクション自體だけであるためです。

  function filter(f, xs) {
    const ret = new xs.constructor()
    for (const x of xs) {
      if (f(x)) {
        ret['@@transducer/step'](x)
      }
    }
    return ret
  }

  filter(x => x % 2 === 1, range(10))
  // [ 1, 3, 5, 7, 9 ]

  filter(x => x > 3, new Set(range(10)))
  // Set (6) {4, 5, 6, 7, 8, 9}

作曲する

上記のマップとフィルタを組み合わせて使用??すると、いくつかの問題が発生します。

  range(10)
    .map(x => x + 1)
    .filter(x => x % 2 === 1)
    .slice(0, 3)
  // [ 1, 3, 5 ]

使用される要素は 5 つだけですが、コレクション內(nèi)のすべての要素が走査されます。
各ステップで中間コレクション オブジェクトが生成されます。
Compose を使用してこのロジックを再度実裝します

  function compose(...fns) {
    return fns.reduceRight((acc, fn) => x => fn(acc(x)), x => x)
  }

合成をサポートするために、マップやフィルターなどの関數(shù)をカレーの形式で実裝します。

  function curry(f) {
    return (...args) => data => f(...args, data)
  }

  var rmap = curry(map)
  var rfilter = curry(filter)

  function take(n, xs) {
    const ret = new xs.constructor()
    for (const x of xs) {
      if (n <= 0) {
        break
      }
      n--
      ret['@@transducer/step'](x)
    }
    return ret
  }
  var rtake = curry(take)

  take(3, range(10))
  // [ 0, 1, 2 ]

  take(4, new Set(range(10)))
  // Set (4) {0, 1, 2, 3}

  const takeFirst3Odd = compose(
    rtake(3),
    rfilter(x => x % 2 === 1),
    rmap(x => x + 1)
  )

  takeFirst3Odd(range(10))
  // [ 1, 3, 5 ]

これまでのところ、私たちの実裝は表現(xiàn)的には明確かつ簡潔ですが、実行時には無駄です。

関數(shù)の形狀

トランス

バージョンカレーのマップ関數(shù)は次のようになります:

  const map = f => xs => ...

つまり、map(x => ...) は単一パラメータ関數(shù)を返します。

  const list = [1, 2, 3, 4, 5]

  list.map(x => x + 1)
  // [ 2, 3, 4, 5, 6 ]

パラメータが 1 つの関數(shù)は簡単に作成できます。
具體的には、これらの関數(shù)の入力は「データ」、出力は処理されたデータであり、関數(shù)はデータ変換器 (Transformer) です。

  function map(f, xs) {
    const ret = []
    for (let i = 0; i < xs.length; i++) {
      ret.push(f(xs[i]))
    }
    return ret
  }

  map(x => x + 1, [1, 2, 3, 4, 5])
  // [ 2, 3, 4, 5, 6 ]

  function filter(f, xs) {
    const ret = []
    for (let i = 0; i < xs.length; i++) {
      if (f(xs[i])) {
        ret.push(xs[i])
      }
    }
    return ret
  }

Transformer は単一パラメータ関數(shù)であり、関數(shù)の合成に便利です。

  var range = n => [...Array(n).keys()]

減速機(jī)

リデューサーは、より複雑なロジックを表現(xiàn)するために使用できる 2 つのパラメーターの関數(shù)です。

  filter(x => x % 2 === 1, range(10))
  // [ 1, 3, 5, 7, 9 ]

和

  function map(f, xs) {
    const ret = new xs.constructor()  // 1. construction
    for (const x of xs) { // 2. iteration
      ret['@@transducer/step'](f(x))  // 3. collection
    }
    return ret
  }

地図

  Array.prototype['@@transducer/step'] = Array.prototype.push
  // [Function: push]

  map(x => x + 1, [1, 2, 3, 4, 5])
  // [ 2, 3, 4, 5, 6 ]

フィルター

  Set.prototype['@@transducer/step'] = Set.prototype.add
  // [Function: add]

取る

take を?qū)g裝するにはどうすればよいですか?これには、reduce に Break と同様の機(jī)能を持たせる必要があります。

  map(x => x + 1, new Set([1, 2, 3, 4, 5]))
  // Set (5) {2, 3, 4, 5, 6}

  function filter(f, xs) {
    const ret = new xs.constructor()
    for (const x of xs) {
      if (f(x)) {
        ret['@@transducer/step'](x)
      }
    }
    return ret
  }

  filter(x => x % 2 === 1, range(10))
  // [ 1, 3, 5, 7, 9 ]

トランスデューサー

ついに主人公に會います
まず、以前のマップ実裝を再検討します

  filter(x => x > 3, new Set(range(10)))
  // Set (6) {4, 5, 6, 7, 8, 9}

上記の配列 (Array) に依存するロジックを分離し、Reducer に抽象化する方法を見つける必要があります。

  range(10)
    .map(x => x + 1)
    .filter(x => x % 2 === 1)
    .slice(0, 3)
  // [ 1, 3, 5 ]

構(gòu)築は消滅し、反復(fù)は消滅し、要素のコレクションも消滅しました。
Reducer を介して、マップにはその責(zé)任範(fàn)囲內(nèi)のロジックのみが含まれます。
フィルタをもう一度見てください

  function compose(...fns) {
    return fns.reduceRight((acc, fn) => x => fn(acc(x)), x => x)
  }

上記の rfilter と rmap の戻り値の型に注意してください:

  function curry(f) {
    return (...args) => data => f(...args, data)
  }

これは実際には Transformer であり、パラメータと戻り値の両方が Reducer であるため、 Transducer です。
Transformer はコンポーザブルであるため、Transducer もコンポーザブルです。

  var rmap = curry(map)
  var rfilter = curry(filter)

  function take(n, xs) {
    const ret = new xs.constructor()
    for (const x of xs) {
      if (n <= 0) {
        break
      }
      n--
      ret['@@transducer/step'](x)
    }
    return ret
  }
  var rtake = curry(take)

変換する

しかし、トランスデューサーの使用方法は?

  take(3, range(10))
  // [ 0, 1, 2 ]

  take(4, new Set(range(10)))
  // Set (4) {0, 1, 2, 3}

リデューサーを使用して反復(fù)とコレクションを?qū)g裝する必要があります。

  const takeFirst3Odd = compose(
    rtake(3),
    rfilter(x => x % 2 === 1),
    rmap(x => x + 1)
  )

  takeFirst3Odd(range(10))
  // [ 1, 3, 5 ]

これで動作するようになり、反復(fù)が「オンデマンド」であることにも気付きました。コレクションには 100 個の要素がありますが、最初の 10 個の要素のみが反復(fù)されました。
次に、上記のロジックを関數(shù)にカプセル化します。

  const map = f => xs => ...

  type Transformer = (xs: T) => R

流れ

フィボナッチジェネレータ。

非同期無限フィボナッチジェネレータなど、ある種の非同期データ収集があると仮定します。

  data ->> map(...) ->> filter(...) ->> reduce(...) -> result

  function pipe(...fns) {
    return x => fns.reduce((ac, f) => f(ac), x)
  }

  const reduce = (f, init) => xs => xs.reduce(f, init)

  const f = pipe(
    rmap(x => x + 1),
    rfilter(x => x % 2 === 1),
    rtake(5),
    reduce((a, b) => a + b, 0)
  )

  f(range(100))
  // 25

上記のデータ構(gòu)造をサポートする関數(shù)を?qū)g裝する必要があります。
參考としてコードの配列バージョンをその隣に投稿します:

  type Transformer = (x: T) => T

実裝コードは次のとおりです:

  type Reducer = (ac: R, x: T) => R

コレクション操作は同じですが、反復(fù)操作は異なります。

  // add is an reducer
  const add = (a, b) => a + b
  const sum = xs => xs.reduce(add, 0)

  sum(range(11))
  // 55

同じロジックが異なるデータ構(gòu)造に適用されます。

注文

注意深い方は、curry に基づいた compose バージョンと、reducer に基づいたバージョンのパラメータの順序が異なることに気づくかもしれません。

カレーバージョン

  const list = [1, 2, 3, 4, 5]

  list.map(x => x + 1)
  // [ 2, 3, 4, 5, 6 ]

  function map(f, xs) {
    const ret = []
    for (let i = 0; i < xs.length; i++) {
      ret.push(f(xs[i]))
    }
    return ret
  }

関數(shù)の実行は右結(jié)合です。

トランスデューサのバージョン

  map(x => x + 1, [1, 2, 3, 4, 5])
  // [ 2, 3, 4, 5, 6 ]

  function filter(f, xs) {
    const ret = []
    for (let i = 0; i < xs.length; i++) {
      if (f(xs[i])) {
        ret.push(xs[i])
      }
    }
    return ret
  }

參照

トランスデューサーが登場します
トランスデューサ - Clojure リファレンス

以上がトランスデューサー：強(qiáng)力な機(jī)能構(gòu)成パターンの詳細(xì)內(nèi)容です。詳細(xì)については、PHP 中國語 Web サイトの他の関連記事を參照してください。