Clojure 的 CLOS？

Question

Clojure 是否存在类似 CLOS （Common Lisp 对象系统）之类的东西？

Answer 1

您是否考虑过 Clojure 的数据类型（尤其是 defrecord），协议 和多方法？这三者在 Clojure 中总是比这些机制之上的 CLOS 端口更惯用。

Answer 2

Clojure 本身没有对象系统，原因有二：

1. Clojure 专门设计为托管在面向对象的平台上，然后它只是吸收底层平台的对象系统。即ClojureJVM有JVM对象系统，ClojureCLR有CLI对象系统，ClojureScript有ECMAScript对象系统，等等。
2. 里奇·希基讨厌物体。

但是，您显然可以在 Clojure 中实现对象系统。毕竟，Clojure 是图灵完备的。

Mikel Evins 正在研究一种新的 OO 方法，他称之为 类别。他实现了多种 Lisp，包括 Clojure（尽管不能保证所有端口始终保持最新）。

类别正在慢慢被 Bard 所涵盖，这是 Mikel 正在设计的一种新的 Lisp 方言，它内置了类别。（然后反过来，可能会成为 Mikel 的一个想法 Closos 的实现语言了解如何设计操作系统。）

Answer 3

Clojure 没有 CLOS 并且不需要 CLOS，但你可以实现它。

Clojure 希望是不可变的，因此拥有可变的 OO 有点愚蠢，但你可以拥有一种 OO。

• http://clojure.org/datatypes （查看 defrecord --> 最好的类和哈希映射)
• http://clojure.org/protocols （有点像接口，但更好）
• http://clojure.org/multimethods （功能强大，因为您可以编写自己的调度函数）

有了这三件事，您应该能够满足您的所有需求需要，但大多数时候，最好只使用普通函数和标准数据结构。

Answer 4

使用 OO 范式非常适合编写松散耦合的代码、模拟和测试。 Clojure 使这变得如此容易完成。

我过去遇到的一个问题是代码依赖于其他代码。如果使用得不好，Clojure 命名空间实际上会加剧问题。理想情况下，名称空间可以被模拟出来，但正如我发现的那样......模拟名称空间存在很多问题：

https://groups.google.com/forum/?fromgroups=#!topic/clojure/q3PazKoRlKU

一旦您开始构建越来越大的应用程序，命名空间就会开始依赖于彼此之间，在没有一堆依赖关系的情况下单独测试更高级别的组件真的很不方便。大多数解决方案都涉及函数重新绑定和其他黑魔法，但问题是在测试时，原始依赖项仍在加载 - >如果你有一个很大的应用程序，这就会成为一个大问题。

---

在使用数据库后，我有动力去寻找替代方案。数据库库给我带来了很大的痛苦 - 它们需要很长时间才能加载，并且通常位于应用程序的核心。如果不将整个数据库、库和相关外围设备带入测试代码中，就很难测试您的应用程序。

您希望能够打包文件，以便可以“交换”系统中依赖于数据库代码的部分。 OO 设计方法论提供了答案。

很抱歉，答案很长...我想给出一个很好的理由来解释为什么为什么使用面向对象设计，而不是如何使用它。所以必须使用一个实际的例子。我尝试保留 ns 声明，以便示例应用程序的结构尽可能清晰。

现有的 clojure 风格代码

此示例使用 carmine，它是一个 Redis 客户端。与 korma 和 datomic 相比，它相对容易使用并且启动速度很快，但是数据库库仍然是数据库库：

(ns redis-ex.history
  (:require [taoensso.carmine :as car]
            [clojure.string :as st]))

(defmacro wcr [store kdir f & args]
  `(car/with-conn (:pool ~store) (:conn ~store)
     (~f (st/join "/" (concat [(:ns ~store)] ~kdir)) ~@args)))

(defn empty [store kdir]
  (wcr store kdir car/del))

(defn add-instance [store kdir dt data]
   (wcr store kdir car/zadd dt data))

(defn get-interval [store kdir dt0 dt1]
  (wcr store kdir car/zrangebyscore dt0 dt1))

(defn get-last [store kdir number]
  (wcr store kdir car/zrange (- number) -1))

(defn make-store [pool conn ns]
{:pool pool
 :conn conn
 :ns ns})

现有的测试代码

所有功能都应该进行测试......这不是什么新鲜事，是标准的 clojure 代码

(ns redis-ex.test-history0
   (:require [taoensso.carmine :as car]
             [redis-ex.history :as hist]))

(def store
  (hist/make-store
   (car/make-conn-pool)
   (car/make-conn-spec)
   "test"))

(hist/add-instance store ["hello"] 100 100) ;;=> 1
(hist/get-interval store ["hello"] 0 200) ;;=> [100]

面向对象的调度机制

在观看 Misko Hevery 的演讲后，我想到了“面向对象”并不是邪恶的，而是实际上非常有用的想法：

http://www.youtube.com/watch?v=XcT4yYu_TTs

基本思想是，如果你想构建一个大型应用程序，你必须分离“功能”（功能的核心）程序）来自“接线”（接口和依赖项）。依赖性越少越好。

我使用 clojure 哈希映射作为“对象”，因为它们没有库依赖项并且完全通用（请参阅 Brian Marick 谈论在 ruby​​ 中使用相同的范例 - http://vimeo.com/34522837）。

为了使您的 clojure 代码“面向对象”，您需要以下函数 - （send 窃取自 Smalltalk），该函数仅调度与映射中的键关联的函数（如果该函数与现有键关联）。

(defn call-if-not-nil [f & vs] 
   (if-not (nil? f) (apply f vs))

(defn send [obj kw & args] 
   (call-if-not-nil (obj kw) obj))

我在通用实用程序库中提供了实现（hara.fn 命名空间中的 https://github.com/zcaudate/hara）。如果你想自己实现的话，就4行代码。

定义对象“构造函数”后

，您现在可以修改原始的 make-store 函数以在映射中添加函数。现在你有了一定程度的间接性。

;;; in the redis-ex.history namespace, make change `make-store`
;;; to add our tested function definitions as map values.

(defn make-store [pool conn ns]
  {:pool pool
   :conn conn
   :ns ns
   :empty empty
   :add-instance add-instance
   :get-interval get-interval
   :get-last get-last})

---

;;; in a seperate test file, you can now test the 'OO' implementation

(ns redis-ex.test-history1
   (:require [taoensso.carmine :as car]
             [redis-ex.history :as hist]))
(def store
   (hist/make-store
   (car/make-conn-pool)
   (car/make-conn-spec)
   "test"))

  (require '[hara.fn :as f])
  (f/send store :empty ["test"])
  ;; => 1

  (f/send store :get-instance ["test"] 100000) 
  ;; => nil

  (f/send store :add-instance ["test"]
   {100000 {:timestamp 1000000 :data 23.4}
    200000 {:timestamp 2000000 :data 33.4}
    300000 {:timestamp 3000000 :data 43.4}
    400000 {:timestamp 4000000 :data 53.4}
    500000 {:timestamp 5000000 :data 63.4}})
  ;; => [1 1 1 1 1]

构建抽象

，因为 make-store 函数构造了一个完全独立的 store 对象，

(ns redis-ex.app
   (:require [hara.fn :as f]))

(defn get-last-3-elements [st kdir]
   (f/send st :get-last kdir 3))

如果您想使用它，可以定义函数来利用它。 .. 你会做类似的事情：

(ns redis-ex.test-app0
  (:use redis-ex.app 
        redis-ex.history)
  (:require [taoensso.carmine :as car]))

(def store
   (hist/make-store
   (car/make-conn-pool)
   (car/make-conn-spec)
   "test"))

(get-last-3-elements ["test"] store) 
;;=> [{:timestamp 3000000 :data 43.4} {:timestamp 4000000 :data 53.4} {:timestamp 5000000 :data 63.4}]

用 clojure - 'OO' 风格进行模拟

因此，这样做的真正优点是 get-last-3-elements 方法可以位于完全不同的命名空间中。它根本不依赖于数据库实现，因此测试此功能现在只需要一个轻量级的工具。

那么定义模拟就很简单了。 redis-ex.usecase 命名空间的测试可以在不加载任何数据库的情况下完成。

(ns redis-ex.test-app1
  (:use redis-ex.app))

(defn make-mock-store []
   {:database [{:timestamp 5000000 :data 63.4} 
               {:timestamp 4000000 :data 53.4}
               {:timestamp 3000000 :data 43.4} 
               {:timestamp 2000000 :data 33.4} 
               {:timestamp 1000000 :data 23.4}]
    :get-last (fn [store kdir number] 
                  (->> (:database store)
                       (take number)
                       reverse))})

(def mock-store (make-mock-store))
(get-last-3-elements ["test"] mock-store)
;; => [{:timestamp 3000000 :data 43.4} {:timestamp 4000000 :data 53.4} {:timestamp 5000000 :data 63.4}]

Answer 5

前面的文章将这个问题作为关于在 Clojure 中实现对面向对象编程的各种功能的特定支持的价值和可能性的问题来解决。然而，有一系列属性与该术语相关。并非所有面向对象语言都支持所有这些。 Clojure 直接支持其中一些属性，无论您是否想称其为“面向对象”支持。我将提到其中几个属性。

Clojure 可以使用其多方法系统支持分派分层定义的类型。基本功能是 defmulti 和 defmethod。 （也许第一次回答问题时这些还不可用。）

CLOS 相对不寻常的功能之一是它支持根据多个参数类型进行分派的函数。 Clojure 非常自然地模拟这种行为，如此处所示的示例。 （该示例本身并未使用类型 - 但这是 Clojure 多方法灵活性的一部分。与第一个示例进行比较 此处。）

Answer 6

CljOS 是 Clojure 的玩具 OOP 库。它绝不是完整这个词的意思。只是我为了好玩而做的东西。

Answer 7

这是一篇旧帖子，但我想回复它。

没有 clojure 不支持 OO，也不支持 CLOS。环境的底层对象系统仅在互操作性方面勉强可用，而不是在 clojure 中创建您自己的类/对象层次结构。 Clojure 是为了轻松访问 CLR 或 JVM 库而设计的，但 OOP 支持到此为止。

Clojure 是一个 Lisp，支持闭包和闭包。宏。考虑到这两个功能，您可以用几行代码开发一个基本的对象系统。

现在的问题是你真的需要 lisp 方言中的 OOP 吗？我会说不和是。不会，因为大多数问题都可以在没有对象系统的情况下解决，并且在任何 lisp 中都可以更优雅地解决。我会说是的，因为您仍然会时不时地需要 OOP，因此提供一个标准参考实现比让每个极客实现自己的实现更好。

我建议你看一下 Paul Graham 写的 On Lisp 一书。您可以在线免费咨询。

这真是一本好书，真正掌握了lisp的精髓。您必须稍微调整语法以适应 clojure，但概念保持不变。对于你的问题很重要，最后一章展示了如何在 lisp 中定义你自己的对象系统。

顺便说一句，Clojure 拥抱不变性。你可以在 clojure 中创建一个可变对象系统，但如果你坚持不变性，你的设计，甚至使用 OOP 也会有很大不同。大多数标准设计模式和构造都是考虑到可变性的。