Bạn có thể triển khai thiết kế theo hợp đồng bằng Clojure cụ thể hoặc các ngôn ngữ chức năng nói chung như thế nào?

Question

Tôi thích các ví dụ về biến thể Lisp (điểm thưởng cho Clojure hoặc Scheme) vì đó là những gì tôi quen thuộc nhất, nhưng bất kỳ phản hồi nào về DBC trong các phần lan chức năng sẽ có giá trị đối với cộng đồng lớn hơn.

Dưới đây là một cách rõ ràng:

(defn foo [action options] 
    (when-not (#{"go-forward" "go-backward" "turn-right" "turn-left"} action) 
       (throw (IllegalArgumentException. 
        "unknown action"))) 
    (when-not (and (:speed options) (> (:speed options) 0)) 
       (throw (IllegalArgumentException. 
        "invalid speed"))) 
    ; finally we get to the meat of the logic) 

Những gì tôi không thích về thực hiện này là logic hợp đồng làm lu mờ các chức năng cốt lõi; mục đích thực sự của hàm bị mất trong các kiểm tra có điều kiện. Đây là cùng một vấn đề tôi nêu ra trong this question. Trong một ngôn ngữ bắt buộc như Java, tôi có thể sử dụng chú thích hoặc siêu dữ liệu/thuộc tính được nhúng trong tài liệu để di chuyển hợp đồng ra khỏi triển khai phương pháp.

Có ai đã xem xét thêm hợp đồng vào siêu dữ liệu trong Clojure không? Các hàm bậc cao hơn sẽ được sử dụng như thế nào? tùy chọn khác là gì ở đó?

Answer 1

Clojure đã có sự hỗ trợ cho trước và sau điều kiện, tiếc là không tốt tài liệu:

Should I use a function or a macro to validate arguments in Clojure?

Answer 2

tôi có thể tưởng tượng một cái gì đó như thế này trong Clojure:

(defmacro defnc 
    [& fntail] 
    `(let [logic# (fn ~@(next fntail))] 
    (defn ~(first fntail) 
     [& args#] 
     (let [metadata# (meta (var ~(first fntail)))] 
     (doseq [condition# (:preconditions metadata#)] 
      (apply condition# args#)) 
     (let [result# (apply logic# args#)] 
      (doseq [condition# (:postconditions metadata#)] 
      (apply condition# result# args#)) 
      result#))))) 

(defmacro add-pre-condition! 
    [f condition] 
    `(do 
    (alter-meta! (var ~f) update-in [:preconditions] conj ~condition) 
    nil)) 

(defmacro add-post-condition! 
    [f condition] 
    `(do 
    (alter-meta! (var ~f) update-in [:postconditions] conj ~condition) 
    nil))

Một phiên dụ:

user=> (defnc t [a test] (a test)) 
\#'user/t 
user=> (t println "A Test") 
A Test 
nil 
user=> (t 5 "A Test") 
java.lang.ClassCastException: java.lang.Integer (NO_SOURCE_FILE:0) 
user=> (add-pre-condition! t (fn [a _] (when-not (ifn? a) (throw (Exception. "Aaargh. Not IFn!"))))) 
nil 
user=> (t 5 "A Test") 
java.lang.Exception: Aaargh. Not IFn! (NO_SOURCE_FILE:0) 
user=> (t println "A Test") 
A Test 
nil

Vì vậy, bạn có thể xác định chức năng, rồi sau đó xác định trước và sau điều kiện bất cứ nơi nào bạn thích , mà không làm lộn xộn chính hàm logic.

chức năng điều kiện phải loại trừ một ngoại lệ nếu có điều gì đó sai.