标签: shapeless

我试图调用Shapeless从内宏quasiquote用Scala,我没有得到什么,我想获得.

我的宏不会返回任何错误,但它不会扩展Witness(fieldName)到Witness.Lt[String]

val implicits = schema.fields.map { field =>
  val fieldName:String = field.name
  val fieldType = TypeName(field.valueType.fullName)
  val in = TermName("implicitField"+fieldName)
  val tn = TermName(fieldName)
  val cc = TermName("cc")
  q"""implicit val $in = Field.apply[$className,$fieldType](Witness($fieldName), ($cc:   $className) => $cc.$tn)"""
}

这是我的Field定义:

sealed abstract class Field[CC, FieldName] {
  val  fieldName: String
  type fieldType

  // How to extract this field
  def  get(cc : CC) : fieldType
}

object Field {
  // fieldType …

在无形状中,Nat类型表示在类型级别编码自然数的方法.这用于例如固定大小的列表.您甚至可以在类型级别上进行计算,例如,将N元素列表附加到元素列表中,K并返回在编译时已知的具有N+K元素的列表.

这种表示是否能够表示大数,例如1000000或2 ⁵³,或者这会导致Scala编译器放弃吗？

我真的很想知道差异在哪里,更一般地说,找出不能使用HLists的规范用例(或者说,不会比常规列表产生任何好处).

(我知道TupleNScala 中有22个(我相信),而一个只需要一个HList,但这不是我感兴趣的那种概念差异.)

我在下面的文字中标出了几个问题.它实际上可能没有必要回答它们,它们更倾向于指出我不清楚的事情,并指导某些方向的讨论.

动机

我最近在SO上看到了几个人们建议使用HLists的答案(例如,由Shapeless提供),包括对这个问题的删除答案.它引发了这一讨论,从而引发了这个问题.

介绍

在我看来,只有当您静态地知道元素的数量及其精确类型时,才会使用hlists.这个数字实际上并不重要,但你似乎不太可能需要生成一个包含不同但静态精确已知类型的元素的列表,但是你不能静态地知道它们的数量.问题1:你甚至可以写一个这样的例子,例如,在循环中吗？我的直觉是,拥有静态精确的hlist与静态未知数量的任意元素(相对于给定的类层次结构的任意)只是不兼容.

HLists与Tuples

如果这是真的,即你静态地知道数字和类型 - 问题2:为什么不使用n元组？当然,你可以类型安全地映射和折叠一个HList(你也可以,但不是类型安全地,借助于一个元组productIterator),但由于元素的数量和类型是静态已知的,你可能只是访问元组元素直接执行操作.

另一方面,如果f您在hlist上映射的函数是如此通用以至于它接受所有元素 - 问题3:为什么不通过它使用它productIterator.map？好的,一个有趣的区别可能来自方法重载:如果我们有几个重载f的,拥有hlist提供的更强的类型信息(与productIterator相反)可以允许编译器选择更具体的f.但是,我不确定这在Scala中是否真的有用,因为方法和功能不一样.

HLists和用户输入

基于相同的假设,即您需要静态地知道元素的数量和类型 - 问题4:可以在元素依赖于任何类型的用户交互的情况下使用hlists吗？例如,想象用循环内的元素填充hlist; 从某个地方(UI,配置文件,演员交互,网络)读取元素,直到某个条件成立.什么类型的hlist是什么？类似于接口规范getElements:HList [...]应该使用静态未知长度的列表,并允许系统中的组件A从组件B获得这样的任意元素列表.

有路径依赖的类型,我认为这是可能的,表达了这样的语言作为警句或阿格达Scala中的几乎所有功能,但我不知道为什么斯卡拉不支持此更明确地像它非常漂亮,在其他领域(比如,DSLs)？我缺少的任何东西都像"没有必要"？

有人能用简单的语言向我解释一下Shapeless库的用途吗？

Scala具有泛型和继承功能,所以我对Shapeless的用途有点困惑.

也许一个用例来澄清事情会有所帮助.

假设我有一个类型类,证明Shapeless副产品中的所有类型都是单例类型:

import shapeless._

trait AllSingletons[A, C <: Coproduct] {
  def values: List[A]
}

object AllSingletons {
  implicit def cnilSingletons[A]: AllSingletons[A, CNil] =
    new AllSingletons[A, CNil] {
      def values = Nil
    }

  implicit def coproductSingletons[A, H <: A, T <: Coproduct](implicit
    tsc: AllSingletons[A, T],
    witness: Witness.Aux[H]
  ): AllSingletons[A, H :+: T] =
    new AllSingletons[A, H :+: T] {
      def values = witness.value :: tsc.values
    }
}

我们可以证明它适用于简单的ADT:

sealed trait Foo
case object Bar extends Foo
case object Baz extends Foo

然后: …

问题

当我使用支持类型级编程的库时,我经常会发现自己编写如下的注释(来自Paul Snively在Strange Loop 2012中提供的示例):

// But these invalid sequences don't compile:
// isValid(_3 :: _1 :: _5 :: _8 :: _8 :: _2 :: _8 :: _6 :: _5 :: HNil)
// isValid(_3 :: _4 :: _5 :: _8 :: _8 :: _2 :: _8 :: _6 :: HNil)

或者这,从一个例子中的无形资源库:

/**
 * If we wanted to confirm that the list uniquely contains `Foo` or any
 * subtype of `Foo`, we could …

'map'保留了元素的数量,因此在元组上使用它似乎是明智的.

到目前为止我的尝试:

scala> (3,4).map(_*2)    
error: value map is not a member of (Int, Int)
       (3,4).map(_*2)
             ^
scala> (3,4).productIterator.map(_*2)
error: value * is not a member of Any
       (3,4).productIterator.map(_*2)
                                  ^
scala> (3,4).productIterator.map(_.asInstanceOf[Int]*2)
res4: Iterator[Int] = non-empty iterator

scala> (3,4).productIterator.map(_.asInstanceOf[Int]*2).toList
res5: List[Int] = List(6, 8)

它看起来很痛苦......我甚至还没有开始尝试将它转换回元组.
我做错了吗？图书馆可以改进吗？

考虑到https://speakerdeck.com/folone/theres-a-prolog-in-your-scala,我想"滥用"Scala类型系统来查找CanBuildFrom符合给定条件的所有实例.Prolog风格,我会评估以下伪代码的行:

can_build_from(Src, int, list[int])
Src = somecollectiontype1[int]
Src = somecollectiontype2[int]
... etc

即运行时将查找Src满足该语句的所有值can_build_from(Src, int, list[int]).

现在,我知道,原始的约束/逻辑编程环境,斯卡拉隐含查询系统,并不意味着使用这种技巧,并且不能用于"重返"不止一个发现价值Src出来的箱,所以我的问题是:是否有一个"魔术",使其工作,所以无论如何我会得到所有可能的值X的CanBuildFrom[X, Int, List[Int]]？

附加示例:

trait CanFoo[T, U]

implicit val canFooIntString  = new CanFoo[Int,     String] {}
implicit val canFooDblString  = new CanFoo[Double,  String] {}
implicit val canFooBoolString = new CanFoo[Boolean, String] {}
implicit val canFooIntSym     = new CanFoo[Int,     Symbol] {}
implicit val canFooDblSym     = new CanFoo[Double,  Symbol] {}
implicit val canFooBoolSym    = …

我很确定我在这里遗漏了一些东西,因为我对Shapeless很新,而且我正在学习,但是Aux技术何时需要呢？我看到它用于通过将type语句提升到另一个"伴侣" type定义的签名来公开语句.

trait F[A] { type R; def value: R }
object F { type Aux[A,RR] = F[A] { type R = RR } }

但是这不等于将R放入F的类型签名中吗？

trait F[A,R] { def value: R }
implicit def fint = new F[Int,Long] { val value = 1L }
implicit def ffloat = new F[Float,Double] { val value = 2.0D }
def f[T,R](t:T)(implicit f: F[T,R]): R = f.value
f(100)    // res4: Long = 1L
f(100.0f) // res5: Double = …