Chức năng phối hợp Clojure

Question

SQL cung cấp một hàm có tên là coalesce(a, b, c, ...) trả về giá trị rỗng nếu tất cả các đối số của nó là null, nếu không nó sẽ trả về đối số không null đầu tiên.

Bạn sẽ viết một cái gì đó như thế này ở Clojure như thế nào?

Nó sẽ được gọi như sau: (coalesce f1 f2 f3 ...) trong đó fi là các hình thức chỉ nên được đánh giá nếu được yêu cầu. Nếu f1 không phải là không, thì không nên đánh giá f2 - nó có thể có tác dụng phụ.

Có thể Clojure đã cung cấp chức năng (hoặc macro) như vậy.

EDIT: Dưới đây là một giải pháp mà tôi đã đưa ra (sửa đổi từ trình của Stuart Halloway Clojure, (and ...) vĩ mô trên trang 206):

(defmacro coalesce 
    ([] nil) 
    ([x] x) 
    ([x & rest] `(let [c# ~x] (if c# c# (coalesce ~@rest))))) 

vẻ để làm việc.

(defmacro coalesce 
    ([] nil) 
    ([x] x) 
    ([x & rest] `(let [c# ~x] (if (not (nil? c#)) c# (coalesce ~@rest))))) 

Đã sửa lỗi.

Answer 1

Dựa trên câu trả lời nickik và "hay" vĩ mô clojure:

(defmacro coalesce 
    ([] nil) 
    ([x] x) 
    ([x & next] 
     `(let [v# ~x] 
      (if (not (nil? v#)) v# (coalesce ~@next))))) 

Answer 2

Điều bạn muốn là macro "hoặc".

Đánh giá từng lần một, từ trái sang phải. Nếu một biểu mẫu trả về giá trị thực sự hợp lý hoặc trả về giá trị đó và không đánh giá bất kỳ biểu thức nào khác, nếu không, giá trị này sẽ trả về giá trị của biểu thức cuối cùng. (hoặc) trả về nil.

http://clojuredocs.org/clojure_core/clojure.core/or

Nếu bạn chỉ muốn bằng không và không sai làm một viết lại và và đặt tên nó kết thành một khối.

Chỉnh sửa:

Không thể thực hiện chức năng này vì chức năng đánh giá tất cả các đối số của họ trước tiên. Điều này có thể được thực hiện trong Haskell vì chức năng là lười (không chắc chắn 100% về điều Haskell).

Answer 3

Bạn có thể sử dụng tiếp tục giới thiệu trong 1.2:

EDIT: câu trả lời mở rộng một chút. Macro cho các cuộc xâm lược trực tiếp. Người trợ giúp cho ví dụ. áp dụng + lazy seq tạo ra các giá trị.

(defn coalesce* 
    [values] 
    (first (keep identity values))) 

(defmacro coalesce 
    [& values] 
    `(coalesce* (lazy-list ~@values))) 

Tuy nhiên để ngăn chặn việc đánh giá giá trị, người ta cần một số cách phát triển tại nhà.

Ugly:

(lazy-cat [e1] [e2] [e3])

Một chút tham gia nhiều hơn nhưng đẹp hơn trong các mã:

(defn lazy-list* 
    [& delayed-values] 
    (when-let [delayed-values (seq delayed-values)] 
    (reify 
     clojure.lang.ISeq 
     (first [this] @(first delayed-values)) 
     (next [this] (lazy-list* (next delayed-values))) 
     (more [this] (or (next this)()))))) 

(defmacro lazy-list 
    [& values] 
    `(lazy-list* ~@(map (fn [v] `(delay ~v)) values)) 

Answer 4

Có lẽ tôi đang hiểu sai câu hỏi, nhưng không phải đây chỉ là phần tử được lọc đầu tiên?

Ví dụ:

 
user=> (first (filter (complement nil?) [nil false :foo])) 
false 
user=> (first (filter (complement nil?) [nil :foo])) 
:foo 
user=> (first (filter (complement nil?) [])) 
nil 
user=> (first (filter (complement nil?) nil)) 
nil 

Nó có thể được rút ngắn đến:

 
(defn coalesce [& vals] 
    (first (filter (complement nil?) vals))) 

 
user=> (coalesce nil false :foo) 
false 
user=> (coalesce nil :foo) 
:foo 
user=> (coalesce nil) 
nil 
user=> (coalesce) 
nil 

Answer 5

Một số phiên bản chức năng của liên hiệp, nếu bạn muốn tránh macro:

(defn coalesce 
    "Returns first non-nil argument." 
    [& args] 
    (first (keep identity args))) 

(defn coalesce-with 
    "Returns first argument which passes f." 
    [f & args] 
    (first (filter f args))) 

Cách sử dụng:

=> (coalesce nil "a" "b") 
"a" 
=> (coalesce-with not-empty nil "" "123") 
"123" 

Không giống như thông số kỹ thuật, điều này sẽ đánh giá tất cả các arg. Sử dụng or hoặc giải pháp macro thích hợp khác nếu bạn muốn đánh giá ngắn mạch.