即使.head不起作用.
我需要做些什么改变来完成这项工作？
import shapeless._
import HList._
import Nat._
scala> case class Foo[A](a: A)
defined class Foo
scala> case class Bar[A](f: Foo[A])
defined class Bar
scala> val xs = Foo(23) :: Foo("blah") :: HNil
xs: shapeless.::[Foo[Int],shapeless.::[Foo[java.lang.String],shapeless.HNil]] = Foo(23) :: Foo(blah) :: HNil
scala> object mapper extends (Foo ~> Bar) {
| def apply[A](f: Foo[A]) = Bar(f)
| }
defined module mapper
scala> xs map mapper
res13: mapper.Out = Bar(Foo(23)) :: Bar(Foo(blah)) :: HNil
scala> res13.apply[_1]
<console>:38: error: could not …以下代码似乎足以编译和运行
case class Pair(a: String, b: Int)
val pairGen = Generic[Pair]
object size extends Poly1 {
implicit def caseInt = at[Int](x => 1)
implicit def caseString = at[String](_.length)
}
def funrun(p: Pair) = {
val hp: HList = pairGen.to(p)
hp.map(size)
}
但是编译器说"找不到参数映射器的隐含值".在我的用例中,我想映射一个HList来获取String的HList,然后将String的HList转换为Scala List [String].有任何想法吗？
我是Shapeless的新手.我有利用了无形的"自动类型类派生"的辅助类(https://gist.github.com/negator/fbbcd1b2ce9a85b762b7)帮我填充JSON读取和写入.
import play.api.libs._
import json._
import shapeless.{ `::` => :#:, _ }
import poly._
object SReads extends LabelledTypeClassCompanion[Reads] {
object typeClass extends LabelledTypeClass[Reads] {
def emptyProduct: Reads[HNil] = Reads(_ => JsSuccess(HNil))
def product[F, T <: HList](name: String, FHead: Reads[F], FTail: Reads[T]) = Reads[F :#: T] {
case obj @ JsObject(fields) =>
for {
head <- FHead.reads(obj \ name)
tail <- FTail.reads(obj - name)
} yield head :: tail
case _ => JsError("Json object required")
}
def project[F, G](instance: …在将源 AST1 转换为目标 AST2（在 Scala 中构建 DSL 编译器）时，我试图实现某种多态缓存。因为我希望缓存为翻译结果保留精确的类型，所以我使用了无形的 HMap。它按预期工作，但是在某些时候我需要迭代缓存内容以将其转储到必须记录翻译过程的文件中，然后将用于构建从 A2 到 A1 的回译。通过查看 HMap 的源代码，我看到有一个我无法访问的底层 HashMap[Any, Any]，因为它不是 HMap 中的 val，而且我看到 HMap 实际上是一个多态函数值，这意味着我可以将它应用到 HList 上，它的类型对应于 HMap 键类型的子集，但我真正想做的是能够折叠一个多态函数，该函数在此 HMap 上接受多态（键，值）参数，以另一种形式检索其内容（例如，在标准 HashMap 元组中切片）。有没有办法做到这一点？最好的事物。
我正在尝试使用 shapeless 从两个 HList 中选择“非空”值：
import shapeless.{ HNil, Poly2}
object choose extends Poly2 {
implicit def caseInt =
at[Int,Int]{
case (_,n) if n > 0 => n
case (o,_) => o
}
implicit def caseString =
at[String,String] {
case (_,n) if n.nonEmpty => n
case(o,_) => o
}
}
val g = "a" :: "" :: 0 :: HNil
val h = "" :: "a" :: 5 :: HNil
g.zip(h).map(choose)
我在缺少隐式映射器时遇到错误如果我理解正确，我需要提供证明 zip 的结果是可映射的，但我不知道该怎么做
我正在对字符串进行一系列预处理步骤，并且正在考虑使用HLists 来提高步骤的安全性。某些处理步骤必须在其他处理步骤之后运行，所以我正在考虑在类型系统中对其进行编码。我的第一次尝试是：
trait Step
trait Raw extends Step
trait A extends Step
trait B extends Step
trait DependsOnA extends Step
trait DependsOnB extends Step
case class ToBeProcessed[S <: Step](value: String)
object ToBeProcessed {
def raw(input: String): ToBeProcessed[Raw] = ...
def doA(input: ToBeProcessed[Raw]): ToBeProcessed[A] = ...
def doB(input: ToBeProcessed[A]): ToBeProcessed[B] = ...
def doDependsOnA(input: ToBeProcessed[B]): ToBeProcessed[DependsOnA] = ...
def doDependsOnB(input: ToBeProcessed[DependsOnA]): ToBeProcessed[DependsOnB] = ...
}
这是有效的，因为它迫使我按顺序调用所有内容doA> doB> doDependsOnA> doDependsOnB，这是它工作的可能顺序，但是：
doC我必须改变与它无关的事物的类型所以我开始阅读 …
我try-with-resources在Scala中有这个版本。我想知道是否可以使用Shapeless和HList制作通用版本？
import scala.util.{Failure, Success, Try}
class Loan1[A <: AutoCloseable](resource: A) {
def to[B](block: A => B): B = {
Try(block(resource)) match {
case Success(result) =>
resource.close()
result
case Failure(e) =>
resource.close()
throw e
}
}
}
class Loan2[A <: AutoCloseable, B <: AutoCloseable](r1: A, r2: B){
def to[R](block: (A,B) => R): R = {
Try(block(r1,r2)) match {
case Success(result) =>
r1.close(); r2.close()
result
case Failure(e) =>
r1.close(); r2.close()
throw e
}
}
}
object Loan {
def apply[A …我有一个案例类包括大约20个字段,所有字段都是原始类型.
case class A( f1: String, f2: Int .....)
我不得不从命令行解析这些字段(不幸的是).我可以,但我真的不想写这20次
opt[String]("f1") required() valueName "<f1>" action { (x, c) =>
c.copy(f1 = x)
} text "f1 is required"
//...repeat 20 times
我可以通过反射获得字段名称和字段类型,但我不知道如何在for循环中将这些信息粘贴到此调用中
我可以将它与无形连接起来,但我仍然不熟悉它,这可以在没有形状的情况下完成吗？
==
scala选项解析器=> scopt
我正在尝试收集在编译时使用特定注释的案例类的字段shapeless.我试图玩下面的片段,但它没有按预期工作(输出什么,而不是打印"我").我怎样才能使它工作？
import shapeless._
import shapeless.labelled._
final class searchable() extends scala.annotation.StaticAnnotation
final case class Foo(@searchable i: Int, s: String)
trait Boo[A] {
def print(a: A): Unit
}
sealed trait Boo0 {
implicit def hnil = new Boo[HNil] { def print(hnil: HNil): Unit = () }
implicit def hlist[K <: Symbol, V, RL <: HList](implicit b: Boo[RL]): Boo[FieldType[K, V] :: RL] =
new Boo[FieldType[K, V] :: RL] {
def print(a: FieldType[K, V] :: RL): Unit = {
b.print(a.tail)
}
} …我试图以无形的方式理解单例类型，并面临对单例类型编译时类型的误解。下面是一个例子：
val x: Witness.`120`.T = 120.narrow
它工作正常，但这种结构看起来很不寻常。什么是Witness.120？在 IDE 中，它指向一些宏函数selectDynamic：
def selectDynamic(tpeSelector: String): Any = macro SingletonTypeMacros.witnessTypeImpl
具有编译时类型Any和由施工判断Witness.120.T一个type部件T。这看起来很神奇......当一个人写下这样的东西时，任何人都可以解释一下实际发生的事情：
val x: Witness.`120`.T = //...