在2024 Clojure调查问卷中分享您的想法！

欢迎！请查看关于页面了解有关此功能的更多信息。

提问

为什么identical?对let-bound的##NaN的处理与直接引用它的处理不同？

+2票
在 Java互联 由

考虑以下代码片段使用Clojure 1.11.1进行评估

;; example 1
user=> (identical? Double/NaN Double/NaN)
false

;; example 2
user=> (let [x Double/NaN] (identical? x x))
false

;; example 3
user=> (identical? ##NaN ##NaN)
true

;; example 4
user=> (let [x ##NaN] (identical? x x))
false

为什么例子3返回true，而其他所有例子都返回false？这是预期行为吗？

我认为这与Clojure有时使用的无箱数数学有关。

在我对Clojure的脑图中，identical?基本上等同于Java的==，而##NaN是Java的Double.NaN。在Java中，Double.NaN == Double.NaN评估为false。因此，我预计所有示例都应返回false。

2 答案

+3票
由
 
最佳答案

好吧，我对identical?的心理模型不准确。它调用clojure.lang.Util/identical，其实现如下

static public boolean identical(Object k1, Object k2){
    return k1 == k2;
}

当Clojure调用具有此类签名的函数时，它必须将参数中的原始值装箱。Double通过调用Double.valueOf(double)进行装箱。NaN的不寻常等式语义使示例令人困惑，但在每种情况下，identical?比较的是装箱值的引用等式，而不是数值等式。

通过查看反汇编的字节码（见下文），我们可以了解正在发生的事情。以下是总结。

  • 在例子1、2和4中，identical?的每个参数都分别装箱。
  • 在例3中，##NaN仅装箱一次，相同的装箱值用作identical?的两个参数。

这里有一些更多的例子。请注意，##Inf的行为与##NaN是相同的。

(identical? ##Inf ##Inf)          ; true
(let [x ##Inf] (identical? x x))  ; false

(identical? 1.0 1.0)              ; false
(let [x 1.0] (identical? x x))    ; false

(def my-one 1.0)
(identical? my-one my-one)        ; true

结论

一切运行正常。我对identical?的 mental model 是错误的。它更像是(Object)... == (Object) ...而不是简单的==。

得到的教训：仅在使用identical?时考虑引用等价性。

拆解示例

代码已经使用clj-java-decompiler进行了反编译。

示例 1 (identical? Double/NaN Double/NaN)

class user$fn_line_1__254
    Minor version: 0
    Major version: 52
    Flags: PUBLIC, FINAL, SUPER
    
    public void <init>();
        Flags: PUBLIC
        Code:
                  linenumber      1
               0: aload_0        
               1: invokespecial   clojure/lang/AFunction.<init>:()V
               4: return         
    
    public static java.lang.Object invokeStatic();
        Flags: PUBLIC, STATIC
        Code:
                  linenumber      1
               0: getstatic       java/lang/Double.NaN:D
               3: invokestatic    java/lang/Double.valueOf:(D)Ljava/lang/Double;
                  linenumber      1
               6: getstatic       java/lang/Double.NaN:D
               9: invokestatic    java/lang/Double.valueOf:(D)Ljava/lang/Double;
                  linenumber      1
              12: invokestatic    clojure/lang/Util.identical:(Ljava/lang/Object;Ljava/lang/Object;)Z
              15: ifeq            24
              18: getstatic       java/lang/Boolean.TRUE:Ljava/lang/Boolean;
              21: goto            27
              24: getstatic       java/lang/Boolean.FALSE:Ljava/lang/Boolean;
              27: areturn        
        StackMapTable: 00 02 18 42 07 00 1D
    
    public java.lang.Object invoke();
        Flags: PUBLIC
        Code:
                  linenumber      1
               0: invokestatic    user$fn_line_1__254.invokeStatic:()Ljava/lang/Object;
               3: areturn        
    
    static {};
        Flags: PUBLIC, STATIC
        Code:
                  linenumber      1
               0: return

示例 2 (let [x Double/NaN] (identical? x x))

跳过；与示例 4 类似。

示例 3 (identical? ##NaN ##NaN)

请注意，装箱是在静态块中发生的。

class user$fn_line_1__246
    Minor version: 0
    Major version: 52
    Flags: PUBLIC, FINAL, SUPER
    
    public static final java.lang.Object const__1;
        Flags: PUBLIC, STATIC, FINAL
    
    public void <init>();
        Flags: PUBLIC
        Code:
                  linenumber      1
               0: aload_0        
               1: invokespecial   clojure/lang/AFunction.<init>:()V
               4: return         
    
    public static java.lang.Object invokeStatic();
        Flags: PUBLIC, STATIC
        Code:
                  linenumber      1
               0: getstatic       user$fn_line_1__246.const__1:Ljava/lang/Object;
               3: getstatic       user$fn_line_1__246.const__1:Ljava/lang/Object;
                  linenumber      1
               6: invokestatic    clojure/lang/Util.identical:(Ljava/lang/Object;Ljava/lang/Object;)Z
               9: ifeq            18
              12: getstatic       java/lang/Boolean.TRUE:Ljava/lang/Boolean;
              15: goto            21
              18: getstatic       java/lang/Boolean.FALSE:Ljava/lang/Boolean;
              21: areturn        
        StackMapTable: 00 02 12 42 07 00 17
    
    public java.lang.Object invoke();
        Flags: PUBLIC
        Code:
                  linenumber      1
               0: invokestatic    user$fn_line_1__246.invokeStatic:()Ljava/lang/Object;
               3: areturn        
    
    static {};
        Flags: PUBLIC, STATIC
        Code:
                  linenumber      1
               0: ldc2_w          NaN
               3: invokestatic    java/lang/Double.valueOf:(D)Ljava/lang/Double;
               6: putstatic       user$fn_line_1__246.const__1:Ljava/lang/Object;
               9: return

示例 4 (let [x ##NaN] (identical? x x))

注意调用静态方法中的两次Double.valueOf调用。

class user$fn_line_1__250
    Minor version: 0
    Major version: 52
    Flags: PUBLIC, FINAL, SUPER
    
    public void <init>();
        Flags: PUBLIC
        Code:
                  linenumber      1
               0: aload_0        
               1: invokespecial   clojure/lang/AFunction.<init>:()V
               4: return         
    
    public static java.lang.Object invokeStatic();
        Flags: PUBLIC, STATIC
        Code:
                  linenumber      1
               0: ldc2_w          NaN
               3: dstore_0        /* x */
               4: dload_0         /* x */
               5: invokestatic    java/lang/Double.valueOf:(D)Ljava/lang/Double;
               8: dload_0         /* x */
               9: invokestatic    java/lang/Double.valueOf:(D)Ljava/lang/Double;
                  linenumber      1
              12: invokestatic    clojure/lang/Util.identical:(Ljava/lang/Object;Ljava/lang/Object;)Z
              15: ifeq            24
              18: getstatic       java/lang/Boolean.TRUE:Ljava/lang/Boolean;
              21: goto            27
              24: getstatic       java/lang/Boolean.FALSE:Ljava/lang/Boolean;
              27: areturn        
        StackMapTable: 00 02 FC 00 18 03 42 07 00 1B
    
    public java.lang.Object invoke();
        Flags: PUBLIC
        Code:
                  linenumber      1
               0: invokestatic    user$fn_line_1__250.invokeStatic:()Ljava/lang/Object;
               3: areturn        
    
    static {};
        Flags: PUBLIC, STATIC
        Code:
                  linenumber      1
               0: return
由
有趣。我对`identical?`的 mental model 是准确的（`identical?`对相同对象返回 true），但是我对于 Clojure 的参数传递的 mental model 有缺陷。根据你的示例，我认为下面是这样发生的。

```clojure
;; 示例 1
user=> (identical? Double/NaN Double/NaN)
false
;; false 可能是正确的。如果 Double/NaN 被标记为 final，那么应该是 true，但它显然不是，尽管 Double 类被标记为 final。

;; 示例 2
user=> (let [x Double/NaN] (identical? x x))
false
;; 我认为 Clojure 编译器应该只装箱一次，并将同一个 box 传递给 identical?，从而 true

;; 示例 3
user=> (identical? ##NaN ##NaN)
true
;; 我很高兴这是 true，但很惊讶它会作为一个特殊情况进行优化。

;; 示例 4
user=> (let [x ##NaN] (identical? x x))
false
;; 与示例 2 类似，Clojure 编译器应该足够聪明，只对此进行一次装箱，从而 true。
```

基本上，我的直觉是如果`x`被绑定到一个值，那么这个相同的对象，无论装箱还是非装箱，都应该传递给一个被调用的函数。作为一个纯粹的效率问题，与`identical?`无关，编译器不应该多次对相同的原始值进行装箱。所以，我认为这是一个问题，Clojure 编译器生成的代码既不直观也不优化。
0 票
由

在示例 3 中，读取器在这两个常量下绑定相同的Object常量，所以只有一个类型的Object实例。

在其他示例中，存在double类型的实例。

所有这些，只是Java的工作方式：https://stackoverflow.com/a/1408643/564509

这是一个演示Java行为的简单方式

jshell> Object a = Double.NaN
a ==> NaN

jshell> a == a
$2 ==> true

jshell> double a = Double.NaN
a ==> NaN

jshell> a == a
$4 ==> false
by
你是如何得出这个结论的？
by
如果你指的是我信息中的前两句，那么我得到了你的Clojure代码，编译了它，反编译了它，并检查了结果。
by
你是否使用了clj-java-decompiler的反编译功能（Java输出）？还可以尝试使用disassemble（字节码输出）；它实际上并不符合你的解释。
by
我使用了IntelliJ IDEA内置的反编译器。但使用哪种工具并不那么重要。最终，你甚至可以用一些查看器检查字节码。为了提高确定性，你可以用`def`s将你OP中的每个表达式绑定到一个名称。
由 Cognitect 维护，代表 Clojure 社区
...