为什么identical?会对直接引用和绑定到它的##NaN对待不同？

Question

考虑以下在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的==，而`##isnan`是Java的Double.NaN。在Java中，Double.NaN == Double.NaN的值是false。因此，我预计所有示例都将返回false。

Answer 1

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

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

当Clojure调用具有这种签名的函数时，它必须对参数中的原始值进行打包。使用`Double.valueOf(double)`对双精度值进行封箱。NaN的非平凡等价性使示例显得有些混乱，但不论哪种情况，identical?比较的是封箱值的引用等价性，而不是数值等价性。

通过查看反汇编的字节码（见下文），我们可以看到发生了什么。以下总结。

• 在示例1、2和4中，传递给identical?的每个参数都是单独封箱的。
• 在示例3中，`##isnan`只封箱一次，并且使用相同的封箱值作为`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? 的心理模型是错误的。它更像 (Object)... == (Object) ... 而不是普通的 ==。

经验教训：仅使用 identical? 来检查引用等价性。

反汇编示例

代码已使用 clj-java-deompiler 进行反汇编。

示例 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))

请注意在 invokeStatic 方法中的两个 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         

Comments

很有趣。关于 `identical?` 的心理模型是准确的（`identical?` 对于相同的对象返回 true），但我对 Clojure 的参数传递的心理模型是有缺陷的。看看你的例子，我认为下面是这样发生的。

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

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

;; 示例 3
user=> (identical? ##NaN ##NaN)
true
;; 我很高兴这确实是 true，但对此作为特殊情况进行了优化而感到惊讶。

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

基本上，我的直觉是，如果将 `x` 绑定到一个值，不管这个对象是否装箱或未装箱，都应该作为一个相同的对象传递给一个被调用的函数。从纯粹效率的角度来看，这与 `identical?` 无关，编译器不应当对同一个原始值进行多次装箱。所以，我认为，这看起来像是 Clojure 编译器没有生成直观或最佳代码的问题。

Answer 2

在示例 3 中，reader 将这两个常量绑定到同一个 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

Comments

你是如何得出这个结论的？

---

如果你指的是我消息中的前两句话，那么我获取了你的Clojure代码，编译并反编译，然后检查了结果。

---

你使用的是clj-java-decompiler的反编译功能（Java输出）吗？也可以尝试disassemble（字节码输出）；它不太符合你的解释。

---

我用的是集成在IntelliJ IDEA中的反编译器。但使用什么其实不重要。最后，你甚至可以用一些查看器检查字节码。为了增加确定性，你可以用`def`s把你的帖子中的每个表达式绑定到一个名字上。