ใครช่วยอธิบาย Clojure Transducers ให้ฉันฟังด้วยคำง่ายๆได้ไหม

ฉันได้ลองอ่านสิ่งนี้แล้วแต่ยังไม่เข้าใจคุณค่าของสิ่งเหล่านี้หรือสิ่งที่พวกเขาแทนที่ พวกเขาทำให้โค้ดของฉันสั้นลงเข้าใจง่ายขึ้นหรืออะไร?

อัปเดต

มีคนโพสต์คำตอบมากมาย แต่คงจะดีหากได้เห็นตัวอย่างของการมีและไม่มีตัวแปลงสัญญาณสำหรับบางสิ่งที่เรียบง่ายซึ่งแม้แต่คนงี่เง่าอย่างฉันก็สามารถเข้าใจได้ เว้นแต่แน่นอนว่าทรานสดิวเซอร์ต้องการความเข้าใจในระดับสูงซึ่งในกรณีนี้ฉันจะไม่มีวันเข้าใจพวกเขา :(

ทรานสดิวเซอร์เป็นสูตรที่จะทำอย่างไรกับลำดับข้อมูลโดยที่ไม่รู้ว่าลำดับพื้นฐานคืออะไร (ทำอย่างไร) อาจเป็นช่อง seq, async หรืออาจสังเกตได้

พวกเขาเป็นแบบประกอบและหลายรูปแบบ

ข้อดีคือคุณไม่จำเป็นต้องใช้ตัวรวมมาตรฐานทั้งหมดทุกครั้งที่มีการเพิ่มแหล่งข้อมูลใหม่ ครั้งแล้วครั้งเล่า. ผลที่ตามมาคือคุณในขณะที่ผู้ใช้สามารถนำสูตรอาหารเหล่านั้นกลับมาใช้ซ้ำในแหล่งข้อมูลต่างๆได้

อัปเดตโฆษณา

เวอร์ชันก่อนหน้า 1.7 ของ Clojure คุณมีสามวิธีในการเขียนแบบสอบถามกระแสข้อมูล:

1. การโทรที่ซ้อนกัน

    (reduce + (filter odd? (map #(+ 2 %) (range 0 10))))

2. องค์ประกอบการทำงาน

    (def xform
      (comp
        (partial filter odd?)
        (partial map #(+ 2 %))))
    (reduce + (xform (range 0 10)))

3. มาโครเธรด

    (defn xform [xs]
      (->> xs
           (map #(+ 2 %))
           (filter odd?)))
    (reduce + (xform (range 0 10)))

ด้วยทรานสดิวเซอร์คุณจะเขียนมันดังนี้:

(def xform
  (comp
    (map #(+ 2 %))
    (filter odd?)))
(transduce xform + (range 0 10))

พวกเขาทั้งหมดทำเหมือนกัน ความแตกต่างคือคุณไม่เคยโทรหา Transducers โดยตรงคุณส่งต่อไปยังฟังก์ชันอื่น ทรานสดิวเซอร์รู้ว่าต้องทำอย่างไรฟังก์ชันที่รับทรานสดิวเซอร์รู้ได้อย่างไร ลำดับของตัวรวมกันก็เหมือนกับที่คุณเขียนด้วยมาโครเธรด (ลำดับธรรมชาติ) ตอนนี้คุณสามารถใช้ซ้ำxformกับช่อง:

(chan 1 xform)

ทรานสดิวเซอร์ปรับปรุงประสิทธิภาพและช่วยให้คุณเขียนโค้ดที่มีประสิทธิภาพด้วยวิธีโมดูลาร์มากขึ้น

นี่คือการวิ่งผ่านที่ดี

เมื่อเทียบกับการแต่งสายเก่าmap, filter, reduceฯลฯ คุณจะได้รับประสิทธิภาพที่ดีขึ้นเพราะคุณไม่จำเป็นต้องสร้างคอลเลกชันกลางระหว่างแต่ละขั้นตอนและซ้ำ ๆ เดินคอลเลกชันเหล่านั้น

เมื่อเทียบกับreducersหรือเขียนการดำเนินการทั้งหมดของคุณให้เป็นนิพจน์เดียวด้วยตนเองคุณจะสามารถใช้นามธรรมได้ง่ายขึ้นความเป็นโมดูลาร์ที่ดีขึ้นและการใช้ฟังก์ชันการประมวลผลซ้ำ

ทรานสดิวเซอร์เป็นวิธีการรวมกันเพื่อลดฟังก์ชัน

ตัวอย่าง: ฟังก์ชันการลดคือฟังก์ชันที่รับอาร์กิวเมนต์สองค่า: ผลลัพธ์จนถึงตอนนี้และอินพุต พวกเขาส่งคืนผลลัพธ์ใหม่ (จนถึงปัจจุบัน) ตัวอย่างเช่น+เมื่อมีอาร์กิวเมนต์สองตัวคุณสามารถคิดว่าอันแรกเป็นผลลัพธ์จนถึงตอนนี้และอันที่สองเป็นอินพุต

ตอนนี้ทรานสดิวเซอร์สามารถใช้ฟังก์ชัน + และทำให้เป็นฟังก์ชันบวกสองครั้ง (เพิ่มทุกอินพุตเป็นสองเท่าก่อนเพิ่ม) นี่คือลักษณะของตัวแปลงสัญญาณ (ในแง่พื้นฐานส่วนใหญ่):

(defn double
  [rfn]
  (fn [r i] 
    (rfn r (* 2 i))))

แทนภาพประกอบrfnด้วย+เพื่อดูว่า+จะเปลี่ยนเป็นครั้งที่สองบวก:

(def twice-plus ;; result of (double +)
  (fn [r i] 
    (+ r (* 2 i))))

(twice-plus 1 2)  ;-> 5
(= (twice-plus 1 2) ((double +) 1 2)) ;-> true

ดังนั้น

(reduce (double +) 0 [1 2 3]) 

ตอนนี้จะให้ผล 12

การลดฟังก์ชันที่ส่งคืนโดยทรานสดิวเซอร์ไม่ขึ้นอยู่กับวิธีการสะสมของผลลัพธ์เนื่องจากฟังก์ชันเหล่านี้สะสมด้วยฟังก์ชันการลดที่ส่งผ่านไปยังฟังก์ชันเหล่านั้นโดยไม่รู้วิธี ที่นี่เราใช้conjแทน+. Conjรับคอลเล็กชันและค่าและส่งคืนคอลเล็กชันใหม่พร้อมกับค่านั้นต่อท้าย

(reduce (double conj) [] [1 2 3]) 

จะให้ผล [2 4 6]

นอกจากนี้ยังไม่ขึ้นกับแหล่งที่มาของอินพุต

ทรานสดิวเซอร์หลายตัวสามารถผูกมัดเป็นสูตร (chainable) เพื่อเปลี่ยนฟังก์ชันการลด

อัปเดต: เนื่องจากตอนนี้มีหน้าอย่างเป็นทางการเกี่ยวกับเรื่องนี้ฉันขอแนะนำให้อ่าน: http://clojure.org/transducers

สมมติว่าคุณต้องการใช้ชุดฟังก์ชันเพื่อเปลี่ยนสตรีมข้อมูล เปลือก Unix ช่วยให้คุณทำสิ่งนี้กับตัวดำเนินการท่อเช่น

cat /etc/passwd | tr '[:lower:]' '[:upper:]' | cut -d: -f1| grep R| wc -l

(คำสั่งด้านบนจะนับจำนวนผู้ใช้ที่มีตัวอักษร r เป็นตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็กในชื่อผู้ใช้) สิ่งนี้ถูกนำไปใช้เป็นชุดของกระบวนการซึ่งแต่ละกระบวนการอ่านจากผลลัพธ์ของกระบวนการก่อนหน้าดังนั้นจึงมีสตรีมกลางสี่สาย คุณสามารถจินตนาการถึงการนำไปใช้งานที่แตกต่างกันซึ่งประกอบด้วยคำสั่งห้าคำสั่งเป็นคำสั่งรวมคำสั่งเดียวซึ่งจะอ่านจากอินพุตและเขียนเอาต์พุตทุกครั้ง หากสตรีมระดับกลางมีราคาแพงและองค์ประกอบราคาถูกนั่นอาจเป็นการแลกเปลี่ยนที่ดี

สิ่งเดียวกันนี้ถือสำหรับ Clojure มีหลายวิธีในการแสดงไปป์ไลน์ของการเปลี่ยนแปลง แต่ขึ้นอยู่กับว่าคุณทำอย่างไรคุณสามารถจบลงด้วยสตรีมระดับกลางที่ส่งผ่านจากฟังก์ชันหนึ่งไปยังฟังก์ชันถัดไป หากคุณมีข้อมูลจำนวนมากการรวบรวมฟังก์ชันเหล่านั้นให้เป็นฟังก์ชันเดียวจะเร็วกว่า ทรานสดิวเซอร์ทำให้ง่ายต่อการทำเช่นนั้น นวัตกรรม Clojure รุ่นก่อนหน้านี้ช่วยให้คุณทำเช่นนั้นได้เช่นกัน แต่มีข้อ จำกัด บางประการ ทรานสดิวเซอร์ลบข้อ จำกัด บางส่วนออกไป

ดังนั้นเพื่อตอบคำถามของคุณทรานสดิวเซอร์ไม่จำเป็นต้องทำให้โค้ดของคุณสั้นลงหรือเข้าใจได้มากขึ้น แต่โค้ดของคุณอาจจะไม่เข้าใจนานขึ้นหรือน้อยลงเช่นกันและหากคุณกำลังทำงานกับข้อมูลจำนวนมากตัวแปลงสัญญาณสามารถสร้างโค้ดของคุณได้ เร็วขึ้น

นี่เป็นภาพรวมของทรานสดิวเซอร์ที่ค่อนข้างดี

Rich Hickey บรรยาย 'Transducers' ในการประชุม Strange Loop 2014 (45 นาที)

เขาอธิบายง่ายๆว่าทรานสดิวเซอร์คืออะไรพร้อมตัวอย่างในโลกแห่งความเป็นจริง - การแปรรูปกระเป๋าในสนามบิน เขาแยกแง่มุมที่แตกต่างกันอย่างชัดเจนและแตกต่างกับแนวทางปัจจุบัน ในตอนท้ายเขาให้เหตุผลสำหรับการดำรงอยู่ของพวกเขา

วิดีโอ: https://www.youtube.com/watch?v=6mTbuzafcII

ฉันพบว่าการอ่านตัวอย่างจากทรานสดิวเซอร์ -Jsช่วยให้ฉันเข้าใจในแง่ที่เป็นรูปธรรมว่าฉันจะใช้มันในโค้ดวันต่อวันได้อย่างไร

ตัวอย่างเช่นพิจารณาตัวอย่างนี้ (นำมาจาก README ที่ลิงค์ด้านบน):

var t = require("transducers-js");

var map    = t.map,
    filter = t.filter,
    comp   = t.comp,
    into   = t.into;

var inc    = function(n) { return n + 1; };
var isEven = function(n) { return n % 2 == 0; };
var xf     = comp(map(inc), filter(isEven));

console.log(into([], xf, [0,1,2,3,4])); // [2,4]

ประการแรกการใช้งานxfจะดูสะอาดกว่าทางเลือกปกติด้วยเครื่องหมายขีดล่าง

_.filter(_.map([0, 1, 2, 3, 4], inc), isEven);

ทรานสดิวเซอร์เป็นฟังก์ชัน (ตามความเข้าใจของฉัน!) ซึ่งใช้ฟังก์ชันลดหนึ่งฟังก์ชันและส่งกลับอีกฟังก์ชันหนึ่ง ฟังก์ชันการลดคือฟังก์ชันหนึ่ง

ตัวอย่างเช่น:

user> (def my-transducer (comp count filter))
#'user/my-transducer
user> (my-transducer even? [0 1 2 3 4 5 6])
4
user> (my-transducer #(< 3 %) [0 1 2 3 4 5 6])
3

ในกรณีนี้ตัวแปลงสัญญาณของฉันใช้ฟังก์ชันการกรองอินพุตซึ่งใช้กับ 0 แล้วถ้าค่านั้นเท่ากัน? ในกรณีแรกตัวกรองส่งค่านั้นไปยังตัวนับจากนั้นตัวกรองจะกรองค่าถัดไป แทนที่จะกรองก่อนแล้วส่งผ่านค่าเหล่านั้นไปนับ

มันเป็นสิ่งเดียวกันในตัวอย่างที่สองที่ตรวจสอบทีละค่าและถ้าค่านั้นน้อยกว่า 3 ก็ให้นับเพิ่ม 1

คำจำกัดความที่ชัดเจนของตัวแปลงสัญญาณอยู่ที่นี่:

Transducers are a powerful and composable way to build algorithmic transformations that you can reuse in many contexts, and they’re coming to Clojure core and core.async.

เพื่อทำความเข้าใจลองพิจารณาตัวอย่างง่ายๆต่อไปนี้:

;; The Families in the Village

(def village
  [{:home :north :family "smith" :name "sue" :age 37 :sex :f :role :parent}
   {:home :north :family "smith" :name "stan" :age 35 :sex :m :role :parent}
   {:home :north :family "smith" :name "simon" :age 7 :sex :m :role :child}
   {:home :north :family "smith" :name "sadie" :age 5 :sex :f :role :child}

   {:home :south :family "jones" :name "jill" :age 45 :sex :f :role :parent}
   {:home :south :family "jones" :name "jeff" :age 45 :sex :m :role :parent}
   {:home :south :family "jones" :name "jackie" :age 19 :sex :f :role :child}
   {:home :south :family "jones" :name "jason" :age 16 :sex :f :role :child}
   {:home :south :family "jones" :name "june" :age 14 :sex :f :role :child}

   {:home :west :family "brown" :name "billie" :age 55 :sex :f :role :parent}
   {:home :west :family "brown" :name "brian" :age 23 :sex :m :role :child}
   {:home :west :family "brown" :name "bettie" :age 29 :sex :f :role :child}

   {:home :east :family "williams" :name "walter" :age 23 :sex :m :role :parent}
   {:home :east :family "williams" :name "wanda" :age 3 :sex :f :role :child}])

แล้วเราอยากรู้ว่ามีเด็กกี่คนในหมู่บ้าน? เราสามารถค้นหาได้อย่างง่ายดายด้วยตัวลดต่อไปนี้:

;; Example 1a - using a reducer to add up all the mapped values

(def ex1a-map-children-to-value-1 (r/map #(if (= :child (:role %)) 1 0)))

(r/reduce + 0 (ex1a-map-children-to-value-1 village))
;;=>
8

นี่เป็นอีกวิธีหนึ่งที่ทำได้:

;; Example 1b - using a transducer to add up all the mapped values

;; create the transducers using the new arity for map that
;; takes just the function, no collection

(def ex1b-map-children-to-value-1 (map #(if (= :child (:role %)) 1 0)))

;; now use transduce (c.f r/reduce) with the transducer to get the answer 
(transduce ex1b-map-children-to-value-1 + 0 village)
;;=>
8

นอกจากนี้ยังมีประสิทธิภาพมากเมื่อใช้กลุ่มย่อยในบัญชีด้วย ตัวอย่างเช่นหากเราต้องการทราบจำนวนเด็กในครอบครัวบราวน์เราสามารถดำเนินการ:

;; Example 2a - using a reducer to count the children in the Brown family

;; create the reducer to select members of the Brown family
(def ex2a-select-brown-family (r/filter #(= "brown" (string/lower-case (:family %)))))

;; compose a composite function to select the Brown family and map children to 1
(def ex2a-count-brown-family-children (comp ex1a-map-children-to-value-1 ex2a-select-brown-family))

;; reduce to add up all the Brown children
(r/reduce + 0 (ex2a-count-brown-family-children village))
;;=>
2

ฉันหวังว่าคุณจะพบตัวอย่างเหล่านี้ที่เป็นประโยชน์ คุณสามารถค้นหาเพิ่มเติมได้ที่นี่

หวังว่าจะช่วยได้

Clemencio Morales Lucas

ฉันเขียนบล็อกเกี่ยวกับเรื่องนี้ด้วยตัวอย่าง clojurescript ซึ่งอธิบายว่าตอนนี้ฟังก์ชั่นลำดับสามารถขยายได้อย่างไรโดยสามารถแทนที่ฟังก์ชันการลด

นี่คือประเด็นของทรานสดิวเซอร์ที่ฉันอ่าน หากคุณคิดว่าเกี่ยวกับconsหรือconjการดำเนินการที่เขียนยากในการดำเนินงานเช่นmap, filterฯลฯ ฟังก์ชั่นการลดก็ไม่สามารถเข้าถึงได้

ด้วยทรานสดิวเซอร์ฟังก์ชันการลดจะถูกแยกออกและฉันสามารถแทนที่ได้เหมือนกับที่ฉันทำกับอาร์เรย์จาวาสคริปต์ดั้งเดิมpushด้วยตัวแปลงสัญญาณ

(transduce (filter #(not (.hasOwnProperty prevChildMapping %))) (.-push #js[]) #js [] nextKeys)

filter และเพื่อน ๆ มีการดำเนินการ 1 arity ใหม่ที่จะส่งคืนฟังก์ชันการแปลงสัญญาณที่คุณสามารถใช้เพื่อจัดหาฟังก์ชันการลดของคุณเอง

นี่คือศัพท์แสง (ส่วนใหญ่) และคำตอบที่ไม่มีรหัสของฉัน

ลองนึกถึงข้อมูลในสองวิธีสตรีม (ค่าที่เกิดขึ้นเมื่อเวลาผ่านไปเช่นเหตุการณ์) หรือโครงสร้าง (ข้อมูลที่มีอยู่ ณ ช่วงเวลาหนึ่งเช่นรายการเวกเตอร์อาร์เรย์ ฯลฯ )

มีการดำเนินการบางอย่างที่คุณอาจต้องการดำเนินการกับสตรีมหรือโครงสร้าง การดำเนินการอย่างหนึ่งคือการทำแผนที่ ฟังก์ชันการทำแผนที่อาจเพิ่มรายการข้อมูลแต่ละรายการ (สมมติว่าเป็นตัวเลข) ด้วย 1 และคุณคงพอจะนึกออกว่าสิ่งนี้จะนำไปใช้กับสตรีมหรือโครงสร้างได้อย่างไร

ฟังก์ชันการทำแผนที่เป็นเพียงคลาสหนึ่งของฟังก์ชันที่บางครั้งเรียกว่า "ฟังก์ชันการลด" ฟังก์ชันการลดทั่วไปอีกอย่างหนึ่งคือตัวกรองซึ่งจะลบค่าที่ตรงกับเพรดิเคต (เช่นลบค่าทั้งหมดที่เป็นคู่)

ทรานสดิวเซอร์ช่วยให้คุณ "ตัด" ลำดับของฟังก์ชันการลดอย่างน้อยหนึ่งฟังก์ชันและสร้าง "แพ็กเกจ" (ซึ่งก็คือฟังก์ชัน) ที่ทำงานได้ทั้งบนสตรีมหรือโครงสร้าง ตัวอย่างเช่นคุณสามารถ "แพ็กเกจ" ลำดับของฟังก์ชันการลด (เช่นกรองเลขคู่จากนั้นแมปตัวเลขผลลัพธ์เพื่อเพิ่มขึ้นทีละ 1) จากนั้นใช้ "แพ็กเกจ" ตัวแปลงสัญญาณนั้นกับสตรีมหรือโครงสร้างของค่า (หรือทั้งสองอย่าง) .

มีอะไรพิเศษเกี่ยวกับเรื่องนี้? โดยปกติแล้วฟังก์ชันการลดขนาดไม่สามารถประกอบได้อย่างมีประสิทธิภาพเพื่อทำงานทั้งบนสตรีมและโครงสร้าง

ประโยชน์ที่คุณจะได้รับคือคุณสามารถใช้ประโยชน์จากความรู้เกี่ยวกับฟังก์ชันเหล่านี้และนำไปใช้กับกรณีการใช้งานได้มากขึ้น ค่าใช้จ่ายสำหรับคุณคือคุณต้องเรียนรู้เครื่องจักรพิเศษบางอย่าง (เช่นตัวแปลงสัญญาณ) เพื่อให้คุณได้รับพลังพิเศษนี้

เท่าที่ฉันเข้าใจพวกเขาเป็นเหมือนหน่วยการสร้างโดยแยกออกจากการใช้อินพุตและเอาต์พุต คุณเพียงแค่กำหนดการดำเนินการ

เนื่องจากการใช้งานการดำเนินการไม่ได้อยู่ในรหัสของอินพุตและไม่มีการดำเนินการใด ๆ กับเอาต์พุตตัวแปลงสัญญาณจึงสามารถใช้ซ้ำได้อย่างมาก พวกเขาเตือนฉันของการไหลในAkka Streams

ฉันยังใหม่กับทรานสดิวเซอร์ขออภัยสำหรับคำตอบที่อาจไม่ชัดเจน

ฉันพบว่าโพสต์นี้ให้มุมมองของทรานสดิวเซอร์แบบเบิร์ดอายมากขึ้น

https://medium.com/@roman01la/understand-transducers-in-javascript-3500d3bd9624