Scala 置换列表（递归类型不匹配）答案

【问题标题】：Scala permute list (recursive type mismatch)Scala 置换列表（递归类型不匹配）
【发布时间】：2013-06-08 14:25:33
【问题描述】：

我有以下代码：

      type foo= List[bar]
      def emtfoo= List[bar]()

   def permute(s1:Set[foo],s2:Set[foo]):Set[foo]={
     for{ 
        x<-s1
        y<-s2 
     }yield permutatefoo(x,y,e,emtfoo)

def permutatefoo(l1:foo,l2:foo,sofar:foo):Set[foo]={
    if (l1.equals (emtfoo)) {
       Set{sofar:+l2}
      }
    else {
    combine(permutatefoo(l1.drop(1),l2,l1.take(1):::sofar),
        permutatefoo(l1,l2.drop(1),l2.take(1):::sofar))
        }
    }
def combine(s1:Set[foo],s2:Set[foo]):Set[foo] = 
   for {
      x <- s1
      y<- s2
  } yield x ::: y

这应该是相当简单的代码，可以将 2 组列表排列成一个集合，该集合具有两个列表的所有可能排列顺序，没有元素出现在列表本身前面的元素前面（所以如果我们有 list a = 1,2,3 和 list b =a,b,c 那么它应该返回 Set{1,a,2,b,3,c-1,2,a,3,b, ca,1,2,3,b,c 分机}）。但是，我的代码在行周围产生了一些错误类型不匹配。

{Set{sofar:+l2}}

和

   x<-s1

有人知道如何解决这个问题吗？

【问题讨论】：

为了记录，这个词是“permute”，而不是“permutate”。

标签： list scala set type-mismatch

【解决方案1】：

我不确定我是否理解了你所有的代码，但我看到的一些东西是：

1：

{Set{sofar:+l2}} // should probably be Set(sofar ++ l2)
                 // as it seems you just want to concatenate sofar and l2 
                 // which are both List[bar] (so your return value is a Set[foo]
                 // i.e. a Set[List[bar]] as the signature for 
                 // permutatefoo requests

:+ 是一个提取器 (see the doc)，不应该以这种方式使用它

2：

if (l1.equals (emtfoo)) // you should also check against ls.equals(emtfoo)
                        // as you're also dropping elements from l2
                        // in permutatefoo(l1,l2.drop(1),l2.take(1):::sofar))

3：

permute 的返回类型错误。按照您定义它的方式，它返回 Set[Set[foo]] 而不是 Set[foo]。我不确定我是否理解你想要它做什么，但如果你修复了返回类型，它至少应该进行类型检查。

这是可编译的代码版本。我并不是说它有效（正如我所说，我不确定我是否理解您的程序的所有预期输入和输出应该是什么），但它可以编译。

type bar=Int

type foo= List[bar]
def emtfoo= List[bar]()

def combine(s1:Set[foo],s2:Set[foo]) = 
   for{
      x <- s1
      y <- s2
  } yield x ++ y

def permutatefoo(l1:foo, l2:foo, sofar:foo): Set[foo]={
    if (l1.equals (emtfoo) || l2.equals (emtfoo)) {
       Set(sofar ++ l2)
      }
    else
    {
    combine(permutatefoo(l1.drop(1),l2,l1.take(1) ++ sofar),
        permutatefoo(l1,l2.drop(1),l2.take(1) ++ sofar))
    }
}

def permute(s1:Set[foo],s2:Set[foo]) : Set[Set[foo]] = {
     for { 
        x <- s1
        y <- s2 
     } yield permutatefoo(x,y,emtfoo)
}

【讨论】：