Clojure 何时为唯一元素计算集合？

在哪一点上对集合进行唯一元素的求值。对于每个：

(def set1 #{1, 2, 3, 3})
(def set2 #{1, 2, 3, (+ 1 2)})

(defn foo 
[a b]
#{1, 2, a, b})

(foo 3 (+ 1 2))

它是编译时和运行时的组合还是其他什么？

我猜语法

#{…}

在读取时被转换成

（哈希集…

），所有内容在运行时都会得到评估，就像任何正常的函数调用一样。在您的例子中，当您调用

foo

时，它首先计算

3

，然后

（+1 2）

，然后调用

（foo 3 3）

，这反过来调用

（hash set 1 2 3）

，导致调用

（clojure.lang.PersistentHashSet/create keys）

，将

键逐个添加到集。所以答案是：在运行时消除重复项

更新

正确答案是“两者皆有”

至于op的例子，它显然是在运行时执行的，这在repl中很容易看到：

user> (defn f [a b]
        (println "f" a b)
        #{1 2 a b})
#'user/f

user> (f 1 2)
f 1 2
IllegalArgumentException Duplicate key: 1  clojure.lang.PersistentHashSet.createWithCheck (PersistentHashSet.java:56)

所以：
f
编译正常，
（f2）
编译正常，执行时抛出异常

正如@Hoagy Carmichael的回答中提到的，将相同的内容放入文件并使用clojure编译会抛出错误，但这不是因为编译器检查重复项，而是由于内部编译器在编译后运行顶级表单的行为。所以它不是真正的编译时，而是运行时错误。此外，由于这是一种内在行为，我想没有人能保证将来会是这样

另一方面，当我粗略地简化了读者的行为时，我错了：它确实检查了传递给#{}表单的所有表单的“文字”唯一性。所有这些函数定义都无法编译：

user> (defn f1 [a b]
        #{1 1 a})
IllegalArgumentException Duplicate key: 1 

user> (defn f1 [a b]
        #{1 a a})
IllegalArgumentException Duplicate key: a  

user> (defn f1 [a b]
        #{1 (inc a) (inc a)})
IllegalArgumentException Duplicate key: (inc a)  

user> (defn f1 [a b]
        #{1 @a @a}) ;; notice that at run-time `@a` could easily produce different vals. But the reader sees equal forms.
IllegalArgumentException Duplicate key: (clojure.core/deref a)  

user> (defn f1 [a b]
        #{1 (+ a b) (+ a b)})
IllegalArgumentException Duplicate key: (+ a b)  

tl；dr：对于OP代码中的每种情况：编译时

tl；dr++：虽然编译时检查哈希集文本（
{…}
）总是发生，因为副作用的事情可能发生，某些情况（不是全部）在运行时另外检查

尝试1
首先，将
op
的名称空间声明添加到op的代码中，并将其放入名为
op.clj

其次，将
clojure.jar
与文件一起放入目录

第三，创建一个名为
compile

#!/bin/bash

java -cp ".:clojure.jar" clojure.main - <<CLJ

(set! *compile-path* ".")
(compile 'op)

CLJ

第五，接收堆栈跟踪

Exception in thread "main" java.lang.IllegalArgumentException: Duplicate key: 3, compiling:(op.clj:3:24)
    at clojure.lang.Compiler.compile(Compiler.java:7663)
    at clojure.lang.RT.compile(RT.java:408)
    at clojure.lang.RT.load(RT.java:453)
    at clojure.lang.RT.load(RT.java:421)
    at clojure.core$load$fn__7645.invoke(core.clj:6008)
    at clojure.core$load.invokeStatic(core.clj:6007)
    at clojure.core$load.doInvoke(core.clj:5991)
    at clojure.lang.RestFn.invoke(RestFn.java:408)
    at clojure.core$load_one.invokeStatic(core.clj:5812)
    at clojure.core$compile$fn__7650.invoke(core.clj:6018)
    at clojure.core$compile.invokeStatic(core.clj:6018)
    at clojure.core$compile.invoke(core.clj:6010)
    at user$eval13.invokeStatic(Unknown Source)
    at user$eval13.invoke(Unknown Source)
    at clojure.lang.Compiler.eval(Compiler.java:6951)
    at clojure.lang.Compiler.load(Compiler.java:7403)
    at clojure.lang.Compiler.load(Compiler.java:7350)
    at clojure.core$load_reader.invokeStatic(core.clj:4039)
    at clojure.main$script_opt.invokeStatic(main.clj:336)
    at clojure.main$script_opt.invoke(main.clj:331)
    at clojure.main$main.invokeStatic(main.clj:422)
    at clojure.main$main.doInvoke(main.clj:385)
    at clojure.lang.RestFn.applyTo(RestFn.java:137)
    at clojure.lang.Var.applyTo(Var.java:700)
    at clojure.main.main(main.java:37)
Caused by: java.lang.IllegalArgumentException: Duplicate key: 3
    at clojure.lang.PersistentHashSet.createWithCheck(PersistentHashSet.java:68)
    at clojure.lang.LispReader$SetReader.invoke(LispReader.java:1271)
    at clojure.lang.LispReader$DispatchReader.invoke(LispReader.java:793)
    at clojure.lang.LispReader.read(LispReader.java:265)
    at clojure.lang.LispReader.readDelimitedList(LispReader.java:1302)
    at clojure.lang.LispReader$ListReader.invoke(LispReader.java:1151)
    at clojure.lang.LispReader.read(LispReader.java:265)
    at clojure.lang.LispReader.read(LispReader.java:198)
    at clojure.lang.Compiler.compile(Compiler.java:7561)
    ... 24 more

第六，回顾第一行（重点是我的）：线程“main”java.lang.IllegalArgumentException中的异常：重复键：3，编译：（op.clj:3:24）

第七，知道这是在编译时发生的，感到放心

尝试2
将您的
op.clj
文件更改为如下所示

;; op.clj
(ns op)

(defn foo 
[a b]
#{1, 2, a, b})

(foo 3 (+ 1 2))

再次尝试运行
compile
，您将获得另一个堆栈跟踪，该跟踪也以以下内容开始（强调我的）：线程“main”java.lang.IllegalArgumentException中的异常：重复键：3，编译：（op.clj:3:24）

编译时再次罢工

越来越疯狂
创建一个名为
three
的文件，其中仅包含一个数字3：

3

修改
op.clj
如下所示：

;; op.clj
(ns op
  (:require [clojure.string :as s]))

(defn foo 
[a b]
#{1, 2, a, b})

(foo 3 (-> "three" slurp s/trim Integer/parseInt))

在尝试运行
编译时，我们再次遇到了亲爱的编译时的朋友（我的重点）：线程“main”java.lang.IllegalArgumentException中的异常：重复键：3，编译：（op.clj:9:5）

现在修改
three
以包含单个四个

4

运行
compile
并注意到没有堆栈跟踪！我们已经杀了野兽

现在再次编辑
three
，只包含一个数字3

3

删除
op.clj
，这样我们可以确定在下一位中只使用编译的类文件

rm op.clj

启动repl并要求
op

java -cp ".:clojure.jar" clojure.main
Clojure 1.9.0-alpha11
user=> (require 'op)
IllegalArgumentException Duplicate key: 3  clojure.lang.PersistentHashSet.createWithCheck (PersistentHashSet.java:56)

终于！运行时出现错误！需要一点努力才能平静下来
 谢谢，关于映射和键也可以这样说吗？这并不完全正确，因为
{11}
会引发异常，但
（哈希集11）
不会。的确，集合是在运行时构造的，只是使用不同的静态构造函数，一个允许重复，一个不允许。我想
{}
语法实际上主要用于常量文本。这个答案中的两点都是错误的<代码>哈希集
允许重复。如果散列集文本（
{…}
）变成对
散列集的调用，则不会捕获重复项。然后这个问题的答案也错了。哈希集文本中的重复项在编译时被检查。真的吗？如何在编译时知道a和b的值？我同意我用代码生成简化了部分，但事实是：检查重复项的代码是在编译时生成的，但它是实际执行时的运行时。读取器将
{…}
转换为一个集合。不是第一个元素为
哈希集的列表。请参见中的
SetReader（）
。读者确实要求在读取时对副本抛出异常。然后由eval决定如何将读取时间集转换为运行时间集。您知道吗，clojure编译实际上是对顶级表单进行计算的？所以你的实验完全是肮脏的。因此，您得到的错误实际上是运行时错误，这与容易出错的顶级表单和内部编译器行为的一致性有关，这意味着：如果您从顶级删除
foo
调用（如将它们封装到函数），那么所有内容都将被编译。在repl中可以很容易地看到它，例如
（defn f[ab]（println“running function f”）#{1 2 ab}）
（编译好）
user>（f1）
=>运行函数f IllegalArgumentException复制键：1 clojure.lang.persistenthasset.createWithCheck（persistenthasset.java:56）（同样编译正常，但在运行时抛出了一个错误）@leetwinksi（第一条评论）：是的，我知道。如果你有一个Jav
rm op.clj

java -cp ".:clojure.jar" clojure.main
Clojure 1.9.0-alpha11
user=> (require 'op)
IllegalArgumentException Duplicate key: 3  clojure.lang.PersistentHashSet.createWithCheck (PersistentHashSet.java:56)