Cách tốt nhất để tích lũy kết quả trong một vector trong Clojure là gì? (Mã chức năng thuần túy có vẻ xấu xí và tiết)

Question

... Có thể lập trình bắt buộc với dữ liệu có thể thay đổi được khoan sâu vào bộ não của tôi, nhưng tôi tìm thấy mã để xây dựng vectơ dữ liệu trong Clojure để tiết, khó sử dụng và phức tạp . Phải có cách tốt hơn!

Trong Ruby tôi có thể viết mã như:

results = [] 
a_collection.each do |x| 
    x.nested_collection.each do |y| 
    next if some_condition_holds 
    results << y 
    end 
end 

Trong Clojure, tôi không biết một cách tốt hơn để làm điều đó hơn là sử dụng một hàm đệ quy, có lẽ như sau (khủng khiếp) mã:

; NEWBIE ALERT! NEWBIE ALERT! 
(loop [results [] 
     remaining a_collection] 
    (if (empty? remaining) 
     results 
     (recur 
     (loop [results results 
       nested (nested_collection (first remaining))] 
      (if (empty? nested) 
       results 
       (if (some_condition_holds) 
        (recur results (rest nested)) 
        (recur (conj results (first nested)) (rest nested))))) 
     (rest remaining)))) 

Nếu không có dữ liệu có thể thay đổi và lặp lặp lại, bạn cần sử dụng đệ quy để tạo bộ sưu tập. Mỗi hàm đệ quy như vậy cần một mệnh đề bảo vệ (empty?), v.v ... Toàn bộ điều này lặp đi lặp lại nó khiến tôi muốn hét lên.

Trong trường hợp đơn giản, map là đủ, nhưng tôi đang nghĩ đến trường hợp có nhiều cấp độ lồng nhau và ở mỗi cấp, có thể có các điều kiện yêu cầu bỏ qua một lần lặp.

Trong Lisp thông thường, tôi có thể sử dụng macro loop hoặc mapcan. Clojure không có bất cứ điều gì như mapcan?

Answer 1

Trong thứ tự giảm dần về cách thoải mái Tôi nghĩ tùy chọn giao diện:

(for [x coll, 
     y (nested-collection x) 
     :when (not (some-condition-holds y))] 
    y) 

Ngoài ra, nếu bạn muốn thay vì xây dựng nó ra khỏi các chức năng như map và mapcat thay vì sử dụng for cú pháp:

(mapcat (fn [x] 
      (remove some-condition-holds 
        (nested-collection x))) 
     coll) 

Nếu bạn đang thực sự quan tâm vào nó, bạn cũng có thể xây dựng nó với các ứng dụng chức năng một phần và thành phần:

(mapcat (comp (partial remove some-condition-holds) 
       nested-collection) 
     coll) 

Kiểu thứ ba này không đọc rất tốt ở Clojure, mặc dù mã tương đương ở một số ngôn ngữ khác rất hay. Trong Haskell, ví dụ:

coll >>= (filter (not . someConditionHolds) . nestedCollection) 

Answer 2

chức năng đặt hàng cao hơn thực sự có thể giúp làm cho nó đẹp hơn nhiều mặc dù phải mất một thời gian để làm quen với suy nghĩ theo trình tự và chuyển đổi chuỗi.

có rất nhiều cách để viết những dòng này:

user> (into [] a_colletion) 
[0 1 2 3 4 5 6 7 8 9] 

user> (vec a_colletion) 
[0 1 2 3 4 5 6 7 8 9] 

user> (for [x a_colletion :when (even? x)] x) 
(0 2 4 6 8) 

một ví dụ phức tạp hơn có thể trông giống như thế này:

(flatten (for [x (map extract-from-nested-collection a_collection) 
       :when (test-conditions? x)] 
      x)) 

làm cho một bộ sưu tập lồng nhau

user> (def a_collection (map #(reductions + (range %)) (range 1 5))) 
#'user/a_collection 
user> a_collection 
((0) (0 1) (0 1 3) (0 1 3 6)) 

lấy một lồng nhau bộ sưu tập từ mỗi phần tử của a_collection và bỏ qua một số phần tử:

user> (map #(filter pos? %) a_collection) 
(() (1) (1 3) (1 3 6)) 

thêm các bộ sưu tập lồng nhau cùng

user> (flatten (map #(filter pos? %) a_collection)) 
(1 1 3 1 3 6) 

lọc một số bất cứ điều gì lớn hơn 3 từ bộ sưu tập san phẳng và sau đó vuông mỗi trong số họ

user> (for [x (flatten (map #(filter pos? %) a_collection)) 
       :when (<= x 3)] 
      (* x x)) 
(1 1 9 1 9) 
user> 

Answer 3

(mapcat (fn [y] (filter condition y)) x) 

Answer 4

Những người khác đã cung cấp câu trả lời về cách giải quyết vấn đề quy định sử dụng khái niệm FP như sử dụng chức năng tự cao. Nếu bạn phân tích quá trình suy nghĩ dẫn đến mã hiện tại của mình và so sánh với các giải pháp FP mà người khác đã cung cấp, bạn sẽ thấy rằng bất cứ khi nào bạn nghĩ - "có một biến để lưu trữ kết quả đã xử lý" - nó sẽ dẫn đến OR bắt buộc từng bước giải pháp và do đó mã Clojure của bạn chủ yếu là bắt buộc khi bạn nghĩ về lưu trữ kết quả là một "biến vector". Loại tư duy này sẽ không cho phép bạn áp dụng các khái niệm FP dựa trên "đánh giá biểu thức" và "giải quyết vấn đề theo thành phần"

Answer 5

amalloy's answer có lẽ là tốt nhất nếu bạn muốn theo một phong cách chức năng thành ngữ và tạo ra một sự lười biếng trình tự.

Nếu bạn đang thực sự quan tâm đến việc phải nhất thiết xây dựng một vector (chứ không phải là một chuỗi lười biếng), tôi có lẽ sẽ làm điều đó bằng một nguyên tử và doseq như sau:

(let [v (atom [])] 
    (doseq [x (range 5) 
      y (range 5)] 
    (if (> y x) 
     (swap! v conj (str x y)))) 
    @v) 

=> ["01" "02" "03" "04" "12" "13" "14" "23" "24" "34"] 

Như bạn có thể thấy, đây kết thúc cấu trúc rất giống với mã Ruby.

Cũng có thể thực hiện việc này bằng cách giảm, tuy nhiên điều này phù hợp nhất khi chỉ có một chuỗi đầu vào, ví dụ::

(reduce 
    (fn [v x] 
    (if (even? x) 
     (conj v x) 
     v)) 
    [] 
    (range 20)) 

=> [0 2 4 6 8 10 12 14 16 18]