Clojure是否支持Java的sealed interface模式？如何实现受控临时多态？

Clojure原生并没有像Java那样的sealed接口/record编译期强制机制——这确实是动态语言与静态语言的本质差异之一：动态语言设计上更倾向开放扩展，编译阶段不会限制谁能实现协议。但你可以通过以下几种方式近似实现"仅特定类型可扩展协议"的需求：

1. 命名空间级别的访问控制（约定+限制） #

将协议和允许实现它的类型放在同一个命名空间内，通过私有定义限制外部代码的扩展能力：

(ns myapp.sealed-types)

;; 定义私有协议，外部命名空间无法直接访问
(defprotocol ^:private SealedProtocol
  (do-stuff [this]))

;; 在同一命名空间内定义允许的类型并实现协议
(defrecord AllowedTypeA [data]
  SealedProtocol
  (do-stuff [this] (str "Doing stuff with A: " (:data this))))

(defrecord AllowedTypeB [value]
  SealedProtocol
  (do-stuff [this] (str "Doing stuff with B: " (:value this))))

;; 对外暴露协议的方法（可选，通过公共函数封装）
(defn public-do-stuff [instance]
  (do-stuff instance))

这种方式依赖命名空间的访问约定，外部代码无法直接扩展私有协议，只能使用你提供的已实现类型。

2. 运行时校验+自定义封装宏 #

通过自定义宏来封装协议定义和扩展逻辑，在运行时校验是否为允许的类型：

(defmacro defsealedprotocol [name allows & body]
  `(do
     ;; 定义公共协议
     (defprotocol ~name ~@body)
     ;; 封装扩展方法，仅允许指定类型
     (defmacro extend-sealed [type# & impls#]
       (if (contains? (set ~allows) type#)
         `(extend-type ~type# ~name ~@~impls#)
         (throw (ex-info (str "Cannot extend sealed protocol " '~name " with type " type#)
                         {:protocol '~name :type type# :allowed ~allows}))))))

;; 使用示例：定义仅允许AllowedTypeA、AllowedTypeB扩展的协议
(defsealedprotocol SealedProtocol [AllowedTypeA AllowedTypeB]
  (do-stuff [this]))

;; 合法扩展
(defrecord AllowedTypeA [data])
(extend-sealed AllowedTypeA
  (do-stuff [this] (str "A: " (:data this))))

;; 非法扩展会抛出异常
(defrecord ForbiddenType [x])
(extend-sealed ForbiddenType
  (do-stuff [this] "Oops")) ; 运行时报错

这种方式能在扩展时立即校验类型是否合法，接近静态语言的强制效果，但属于运行时检查而非编译期。

3. 结合Java的Sealed类 #

如果需要更严格的编译期强制，可以先在Java中定义sealed接口/类，再用Clojure类型实现：

// Java代码：SealedInterface.java
package myapp;

public sealed interface SealedInterface permits AllowedTypeA, AllowedTypeB {}

public final class AllowedTypeA implements SealedInterface {}
public final class AllowedTypeB implements SealedInterface {}

然后在Clojure中使用并扩展逻辑：

(ns myapp.clj-code
  (:import [myapp SealedInterface AllowedTypeA AllowedTypeB]))

(defprotocol SealedLogic
  (process [this]))

(extend-type AllowedTypeA
  SealedLogic
  (process [this] "Processing A"))

(extend-type AllowedTypeB
  SealedLogic
  (process [this] "Processing B"))

这种方式借助Java的编译期检查确保只有指定类型能实现sealed接口，Clojure则在此基础上扩展业务逻辑。

关于动态与静态语言的差异 #

你的假设是对的：静态语言依赖编译器的静态分析来强制sealed类型的约束，而动态语言（如Clojure）没有编译期类型检查的强制机制，只能通过**约定、运行时校验、结合静态工具（如clj-kondo自定义规则）**来近似实现类似效果。虽然无法完全达到静态语言的编译期安全性，但足够满足大多数受控多态的场景需求。

内容的提问来源于stack exchange，提问作者Shmuel Greenberger