Question

如标题中所述，我不明白为什么这些函数无法编译并要求Seq。

def f1[V <: Seq[Int]](v: V): V = v.map(_ + 1)
def f2[V <: Seq[Int]](v: V): V = v.zip(v).map{ case (a, b) => a + b }

error: type mismatch;
found   : Seq[Int]
required: V

我有以下解决方法：

def f1[V <: Seq[Int]](v: V): V = v.map(_ + 1).asInstanceOf[V]
def f2[V <: Seq[Int]](v: V): V = v.zip(v).map{ case (a, b) => a + b }.asInstanceOf[V]

但是我想知道它是否存在另一种解决方案。如果不是的话，铸造类似东西的成本是O（1）还是S（n）等于Seq大小的O（n）。

Answer 1

因为

[TestClass]
public class ATest : ATestBase
{
    [TestInitialize]
    public override void TestInitialize()
    {
        if (Playback.IsInitialized == false)
            Playback.Initialize();
    }

    [TestCleanup]
    public override void TestCleanup()
    {
        if (Playback.IsInitialized == true)
            Playback.Cleanup();

        base.TestCleanup();
    }

    [TestMethod, TestCategory("SmokeTest")]
    [DeploymentItem(@"DataSource\Documents\some.pdf")]
    public void SmokeFlow()
    {
        string name = "test";
    }
}

很容易失败：仅保证v.map(_ + 1).asInstanceOf[V]返回一个map，而在运行代码时，它可能恰好是Seq[Int]的一个实例。

一个示例是V，其中V = SeqView.Filtered返回map。

如果不是这样的话，转换的代价是O（1）或Seq大小为n的O（n）。

使用SeqView.Mapped进行转换的成本始终为O（1）。在某些情况下，它实际上是无人值守，费用为0。

Answer 2

让我们看一下函数的编译方式：

def f1[V <: Seq[Int]](v: V): V = v.map(_ + 1)

1 /您已将V声明为Seq[Int]的子类型。因此V可以被编译器视为Seq[Int]。

2 /内部函数，v.map(_ + 1)的返回类型为Seq[Int]，因为它使用的是Seq方法。

3 / V是声明的返回类型。这与实际的返回类型Seq[Int]不匹配。而且您的编译器无法将Seq[Int]视为V，因为没有类型绑定说明[V >: Seq[Int]]。

为什么当V <：Seq [Int]时，如果V是Seq后代映射，而zip操作返回Seq [Int]

2 个答案: