Transduser: Corak komposisi fungsi yang berkuasa

alias:: Transduser: Corak komposisi fungsi yang berkuasa
buku nota:: Transduser: 一种强大的函数组合模式

peta & penapis

Semantik peta ialah "pemetaan", yang bermaksud melakukan transformasi pada semua elemen dalam satu set sekali.

  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 ]

Pernyataan di atas sengaja menggunakan pernyataan for untuk menyatakan dengan jelas bahawa pelaksanaan peta bergantung pada jenis koleksi.
Pelaksanaan berurutan;
Penilaian segera, bukan malas.
Mari lihat penapis:

  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 ]

Begitu juga, pelaksanaan penapis juga bergantung pada jenis koleksi tertentu dan pelaksanaan semasa memerlukan xs untuk menjadi tatasusunan.
Bagaimanakah peta boleh menyokong jenis data yang berbeza? Contohnya, Tetapkan , Peta  dan jenis data tersuai.
Terdapat cara konvensional: ia bergantung pada antara muka (protokol) koleksi.
Bahasa yang berbeza mempunyai pelaksanaan yang berbeza, JS mempunyai sokongan asli yang agak lemah dalam hal ini, tetapi ia juga boleh dilaksanakan:
Lelaran menggunakan Symbol.iterator .
Gunakan Object#constractor untuk mendapatkan pembina.
Jadi, bagaimanakah kami menyokong jenis data yang berbeza secara abstrak dalam tekan ?
Meniru perpustakaan ramdajs, ia boleh bergantung pada fungsi @@transducer/step tersuai.

  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}

Dengan menggunakan kaedah ini, kami boleh melaksanakan fungsi seperti peta , penapis , dll., yang lebih berpaksi.
Kuncinya ialah mewakilkan operasi seperti pembinaan, lelaran dan pengumpulan kepada kelas koleksi tertentu, kerana hanya koleksi itu sendiri yang tahu cara menyelesaikan operasi ini.

  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}

mengarang

Akan terdapat beberapa isu apabila peta dan penapis di atas digunakan dalam gabungan.

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

Walaupun hanya 5 elemen digunakan, semua elemen dalam koleksi akan dilalui.
Setiap langkah akan menghasilkan objek koleksi perantaraan.
Kami menggunakan karang untuk melaksanakan logik ini semula

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

Untuk menyokong gubahan, kami melaksanakan fungsi seperti peta dan penapis dalam bentuk kari .

  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 ]

Setakat ini, pelaksanaan kami jelas dan ringkas dalam ungkapan tetapi membazir dalam masa jalan.

Bentuk fungsi

Transformer

Fungsi peta dalam versi kari adalah seperti ini:

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

Iaitu, map(x => ...) mengembalikan fungsi parameter tunggal.

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

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

Fungsi dengan satu parameter boleh digubah dengan mudah.
Secara khusus, input fungsi ini ialah "data", output ialah data yang diproses dan fungsinya ialah pengubah data (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 adalah fungsi parameter tunggal, mudah untuk komposisi fungsi.

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

Pengurang

Pengurang ialah fungsi dua parameter yang boleh digunakan untuk menyatakan logik yang lebih kompleks.

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

jumlah

  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
  }

peta

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

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

penapis

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

ambil

Bagaimana untuk melaksanakan pengambilan ? Ini memerlukan reduce untuk mempunyai kefungsian yang serupa dengan break .

  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 ]

Transduser

Akhir sekali, kami bertemu dengan protagonis kami
Mula-mula periksa semula pelaksanaan peta sebelumnya

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

Kita perlu mencari cara untuk memisahkan logik yang bergantung pada tatasusunan (Array) yang disebutkan di atas dan mengabstrakkannya menjadi Penurun .

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

Pembinaan hilang, lelaran hilang, dan koleksi elemen juga hilang.
Melalui pengurang , peta kami hanya mengandungi logik dalam tanggungjawabnya.
Lihat sekali lagi pada penapis

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

Notis penapis dan jenis pemulangan rmap di atas:

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

Ia sebenarnya adalah Transfomer , dengan kedua-dua parameter dan nilai pulangan ialah Reducer , ia Transducer .
Transformer boleh digubah, jadi Transduser juga boleh digubah.

  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)

ke dalam & transduksi

Walau bagaimanapun, bagaimana untuk menggunakan transduser ?

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

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

Kita perlu melaksanakan lelaran dan pengumpulan menggunakan pengurang.

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

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

Ia boleh berfungsi sekarang dan kami juga mendapati bahawa lelaran adalah "atas permintaan". Walaupun terdapat 100 elemen dalam koleksi, hanya 10 elemen pertama telah diulang.
Seterusnya, kita akan merangkum logik di atas ke dalam fungsi.

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

  type Transformer = (xs: T) => R

Aliran

Penjana Fibonacci.

Andaikan kita mempunyai beberapa jenis pengumpulan data tak segerak, seperti penjana Fibonacci tak terhingga tak segerak.

  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

Kita perlu melaksanakan ke fungsi yang menyokong struktur data di atas.
Siarkan versi tatasusunan kod di sebelahnya sebagai rujukan:

  type Transformer = (x: T) => T

Berikut ialah kod pelaksanaan kami:

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

Operasi pengumpulan adalah sama, operasi lelaran berbeza.

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

  sum(range(11))
  // 55

Logik yang sama digunakan pada struktur data yang berbeza.

Pesanan

Anda, yang prihatin, mungkin menyedari bahawa susunan parameter versi karang berdasarkan kari dan versi berdasarkan pengurang adalah berbeza.

versi kari

  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
  }

Pelaksanaan fungsi adalah bersekutu kanan.

versi transduser

  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
  }

Rujukan

Transduser Akan Datang
Transduser - Rujukan Clojure

Atas ialah kandungan terperinci Transduser: Corak komposisi fungsi yang berkuasa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!