Scala список переставить (возвратное степенное несоответствие типов)

Question

У меня есть следующий код:

 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 

Каких должна быть довольно прямым кодом permutate 2 комплекта списков в единый комплекс, который имеет все возможные permamutations обоего списков в порядок без элемента, появляющегося перед элементом in, не был перед самим списком (поэтому, если у нас есть список a = 1,2,3 и список b = a, b, c, тогда он должен вернуть Set { 1, a, 2, b, 3, c-1,2, a, 3, b, ca, 1,2,3, b, c ext.}). Однако мой код генерирует несколько типов ошибок mistmaches вокруг линии

{Set{sofar:+l2}} 

и

x<-s1 

ли кто-нибудь знает, как это исправить?

Answer 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) 
}