Scala 是否可能使'='；或'=='；运算符是指除赋值或相等以外的内容吗？

我需要重载

=

或

==

以使其行为不同于赋值或相等。假设我有代码：

case class Col(name:String) 
def foo(col:Col, data:Any):SomeType = ??? // SomeType is another type 

val age = Col("age")
foo(age, 21)

我想为

foo（年龄，21岁）

提供语法糖，如下所示：

case class Col(name:String) {
   def ===(data:Any) = foo(this, data)
}

然后我可以做：

age === 21 // works (returns SomeType)

我想做的是：

age = 21 // does not work

甚至

age == 21 // will not work as expected (== must return Boolean)

---

可能吗？（首选

=

方法）

可能。查看canEqual、hashCode和equals方法。

可能。查看canEqual、hashCode和equals方法。

您可以这样做：

scala> class A { def ==(o: Int) = "Donno" }
defined class A

scala> new A {} == 1
res2: String = Donno

scala> new A {} == "1"
<console>:12: warning: comparing values of types A and String using `==' will always yield false
       new A {} == "1"
                ^
res3: Boolean = false

scala> new A {} == new A {}
<console>:12: warning: comparing values of types A and A using `==' will always yield false
       new A {} == new A {}
                ^
res4: Boolean = false

但不是这个：

scala> class A { def ==(o: Any) = "Donno" }
<console>:10: error: type mismatch;
 found   : String("Donno")
 required: Boolean
       class A { def ==(o: Any) = "Donno" }
                                  ^

scala>class A{def==（o:Any）=“Donno”}
：10：错误：类型不匹配；
找到：字符串（“Donno”）
必填项：布尔值
A类{def==（o:Any）=“Donno”}
^

如果重写函数，则无法更改其返回类型。但是，您可以通过更改其签名来重载它

p、 请不要这样做：）

你可以这样做：

scala> class A { def ==(o: Int) = "Donno" }
defined class A

scala> new A {} == 1
res2: String = Donno

scala> new A {} == "1"
<console>:12: warning: comparing values of types A and String using `==' will always yield false
       new A {} == "1"
                ^
res3: Boolean = false

scala> new A {} == new A {}
<console>:12: warning: comparing values of types A and A using `==' will always yield false
       new A {} == new A {}
                ^
res4: Boolean = false

但不是这个：

scala> class A { def ==(o: Any) = "Donno" }
<console>:10: error: type mismatch;
 found   : String("Donno")
 required: Boolean
       class A { def ==(o: Any) = "Donno" }
                                  ^

scala>class A{def==（o:Any）=“Donno”}
：10：错误：类型不匹配；
找到：字符串（“Donno”）
必填项：布尔值
A类{def==（o:Any）=“Donno”}
^

如果重写函数，则无法更改其返回类型。但是，您可以通过更改其签名来重载它

---

p、 请不要这样做：）

使用

=

，我们可以按照中所述（即，对

Int

、

String

等使用单独的方法，而不是

任何
。我们最接近于将
=
用作赋值以外的东西的方法是（基于）：

使用
=
，我们可以按照中所述进行操作（即，使用
Int
、
String
等的单独方法，而不是
任何
。最接近于将
=
用作赋值以外的其他方法的方法是（基于）：

但是，您不能更改返回类型…因此，
返回布尔值
位将不会被寻址。我希望
==
返回
某个类型
。因此，这并不能解决我的问题。@Jus12，在您的情况下，==返回布尔值以外的任何值不会太模糊吗？是的，这就是为什么我更喜欢
=
。我认为这是不可能的le重载
==
，不能这样做可能是有意义的。但是，您不能更改返回类型…因此
返回布尔值
位将不会被寻址。我希望
==
返回
某个类型
。因此这并不能解决我的问题。@Jus12，如果==返回除b以外的任何内容，是否会太模糊在你的情况下是oolean吗？是的，这就是为什么我更喜欢
=
。我认为它不可能过载
=
，而且不这样做可能是有意义的。这是一个完美的方式来迷惑任何阅读你的代码的人。你可以使用稍微修改过的符号，比如
：=
或
its用于内部DSL，所以类似
se的东西选择（a，b）。where（age=21）
应该是有意义的。我在Rogue:，
==
中看到过eqs，在Slick:，
===
中看到过，在LINQ中它有布尔结果。兄弟，你的DSL看起来让我很困惑。）我最终使用了
==
。更直观，Scala会在我忘记这一点时发出警告，并改用
=
。理想情况下，它甚至不应该编译。这是让任何阅读代码的人感到困惑的完美方法。你可以使用稍微修改过的符号，比如
：=
或
Its作为内部DSL，所以选择
之类的东西（a，b）.where（age=21）
应该有意义。我在Rogue:，
==
中看到过eq，在Slick:，
==
中看到过，在LINQ中看到了布尔结果。你的DSL看起来让我很困惑，兄弟；）我最终使用了
==
。更直观，Scala会在我忘记这一点时发出警告，并改用
=
。理想情况下，它甚至不应该编译。我会接受你的建议，使用
=！=
和
=
。只是想知道这是否可能。顺便说一句，更好的解决方法是使用类似的东西de>age.value=21
。我也喜欢你的想法，即给出单独的类型（
Int
，
String
，等等）。仍在权衡选项是否会让用户感到困惑：）我会接受你的建议并使用
==和
===
如在Slick中一样。只是想知道这是否可能。顺便说一句，更好的解决方法是使用类似于
age.value=21
的东西。我也喜欢您给出单个类型（
Int
，
String
等）的想法。仍在权衡选项是否会让用户感到困惑：）