如何确保（在编译时）该集合没有重新排序？

Question

假设我有索引集合（List 或 Map 在这里无关紧要）：

val zipped = List(1 -> "A", 3 -> "C", 8 -> "D")

这样很难处理（因为每个操作，比如map，都必须处理index），所以我想传递给业务处理程序的是：

case class Indexed[T](seq: Seq[T], i: Seq[Int])

val unzipped = Indexed(List("A", "C", "D"), List(1,3,8))

handler(unzipped.seq)

但我需要限制用户，只做map、filter、collect、contains、forall、scanLeft 等等。但不是flatMap（filter-like 除外）、sort、++ 等等。所以任何双射/超射，但不是类似注射的。在紧要关头，用户可以在没有filter/flatMap 的情况下生活，因此拥有Functor，但不是Monad 对我来说可能没问题-无论如何我最初的要求可接受的List[Option[T]] => List[T] 并不完整Monad（ M[M[T]] => M[T], T => M[T])。

toList、toSet 是可以接受的，但我也想确保返回（从业务处理程序）集合是基于原始集合。我可以通过将路径相关的Tag（路径相关的类型）添加到原始集合的类型签名中来做到这一点，并要求将相同标记的集合作为返回类型（只能用asInstanceOf 作弊）。我的第一个要求可以通过实现我自己的Traversable 来满足。

所以我自己解决这个问题的“轮子”只是一个包装器（只允许操作的子集+用于确保集合相同的标签）：

 trait NonReorderedListT {
     trait Tag
 }

 trait NonReorderedList[Tg <: NonReorderedListT#Tag, T] {
   type Tag = Tg 
   def map[U](f: T => U): NonReorderedList[Tag, U] //same tag
   //... other permitted operations should be here        
 }


 object NonReorderedList {

   class NonReorderedListImpl[Tg <: NonReorderedListT#Tag, T] private[NonReorderedList] (l: List[T]) extends NonReorderedList[Tg, T] { 
      def map[U](f: T => U) = new NonReorderedListImpl[Tag, U](l.map(f))
      //... other permitted operations should be here  
   }     


   def apply[T](l: List[T]) = {
     val tagC = new NonReorderedListT {} //container
     new NonReorderedListImpl[tagC.Tag, T](l)
   }
 }

这是 Scala REPL 的结果：

defined trait NonReorderedListT
defined trait NonReorderedList
defined class NonReorderedListImpl
defined object NonReorderedList

scala>  val l = NonReorderedList(List(1,2,3))
warning: there was one feature warning; re-run with -feature for details
l: NonReorderedListImpl[tagC.Tag,Int] forSome { val tagC: NonReorderedListT } = NonReorderedListImpl@3620eab

scala> val res: NonReorderedList[l.Tag, Int] = l.map(_ + 1)
res: NonReorderedList[l.Tag,Int] = NonReorderedListImpl@34bddf43

scala>  val m = NonReorderedList(List(1,2,3))
warning: there was one feature warning; re-run with -feature for details
m: NonReorderedListImpl[tagC.Tag,Int] forSome { val tagC: NonReorderedListT } = NonReorderedListImpl@2d8c729f

scala> val res: NonReorderedList[l.Tag, Int] = m.map(_ + 1)
<console>:31: error: type mismatch;
 found   : NonReorderedListImpl[m.Tag,Int]
    (which expands to)  NonReorderedListImpl[tagC.Tag,Int]
 required: NonReorderedList[l.Tag,Int]
    (which expands to)  NonReorderedList[tagC.Tag,Int]
       val res: NonReorderedList[l.Tag, Int] = m.map(_ + 1)
                                                    ^

然而，当你需要这样的集合时，它不应该是那么罕见的情况，所以也许 Scalaz 已经有一些实现，比如NonEmptylist，但是NonReorderedList。

我这样做是因为我已经订购了一个集合 (1 -> "A", 2 - "B", 3 -> "C", 4 -> "D", 5 -> "E" ) 作为输入，分为 (1 -> "A", 3 -> "C", 4 -> "D") 和 (2 -> "B", 5 -> "E")，它们是单独处理，然后合并回来（应保留原始顺序）。使用复杂谓词排序需要一些时间（因为它调用外部服务），所以我不能用它重新排序两次集合 - 第二次重新排序应该基于简单索引。

附：我不是在寻找类型安全性较低的替代方案，因为我的项目中已经有这样的替代方案:)。我的目标是改进现有（在我的项目中）代码。

Answer 1

也许这可以通过使用 shapeless 的 Nat 和 HList 来解决？这个想法是显式地对元素的索引进行建模。 （我问了一个相关的问题Achieving compile safe indexing with Shapeless。）例如，

import shapeless._
import Nat._

case class Entry[+N<:Nat](value: String, index: N)

val send: Entry[ _1] :: Entry[ _3] :: Entry[ _4] :: HNil= Entry("A", _1):: Entry("C", _3) :: Entry("D", _4) :: HNil
val keep= Entry("B", _2) :: Entry("E", _5)  :: HNil

这将提供一些类型安全性（尽管我不确定性能影响。）