blocks|key|957648|text|如果希望将next重命名为任何其他单元格*类型实例，则可以使用存在类型|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|957649|trait+CellT[VAL+<:+AnyVal]+{
++var+value:+VAL
++var+next:+CellT[_+<:+AnyVal]
}

abstract+class+Cell[VAL+<:+AnyVal]+extends+CellT[VAL]+{
++var+next:+CellT[_+<:+AnyVal]+=+this+//+defaults+to+`this`
++override+def+toString+=+"Cell(%25s,%25s)".format(value,+if(next+==+this)+"this"+else+next.toString)
}

//+impl+example:
class+CellInt+extends+Cell[Int]+{
++var+value:+Int+=+0
}

class+CellBoolean+extends+Cell[Boolean]+{
++++var+value+=+false
}

var+c1+=+new+CellInt
var+c2+=+new+CellBoolean

println(c1)
c1.value+=+1
println(c1)
c1.next+=+c2
println(c1)

println(c2)
c2.value+=+true
println(c1)
println(c2)|code-block|syntax|javascript|957650|输出：|957651|单元格(0，这个)|957652|单元格(1，这个)|957653|单元格(1，Cell(false，this))|957654|单元格(假，此)|957655|单元格(1，单元格(对，此))|957656|单元格(对，这个)|957657|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cakesolutions.net/teamblogs/2012/09/03/existential-types/^0|5|4|V|4|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|F|3|G|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1D|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1E|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1F|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1G|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1H|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|1I|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|1J|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|Z|$10|$5|11|12|13|E|$14|15]]]]

If you want <code>next</code> to be reassignable to any other Cell[*] types instances, you can use <a href="http://www.cakesolutions.net/teamblogs/2012/09/03/existential-types/" rel="nofollow">existential types</a>:

<pre><code>trait CellT[VAL &lt;: AnyVal] {
 var value: VAL
 var next: CellT[_ &lt;: AnyVal]
}

abstract class Cell[VAL &lt;: AnyVal] extends CellT[VAL] {
 var next: CellT[_ &lt;: AnyVal] = this // defaults to `this`
 override def toString = "Cell(%s,%s)".format(value, if(next == this) "this" else next.toString)
}

// impl example:
class CellInt extends Cell[Int] {
 var value: Int = 0
}

class CellBoolean extends Cell[Boolean] {
 var value = false
}

var c1 = new CellInt
var c2 = new CellBoolean

println(c1)
c1.value = 1
println(c1)
c1.next = c2
println(c1)

println(c2)
c2.value = true
println(c1)
println(c2)
</code></pre>

Output:

Cell(0,this) 
Cell(1,this) 
Cell(1,Cell(false,this)) 
Cell(false,this) 
Cell(1,Cell(true,this)) 
Cell(true,this)

blocks|key|957659|text|这里很明显，它的类型为VAL+<：AnyVal，与NEXT+<：AnyVal相同|type|blockquote|depth|inlineStyleRanges|entityRanges|data|957660|不，他们不是一样的，他们只是有着同样的约束。NEXT尚未指定。假设您随后像下面这样的子类Cell：|unstyled|957661|class+StringNextCell+extends+Cell+{
++++type+NEXT+=+String
}|code-block|syntax|javascript|957662|现在，StringNextCell.next应该是Cell[String]类型的，但是您从单元格中的声明将它声明为Cell[Int]|offset|length|style|CODE|957663|entityMap^0|0|0|0|3|J|P|C|1L|9|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|T|8|@]|9|@]|A|$H|I]]|$1|J|3|K|5|D|7|U|8|@$L|V|M|W|N|O]|$L|X|M|Y|N|O]|$L|Z|M|10|N|O]]|9|@]|A|$]]|$1|P|3|-4|5|D|7|11|8|@]|9|@]|A|$]]]|Q|$]]

<blockquote>
 Here it is obvious that this will have the type VAL &lt;: AnyVal which is the same as NEXT &lt;: AnyVal
</blockquote>

No, they are not the same, they just share the same constraint. NEXT is not yet specified. Imagine that you subsequently subclass Cell like this:

<pre><code>class StringNextCell extends Cell {
 type NEXT = String
}
</code></pre>

Now, <code>StringNextCell.next</code> is supposed to be of type <code>Cell[String]</code> but your declaration from Cell declares it as <code>Cell[Int]</code>

blocks|key|1927515|text|这与其说是一个答案，不如说是一个警告。一个月前，我编写了非常类似的代码，我花了很多迭代才了解到，当使用Scala类型时，更粗的代码更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1927516|请记住，Scala类型参数检查仅限于编译时，因此它通常比您想象的要粗。花15分钟让您的代码编译非常烦人，结果却发现您的XFoo+<：Bar被视为X_。|1927517|我建议你从以下几个方面着手：|1927518|abstract+class+Cell[VAL]+{
++++var+value:+VAL
++++var+next:+Cell[_]
}|code-block|syntax|javascript|1927519|只有在你有迫切需要的时候才能说得更具体些。很可能，如果您需要知道next的类型，那么无论如何都需要进行显式的运行时检查。|1927520|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This isn't exactly an answer so much as a warning. I wrote remarkably similar code a month ago, and it took me many iterations to learn that when it comes to Scala typing, coarser is better.

Keep in mind that Scala type parameter checking is compile-time only, so it is frequently coarser than you think. It's really annoying to spend 15 minutes getting your code to compile, only to discover that your X[Foo &lt;: Bar] is getting treated as X[_].

I would recommend that you start with:

<pre><code>abstract class Cell[VAL] {
 var value: VAL
 var next: Cell[_]
}
</code></pre>

and only get more specific if you have a pressing need. Chances are, if you need to know the type of next, you're going to need to do an explicit runtime check anyway.

I have the following code:

<pre><code>trait CellT[VAL &lt;: AnyVal] {
 var value: VAL
 type NEXT &lt;: AnyVal
 var next: CellT[NEXT]
}

abstract class Cell[VAL &lt;: AnyVal] extends CellT[VAL] {
 var next = this // defaults to `this`. ERROR
}

// impl example:
class CellInt extends Cell[Int] {
 var value: Int = 0
}
</code></pre>

The error says that

<blockquote>
 overriding variable next in trait CellT of type
 Cell[Cell.this.NEXT]; variable next has
 incompatible type
</blockquote>

Here it is obvious that <code>this</code> will have the type <code>VAL &lt;: AnyVal</code> which is the same as <code>NEXT &lt;: AnyVal</code>, however, I still get the error. How can I tell Scala that <code>next</code> should be able to return anything of type <code>Cell[A &lt;: AnyVal]</code>, but this type should not be necessary the same as the class type parameter <code>[VAL &lt;: AnyVal]</code>??? Otherwise I could just use <code>[VAL]</code> but it will be too restrictive, for example for <code>Cell[Int]</code> it will restrict the <code>next</code> method to return only <code>Cell[Int]</code> type instances. But I want the <code>next</code> to be reassignable to any other <code>Cell[*]</code> types instances.

Scala - same but different type

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有以下代码：trait CellT[VAL <: AnyVal] { var value: VAL type NEXT <: AnyVal var next: CellT[NEXT]}abstract class Cell[VAL <: AnyVal] extends CellT[VAL] { var nex...

问Scala -相同但不同的类型
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala -相同但不同的类型EN