在Scala中实现产品类型,并在其部件上使用通用更新功能

val and: String & Int & User & ... = ???

即并且应该有一个String部分和一个Int部分以及一个User部分.这类似于Scala的关键字：

val and: String with Int with User with ... = ???

具有这样的产品类型我需要一种方法,具有功能A => A,将其应用于某些产品价值,并通过更改A部件来恢复该产品.这意味着产品中的每种类型都必须是唯一的 – 这是可以接受的.

一个重要的限制是,当应用函数A =>时对于产品,我只知道产品内部有A,但没有关于其他类型的信息.但作为函数的调用者,我将其传递给具有完整类型信息的产品,并希望将此完整类型作为函数签名的一部分返回.

在伪代码中：

def update[A,Rest](product: A & Rest,f: A => A): A & Rest

使用Shapeless或其他深奥的东西对我来说没问题.我尝试使用HLists但是它们是有序的,而像异构集这样的东西在这里更适合代表A&休息部分.

更新：

以下代码解决了我从RégisJean-Gilles回答的用例,下面添加了阅读支持,一些评论和改进的类型安全：

object product {

  /** Product of `left` and `right` values. */
  case class &[L,R](left: L,right: R)

  implicit class AndPimp[L](val left: L) extends AnyVal {
    /** Make a product of `this` (as left) and `right`. */
    def &[R](right: R): L & R = new &(left,right)
  }

  /* Updater. */

  /** Product updater able to update value of type `A`. */
  trait ProductUpdater[P,A] {
    /** Update product value of type `A`.
      * @return updated product */
    def update(product: P,f: A ? A): P
  }

  trait LowPriorityProductUpdater {
    /** Non-product value updater. */
    implicit def valueUpdater[A]: ProductUpdater[A,A] = new ProductUpdater[A,A] {
      override def update(product: A,f: A ? A): A = f(product)
    }
  }

  object ProductUpdater extends LowPriorityProductUpdater {
    /** Left-biased product value updater. */
    implicit def leftProductUpdater[L,R,A](implicit leftUpdater: ProductUpdater[L,A]): ProductUpdater[L & R,A] =
      new ProductUpdater[L & R,A] {
        override def update(product: L & R,f: A ? A): L & R =
          leftUpdater.update(product.left,f) & product.right
      }

    /** Right-biased product value updater. */
    implicit def rightProductUpdater[L,A](implicit rightUpdater: ProductUpdater[R,f: A ? A): L & R =
          product.left & rightUpdater.update(product.right,f)
      }
  }

  /** Update product value of type `A` with function `f`.
    * Won't compile if product contains multiple `A` values.
    * @return updated product */
  def update[P,A](product: P)(f: A ? A)(implicit updater: ProductUpdater[P,A]): P =
    updater.update(product,f)

  /* Reader. */

  /** Product reader able to read value of type `A`. */
  trait ProductReader[P,A] {
    /** Read product value of type `A`. */
    def read(product: P): A
  }

  trait LowPriorityProductReader {
    /** Non-product value reader. */
    implicit def valueReader[A]: ProductReader[A,A] = new ProductReader[A,A] {
      override def read(product: A): A = product
    }
  }

  object ProductReader extends LowPriorityProductReader {
    /** Left-biased product value reader. */
    implicit def leftProductReader[L,A](implicit leftReader: ProductReader[L,A]): ProductReader[L & R,A] =
      new ProductReader[L & R,A] {
        override def read(product: L & R): A =
          leftReader.read(product.left)
      }

    /** Right-biased product value reader. */
    implicit def rightProductReader[L,A](implicit rightReader: ProductReader[R,A] {
        override def read(product: L & R): A =
          rightReader.read(product.right)
      }
  }

  /** Read product value of type `A`.
    * Won't compile if product contains multiple `A` values.
    * @return value of type `A` */
  def read[P,A](product: P)(implicit productReader: ProductReader[P,A]): A =
    productReader.read(product)

  // let's test it

  val p = 1 & 2.0 & "three"

  read[Int & Double & String,Int](p) // 1
  read[Int & Double & String,Double](p) // 2.0
  read[Int & Double & String,String](p) // three

  update[Int & Double & String,Int](p)(_ * 2) // 2 & 2.0 & three
  update[Int & Double & String,Double](p)(_ * 2) // 1 & 4.0 & three
  update[Int & Double & String,String](p)(_ * 2) // 1 & 2.0 & threethree

}