List Scala-使用整数列表作为索引来填充新的数据结构

我有一个对象（在本例中是项）列表，这些对象具有类别ID和属性（其本身是自定义类型的列表）

我试图定义一个函数，该函数接受一个整数列表，例如与项目的类别ID相对应的

list（101、102、102、103、104）

，并从每个类别的属性列表中创建一个元组列表，其中包括类别类型（这是一个选项）和每个属性类型。到目前为止，我有以下内容，但我得到一个错误，

value\u 2不是可序列化的产品的成员

def idxToData(index: List[Int], items: Seq[Item]): List[(Option[Category], Property[_])] = {

  def getId(ic: Option[Category]): Int => {
   ic match {
     case Some(e) => e._id
     case None => 0
    }
  }

  index.flatMap(t => items.map(i => if(t == getId(i.category)){
    (i.category, i.properties.list.map(_.property).toList.sortWith(_._id < _._id))
  } else {
    None
  }.filter(_ != None )
  ))
   .map(x => x._2.map(d => (x._1, d)))
   .toList
}

def idxToData（索引：List[Int]，项：Seq[Item]）：List[（选项[Category]，属性[]）]={
def getId（ic:Option[Category]）：Int=>{
ic匹配{
案例部分（e）=>e.\u id
案例无=>0
}
}
flatMap（t=>items.map（i=>if（t==getId（i.category））{
（i.category，i.properties.list.map（u.property）.toList.sortWith（u.\u idx.。_2.map（d=>（x._1，d）））
托利斯先生
}

我不确定它是如何分配该类型的（我假设在这一点上，我应该有一个我试图映射的元组列表）

总的来说，在scala中，有没有更好的方法来实现所需的结果，即获取一个索引列表，并使用该列表访问列表中的特定项，其中每个对应项的两个部分组成的元组将“替换”索引以创建新的列表结构？
您应该拆分代码，给事物命名（添加一些VAL和DEF），当编译器不同意您的意见时，编写类型，以便编译器尽早告诉您不同意的地方（别担心，我们在开始使用FP时都这样做了）

此外，在发布此类问题时，您可能希望给出被引用但未定义的元素的接口（相关部分）。什么是“is”（is that items？）、项目、类别、属性……，或者简化代码，使其不会出现

现在，我们来谈谈这个问题：

if(t == (i.category match { case Some(e) => e._id})){
   (i.category, i.properties.list.map(_.property).toList.sortWith(_._id < _._id))
} else {
  None
}

这将是输入选项[type of stuff]，其中stuff的类型是您的配对

然而，有一些简单的例行收集。
它有点像match，只是它接受一个分部函数，并丢弃未定义分部函数的元素

那就是

is.collect { case i if categoryId(i) == Some(t) => 
   (i.catetory, i.properties....)
}

假设你已经定义了

def categoryId(item: Item): Option[Int] = item.category.map(._id)

您应该拆分代码，为事物命名（添加一些VAL和一些DEF），当编译器与您不一致时，编写类型，以便编译器尽早告诉您不一致的地方（不要担心，我们在开始使用FP时都这样做了）

此外，在发布此类问题时，您可能希望给出被引用但未定义的元素的接口（相关部分）。什么是“is”（is that items？）、项目、类别、属性……，或者简化代码，使其不会出现

现在，我们来谈谈这个问题：

if(t == (i.category match { case Some(e) => e._id})){
   (i.category, i.properties.list.map(_.property).toList.sortWith(_._id < _._id))
} else {
  None
}

这将是输入选项[type of stuff]，其中stuff的类型是您的配对

然而，有一些简单的例行收集。
它有点像match，只是它接受一个分部函数，并丢弃未定义分部函数的元素

那就是

is.collect { case i if categoryId(i) == Some(t) => 
   (i.catetory, i.properties....)
}

假设你已经定义了

def categoryId(item: Item): Option[Int] = item.category.map(._id)

执行此操作时：

is.map(i => if(t == getId(i.category)){
  (i.category, i.properties.list.map(_.property).toList.sortWith(_._id < _._id))
} else {
  None
}

is.map（i=>if（t==getId（i.category））{
（i.category，i.properties.list.map（u.property）.toList.sortWith（u.\u id

您会得到一个
列表[Product with Serializable]
（您可能会得到一个类型错误，但这可能是一个很长的离题），因为这是
None
和
的唯一超类型（类别，列表[Property[\u]]）
或任何元组类型。编译器不够聪明，无法执行union类型，并且无法确定当您
筛选（！=None）
时，列表中剩余的任何内容都必须是元组

尝试重新表述这一部分。例如，您可以先在
映射
之前执行
is.filter（i=>t==getId（i.category））
，然后您就不需要再处理列表中的
None
了。
执行此操作时：

is.map(i => if(t == getId(i.category)){
  (i.category, i.properties.list.map(_.property).toList.sortWith(_._id < _._id))
} else {
  None
}

is.map（i=>if（t==getId（i.category））{
（i.category，i.properties.list.map（u.property）.toList.sortWith（u.\u id

您会得到一个
列表[Product with Serializable]
（您可能会得到一个类型错误，但这可能是一个很长的离题），因为这是
None
和
的唯一超类型（类别，列表[Property[\u]]）
或任何元组类型。编译器不够聪明，无法执行union类型，并且无法确定当您
筛选（！=None）
时，列表中剩余的任何内容都必须是元组

尝试重新表述这一部分。例如，你可以先做
is.filter（i=>t==getId（i.category））
，在
map
之前，然后你就不需要再处理列表中的
None
。
这有点纠结了。你有没有可能把一些功能放到本地的def中（然后看看问题是否仍然存在）？如果编译，编译器可能会告诉您其他令人担忧的方面（例如，
case None
？）如何。如果您只想对从元素计算出的内容进行常规排序，您可以使用
sortBy
作为速记。（
sortBy（\uu.foo）
与
sortWith（uo.foo<\uo.foo）
相同@RexKerr是的，这有点纠结，我仍然对scala和fp有点纠结。我至少把match语句提取到了它自己的本地def中，并添加了一个无需发送回0的案例。它似乎仍然与可序列化的
产品保持一致-不知道为什么。这有点纠结。你有没有可能提取一些将功能转换为本地def（然后查看问题是否依然存在）？还有ot