Scala枚举到具有shapeless的HList
Scala枚举是指在Scala编程语言中，通过定义一组有限的命名值来表示一种特定类型的数据。枚举类型可以用于限定变量的取值范围，提高代码的可读性和可维护性。
具有shapeless的HList是指在Scala编程语言中，使用shapeless库实现的HList（Heterogeneous List）数据结构。HList是一种可以存储不同类型元素的列表，它可以在编译时进行类型检查，并支持类型安全的操作。
优势：
- 枚举类型可以提高代码的可读性，使得代码更加清晰和易于理解。
- HList数据结构可以存储不同类型的元素，提供了更大的灵活性和扩展性。
- HList支持类型安全的操作，可以在编译时捕获类型错误，减少运行时错误的可能性。
应用场景：
- 枚举类型适用于需要限定变量取值范围的场景，例如表示一周的天数、表示性别等。
- HList数据结构适用于需要存储不同类型元素的场景，例如构建泛型数据结构、实现类型安全的函数参数传递等。
推荐的腾讯云相关产品： 腾讯云提供了多种云计算相关产品，以下是一些推荐的产品和对应的介绍链接地址：
- 云服务器（CVM）：提供弹性计算能力，支持按需创建、管理和扩展云服务器实例。详细介绍请参考：云服务器产品介绍
- 云数据库MySQL版（CDB）：提供高性能、可扩展的关系型数据库服务，支持自动备份、容灾等功能。详细介绍请参考：云数据库MySQL版产品介绍
- 人工智能机器学习平台（AI Lab）：提供强大的人工智能算法和模型训练平台，支持图像识别、语音识别等应用场景。详细介绍请参考：人工智能机器学习平台产品介绍
请注意，以上推荐的产品仅为示例，腾讯云还提供了更多丰富的云计算产品和服务，可根据具体需求选择适合的产品。
相关·内容
我在斯卡拉做一件事。我有以下案例课：
import shapeless._
case class Foo(param1: String, param2: HList)
我希望获得这种类型的JSON表示，使用 。我还希望将得到的JSON字符串映射回.类型。
模块circe-shapes实现了HLists的自动派生，并且很容易从HList到JSON并返回。参见此示例：
scala> import shapeless._
import shapeless._
scala> import io.circe._, io.circe.generic.auto._, io.circe.pars
浏览 4提问于2016-11-28得票数 3
回答已采纳
2回答
多亏了，我才知道如何压缩无形状的HLists：
从无形状的2.0.0-M1中导入一些东西：
import shapeless._
import shapeless.ops.hlist._
import syntax.std.tuple._
import Zipper._
创建两个HLists：
scala> val h1 = 5 :: "a" :: HNil
h1: shapeless.::[Int,shapeless.::[String,shapeless.HNil]] = 5 :: a :: HNil
scala> val h2 = 6 :: "b&#
浏览 3提问于2013-12-07得票数 4
回答已采纳
1回答
问题:用ID字段描述一个记录(这使它成为一个实体)-- ID字段需要自动生成，以便记录(也称为A) + ID = Entity (也称为B)
trait Record extends Product
trait Entity {
type Id
}
case class Book(title: String, author: String, publication: Int)
case class PersistentBook(id: Long, title: String, author: String, publication: Int) extends Entity {
type
浏览 4提问于2020-01-14得票数 2
回答已采纳
1回答
描述
我正在尝试构建一个能够将Map[String, Any]转换为class/case class实例的工具。如果类定义包含未在Map中指定的默认参数，则将应用默认值。
以下代码片段允许检索主类构造函数：
import scala.reflect.runtime.universe._
def constructorOf[A: TypeTag]: MethodMirror = {
val constructor = typeOf[A]
.decl(termNames.CONSTRUCTOR)
// Getting all the constructors
.alt
浏览 1提问于2020-03-29得票数 2
回答已采纳
我想为函数中未指定数量的参数创建一些函数
例如
scala> def test(fx: (String*) => Boolean, arg: String*): Boolean = fx(arg: _*)
test: (fx: String* => Boolean, arg: String*)Boolean
scala> def AA(arg1: String, arg2: String) :Boolean = {
println ("Arg1 : " + arg1 + " Arg2 : " + arg2)
浏览 0提问于2016-05-04得票数 1
2回答
我试图通过文字类型来过滤一个HList，但是它不能工作，它只是过滤所有的字符串：
import shapeless._
import shapeless.ops.hlist._
def filterLabel[Labels <: HList, Label, Out <: HList](labels: Labels, label: Label)(
implicit sel: Filter.Aux[Labels, label.type, Out]): Out = sel(labels)
val a: "a" = "a"
val b: "b
浏览 10提问于2018-10-22得票数 1
考虑到以下检索两个HList的递归和的尝试，如下所示：
(请暂时原谅Product的名字。)
package net
import shapeless._
import shapeless.nat._
import shapeless.ops.nat.{Sum, Prod, Mod}
trait SumZippedProduct[L, M] {
type S
}
object SumZippedProduct {
type Aux[L, M, O] = SumZippedProduct[L, M] {
type S = O
}
def apply[L <:
浏览 2提问于2017-02-08得票数 2
回答已采纳
2回答
有没有办法从Scala中现有的类型派生出一个类型？ 例如，对于case class Person(name: String, age: Int)，我希望获得(Option[String], Option[Int])的Product/Tuple，即从现有类型映射而来的类型。 Typescript (mapped types)中有一个功能可以相对容易地实现这一点，这就是我开始沿着这条道路思考的原因。但我不确定这样的事情是如何在Scala中完成的。 我觉得解决方案包括以某种方式使用shapeless，但我不确定如何实现。
浏览 25提问于2019-04-16得票数 6
回答已采纳
1回答
通过下面的代码，我尝试在一个HList中获得Parameter的所有值
import shapeless._
case class Parameter[T](value: T)
trait ParameterOperations[Params <: HList, ParamValues <: HList] {
def values(params: Params): ParamValues
}
object ParameterOperations {
implicit val hNil = new ParameterOperations[HNil, HNil] {
浏览 0提问于2018-10-01得票数 0
1回答
假设您有以下案例类
case class Test1(a:String,b:Int,c:Char)
case class Test2(a:String,b:Int)
并使用以下变量实例化这些类
val test1 = Test1("first",2,'3')
val test2 = Test2("1st",20)
是否有一种方法可以使用.copy方法(或其他方法)，将Test2中的变量应用于Test1，例如
val test3 = test1.copy(test2) //Note this isn't valid scala code
浏览 0提问于2014-04-21得票数 11
回答已采纳
1回答
我正在尝试将Xor的HList映射到ValidatedNel的HList，但得到一个错误：
scala> type Result[A] = Xor[String, A]
defined type alias Result
scala> type Validation[A] = ValidatedNel[String, A]
defined type alias Validation
scala> val r0 = Xor.right(0)
r0: cats.data.Xor[Nothing,Int] = Right(0)
scala> val r1 = X
浏览 26提问于2016-09-07得票数 0
回答已采纳
假设我有以下元组：
scala> val t1 = Tuple2("abcd", "efg")
t1: (java.lang.String, java.lang.String) = (abcd,efg)
scala> val t2 = Tuple2(1234, "lmnop")
t2: (Int, java.lang.String) = (1234,lmnop)
scala> val t3 = Tuple3("qrs", "tuv", "wxyz")
t3: (java.lan
浏览 0提问于2012-01-27得票数 17
回答已采纳
考虑下面这段代码：
import shapeless.HList
sealed trait Issue[L <: HList] {
def content: L
def withT[T](t: T): Issue[T :: L]
}
private case class IssueImpl[L <: HList](content: L) extends Issue[L] {
def withT[T](t: T)(implicit ev: SomeEvidenceRegardingT[T]): Issue[T :: L] =
IssueImpl(t :: co
浏览 6提问于2016-07-23得票数 1
我有自动生成的scala代码使用灵活的编码。我看到一些表行被实现为HLists。(但这些都是光滑的HList，而不是普通的无型HList)
现在，我需要一个来自HList的特定元素，它以行的形式返回给灵活的查询。
我在谷歌上找到了这条线
但这并不适用于光滑的HList。它适用于无形状的HList。
我也尝试了应用的方法。
val : Long = slickHList(2)
但这不能编译，因为类型Any不符合exected类型的Long。我不想做.asInstanceOf
是否有一种类型错误的方法可以访问光滑的HList元素？
编辑:基于下面的输入，我编写了下面的代码
package com
浏览 1提问于2017-09-15得票数 3
回答已采纳
我正在编写一个通用的表查看器，应该能够显示任何类型的Seq[Row] where Row <: HList。Table类如下所示：
class Table[TH<:HList, TR<:HList](val hdrs: TH, val rows: Seq[TR])
当有人单击表查看器的某一列时，我希望按该列的顺序重新绘制整个表。为此，我需要能够分配一个函数来对特定列上的表进行排序。使用隐形眼镜似乎是一个合理的选择。
def sort[Elem<:Nat](lens: Lens[R, Elem]) = {
...
table.rows.sortBy(lens.
浏览 1提问于2014-08-10得票数 3
1回答
我对无形体还很陌生(而且在scala的学习曲线上还很低)。我很难与无体型的人在一起
import shapeless._
case class FooBar[T](foo: String, bar: T)
val hl = 0 :: FooBar("A", "one") :: FooBar("B", 1) :: "0" :: FooBar("C", "two") :: HNil
val l = hl.filter[FooBar[String]].toList
println(l) //List(Fo
浏览 0提问于2018-11-14得票数 0
回答已采纳
1回答
函数内HList上的映射
、、、
下面的代码看起来很明显，可以编译和运行
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)
}
但是编译器说“找不到参数映射器的隐
浏览 2提问于2015-09-08得票数 7
回答已采纳
我正在尝试学习shapeless (2.0.0)。这似乎是一个令人惊叹的工具，我对此感到非常兴奋，但我在前进中遇到了问题。因为还没有太多的文档，所以我一直在研究示例和源代码。我遇到了困难，因为大多数示例使用了多个无形状的概念，并且在源代码中，一个无形状的类型通常会利用其他类型，所以可以说，我最终陷入了无形状的兔子洞。我认为列出shapeless的重要特性以及每个特性的简单描述会很有帮助。因为我显然没有资格列出这样的列表，所以我在问你，Stack Overflow的人类！
对于每个功能，请尽可能多地包含以下内容：
功能的名称和导入方法。对功能的简短描述。此功能为什么重要/为什么有人会费心使用它？
浏览 33提问于2014-01-01得票数 17
1回答
假设有一个常规的Scala枚举对象，如下所示 object WeekDay extends Enumeration {
type WeekDay = Value
val Mon, Tue, Wed, Thu, Fri, Sat, Sun = Value
} 有没有可能在不显式指定完整HList的类型签名的情况下将其转换为无形状的HList？我遇到了ProductArgs，这几乎就是我需要的，但它仍然需要将每个枚举值作为单独的参数提供给它。同时，编译器知道枚举集合的类型和大小，所以这必须是可能的。
浏览 27提问于2019-08-22得票数 1
回答已采纳
我正在尝试分割一个元组，删除最后两个项目。我尝试使用列表drop/take方法，但是我不能成功地得到一个元组。
下面是我尝试过的方法：
scala> val myTuple = (1, 2, 4, 5, 0, 5)
myTuple: (Int, Int, Int, Int, Int, Int) = (1,2,4,5,0,5)
scala> val myList = myTuple.productIterator.toList
myList: List[Any] = List(1, 2, 4, 5, 0, 5)
scala> val mySubList = myList.d
浏览 0提问于2012-06-19得票数 23
回答已采纳
2回答
在Scala中可以实现以下功能：
scala> val l = List
l: scala.collection.immutable.List.type = scala.collection.immutable.List$@7960c21a
scala> l ( 1, 2, 3 )
res0: List[Int] = List(1, 2, 3)
换句话说，Scala具有更高阶的多态性。我想使用高阶多态性来做以下事情。
sealed abstract class A { def eval () : A }
case class A0 () extends A { ... }
cas
浏览 1提问于2011-11-25得票数 7
回答已采纳
1回答
我对Scala很陌生，并且使用circe来建模和序列化一些API响应。我发现自己使用了下面的样板
sealed trait SomeTrait
object SomeTrait {
implicit val someEncoder: Encoder[SomeTrait] = deriveEncoder[SomeTrait]
implicit val someDecoder: Decoder[SomeTrait] = deriveDecoder[SomeTrait]
<code>
}
相反，我想使用泛型，并定义如下
trait SerializableTr
浏览 55提问于2022-11-08得票数 2
我正在研究scala语言和成熟的代数类型系统的兼容性，这里有一个有趣的案例： 假设我有一个复杂的CC类型，它是AA和BB的乘积： case class AA(_1: Int, _2: Int)
case class BB(_3: Int)
case class CC(a: AA, b: BB) 现在我想定义一个类型代数flatten(.)，它可以扁平化其操作数定义中的所有内部乘积类型，例如，flatten(CC)可以产生以下乘积类型定义： case class FCC(_1: Int, _2: Int, _3: Int) 在scala 2.12+中实现这样的东西有多难？欢迎你使用任何可能的技
浏览 14提问于2019-08-25得票数 1
我有下一段代码，用于类型类实例的创建：
def productsLogShow[HK <: HList, T, H <: HList, K](hideFieldsWithKeys: HK)(
implicit lg: LabelledGeneric.Aux[T, H], lsh: LogShow[H], keys: Keys.Aux[H, K]
): LogShow[T] = {
LogShow.create { value =>
val record = lg.to(value)
// ...
//filter somehow record
浏览 2提问于2018-11-05得票数 1
回答已采纳
2回答
在Scala中，给定一个泛型类型T，如何检索字段名和字段类型的列表？例如，如果我有case类： case class Person(name: String, age: Int, gender: Boolean) 和泛型函数： def getFieldNamesAndTypes[T](): Seq[(String, String)] 我希望能够检索字段(名称、类型)的序列(按字段出现的顺序)： val fieldNamesAndTypes = getFieldNamesAndTypes[Person]()
浏览 36提问于2020-08-07得票数 2
回答已采纳
1回答
我正在尝试定义一个类型类，以便HList L包含一个特定的类型A。
trait Contains[A] {
type Out
}
object Contains {
type Aux[A, O] = Contains[A] { type Out = O }
def contains[L <: HList, A]
(implicit ev: Contains.Aux[L, A]) = ev
implicit def containsInt[H, L <: HList, A]
(implicit ev: H == A): Contain
浏览 9提问于2017-02-05得票数 3
回答已采纳
1回答
我的副积编码不明确。
、、、、
这个问题最近提了几次，所以我在这里问它。假设我有一些这样的案例类：
import io.circe._, io.circe.generic.semiauto._
object model {
case class A(a: String)
case class B(a: String, i: Int)
case class C(i: Int, b: Boolean)
implicit val encodeA: Encoder[A] = deriveEncoder
implicit val encodeB: Encoder[B] = deriveEncoder
imp
浏览 7提问于2017-06-01得票数 14
回答已采纳
1回答
是否有一种方法可以使泛型方法的类型数目不详？我目前正在试验Scala系统，但没有找到任何解决方案。
参数的经典varargs如下所示：
def printAll(strings: String*) {
strings.foreach(println)
}
但我的问题是，如果有这样的事情：
def magic[TYPES*](...) {
for(t <- TYPES){
typeOf[t] ...
}
}
编辑:这个想法是为了实现一种在方括号中创建列表的方法，如下所示：
def magicList[A: TypeTag, B: TypeTag, C
浏览 0提问于2019-08-13得票数 0
回答已采纳
2回答
我有一个接受HList并使用它构建类实例的方法。我想提供一些简化的语法，隐藏显式的缺点。我想从以下几个方面着手：
MyThingy.describe( 42 :: true :: "string" :: HNil)
至
MyThingy.describe {
42
true
"string"
}
其中MyThingy的定义如下
class MyThingy[L <: HList](elems: L)
我试过用这个宏
def describe[L <: HList](elements: Unit): MyThingy[L] = macro
浏览 2提问于2014-08-24得票数 7
回答已采纳
有人能简单地给我解释一下无形库是用来做什么的吗？
Scala有泛型和继承功能，所以我有点搞不懂Shapeless是用来干什么的。
也许澄清一些事情的用例会有所帮助。
浏览 3提问于2014-02-13得票数 72
我想定义一个接受另一个函数g的函数f。我们要求g接受n Double (对于某些固定的n)并返回Double。函数调用f(g)应返回n的特定值。
例如，f(Math.max) = 2因为Math.sin的类型是(Double, Double) => Double，而f(Math.sin) = 1因为Math.sin的类型是Double => Double。
如何使用Scala泛型定义f？
我已经尝试了几种形式，但都没有成功。例如：
def f[A <: Product](g: Product => Double) = {...}
这不起作用，因为我们不能在编译时提取n的
浏览 0提问于2013-06-19得票数 7
回答已采纳
我自己正在学习Scala，并遇到了这个问题。根据的优秀答案，假设我有以下代码：
object Example extends App {
val x = Seq(1, 2, 3)
val y = Seq("1", "2", "3")
class Or[A, B]
implicit def orA[A, B](implicit ev: A): Or[A, B] = new Or
implicit def orB[A, B](implicit ev: B): Or[A, B] = new Or
def f1[T](seq:
浏览 2提问于2020-06-13得票数 1
回答已采纳
1回答
我一直在试图映射scala的HList包中的shapeless类型，而不访问它们的值。
下面的代码成功地映射了HList的值
import shapeless._
import shapeless.Poly._
import ops.hlist.Mapper
import ops.hlist.Mapper._
trait Person {
type Value
val v : Value
}
case class StringPerson extends Person {
type Value = String
val v = "I like strings"
浏览 5提问于2016-10-02得票数 7
回答已采纳
1回答
获取案例类的具体类型
、、、
我有这个：
sealed trait Block
sealed case class Header(param1: String,
param2: String,
...) extends Block
...
(more sealed case classes that follows the same pattern)
稍后，我将这些块分组到一个Seq中，如下所示：
val blocks: Seq[Block with Product
浏览 3提问于2015-08-11得票数 3
回答已采纳
我想要构建一个简单的库，开发人员可以在其中定义一个Scala类来表示命令行参数(为了保持它的简单性，只需要一组所需的参数--没有标志或可选参数)。我希望库解析命令行参数并返回类的一个实例。库的用户只需这样做：
case class FooArgs(fluxType: String, capacitorCount: Int)
def main(args: Array[String]) {
val argsObject: FooArgs = ArgParser.parse(args).as[FooArgs]
// do real stuff
}
如果提供的参数与预期类型不匹配，解析器应
浏览 0提问于2018-05-07得票数 1
回答已采纳
我有一个包含250个字段的案例类：
case class Data(field1:String, field2:Int, .. )
是否有一种方法可以使用scala检查为其参数生成值
我看过的不相关的问题：
浏览 2提问于2016-07-29得票数 3
回答已采纳
我有一个用例，其中一个头可以包含7个字节加上一个可选的0-15字节的信息，其中的大小信息位于第5字节的较低的4位，所以格式是：
4 bytes | 4 bits | 4 bits <- length of extra bytes | 2 bytes | 0-15 extra Bytes
我在下面的案例类中对此进行了建模
case class FHDR(DevAddr:Long, ADR:Boolean, ADRACKReq:Boolean, ACK:Boolean, FPending:Boolean, FCnt:Int, FOpts:ByteVector)
implicit val F
浏览 2提问于2016-01-05得票数 3
回答已采纳
下面的代码是一个不成形的用例的典型演示：
def getHList[P <: Product, F, L <: HList](p: P)(implicit gen: Generic.Aux[P, L]): L = {
gen.to(p)
}
val v = getHList(1, 2, 3, 4, 5, 6, 7, 8, 9)
这给出了正确的结果，不幸的是，它依赖于scala的元组语法支持，并且在参数数>22时不起作用：
val v = getHList(1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5,
浏览 8提问于2020-05-31得票数 1
回答已采纳
1回答
HList上的类型级别映射
、、、、
我手把手地使用我的数据库API，基本上希望将列族建模为列的HList，后者大致上是一个Seq[_]，所以我在某个地方有一个像Column[String]::Column[Int]::Column[Double]::HNil这样的类型，所有元素都共享一个公共类型构造函数。 从上面给出的类型中表示行类型的最简单方法是什么，即String::Int::Double::HNil，本质上是展开内部类型？我现在的推理是，由于shapeless可以在给定正确的poly的情况下在该HList上进行映射，所以应该能够(Ab)使用Mapper特征的Depedt型Out。 我能想到的一件事就是在正确的情况下实现一
浏览 33提问于2019-02-09得票数 4
回答已采纳
2回答
我正在实验下一节课
import shapeless._
import syntax.std.tuple._
class TestedClass[HL](nodes: HL) {
def addElement[T, OUT](clause: HL => T) = {
new TestedClass[OUT](nodes :+ clause(nodes))
}
}
很明显，这个片段没有编译。我不知道如何将新的元组nodes :+ clause(nodes)类型绑定到OUT。我希望取得以下成果：
scala> val step1 = new Test
浏览 4提问于2014-09-11得票数 6
回答已采纳
假设我有一些case类，我想将它们合并到一个更大的类中。我可以像这样使用重载构造函数来做到这一点： case class A(a: Int)
case class B(b: Double)
case class C(a: Int, b: Double) {
def this(a: A, b: B) = this(a.a, b.b)
}
val a = A(1)
val b = B(1.0)
val c: C = C(a, b) 这样做的问题是，它需要写出this(a.a, b.b)行中的每个参数，如果您的case类接受大量参数，这将是乏味而不优雅的。我想做的是以某种方式将case类“拆
浏览 14提问于2020-03-17得票数 0
回答已采纳
即使是.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.la
浏览 5提问于2012-06-26得票数 5
回答已采纳
1回答
所以我尝试过滤HList上的类型，它的类型可能会有所不同：
import shapeless._
import ops.hlist._, ops.traversable._
object FlexibleTypes {
sealed trait Data {
type H <: HList
def data: H
def ints[Prefix <: HList, Suffix <: HList](
implicit
partitionIntent: Partition.Aux[H, Int, Pre
浏览 0提问于2015-12-08得票数 1
我已经挣扎了几天，试图创建一个宏，或者使用“不成形”创建一个方法/函数来提取字段名和值作为一个TupleString字符串。
让我们想象一下下面的案例类：
case class Person(name: String, age: Int)
我希望有这样的东西(不需要真的是一个在案例类中的方法)。
case class Person(name: String, age: Int) {
def fields: List[(String, String)] = ???
}
// or
def fields[T](caseClass: T): List[(String, String)]
浏览 3提问于2021-05-14得票数 2
回答已采纳
我使用无形状库编写了这段简单的代码
import shapeless.LabelledGeneric
case class Icecream(name: String, numberOfCherries: Int, inCone: Boolean)
object ShapelessRecordEx2 extends App {
val gen = LabelledGeneric[Icecream]
val hlist = gen.to(Icecream("vanilla", 2, false))
hlist match {
case h :: _
浏览 2提问于2017-04-16得票数 5
回答已采纳
1回答
隐式参数优先
、、
我试图将泛型类型转换为HList：
trait ToHList[T] {
type Out <: HList
def apply(value: T): Out
}
trait LowPriorityToHList {
implicit def default[T]: ToHList.Aux[T, T :: HNil] =
new ToHList[T] {
override type Out = T :: HNil
override def apply(value: T): T :: HNil = value :: HNil
}
}
浏览 6提问于2021-06-19得票数 1
回答已采纳
1回答
假设我有一个hlist
val hlist: Boolean :: Int :: HNil = true :: 42 :: HNil
我有一个模式
type Pattern = Int :: Boolean :: HNil
如何用模式重新排序现有的hlist？也就是说。
reorder[Int :: Boolean :: HNil](hlist) // 42 :: true :: HNil
浏览 3提问于2016-11-24得票数 1
回答已采纳
使用Shapeless的Generic.Aux，我在Scala中遇到了下面的隐式问题
case class Complex(re: Double, im: Double)
object Prod2 {
def unapply[C, A, B](c: C)(implicit C: Generic.Aux[C, A :: B :: HNil]) = Some((C.to(c).head, C.to(c).tail.head))
}
val c = Complex(1.0, 2.0)
val Prod2(re, im) = c
上面的代码不能编译。它报告
Error:
浏览 4提问于2019-01-30得票数 1
在编译时，我想要验证一个类参数不是一个特定特征T的实例。我知道如何在运行时使用require或case match做到这一点，但我想知道在编译时如何做到这一点，以防止用户提供特定类型的对象混合。 我研究过scala宏/反射，但还不能完全理解它。 trait A
trait B
trait T
abstract class C extends A with B
case class P(c: C){
require(!c.isInstanceOf[T]) // how to do this at compile time ?
}
// usage as below
object c1
浏览 26提问于2020-04-13得票数 1
回答已采纳
1回答
我有一个如下所示的函数：
def fun[T <: HList](l: T)(implicit k: HKernelAux[T], ft: FromTraversable[T]) = ???
当我传递一个HList类型的参数时，这个函数就起作用了。如果我传递一个可扩展的记录，它只是一个带有标签的HList，隐式参数的值就找不到了。为什么会这样呢？有没有办法使该函数适用于HList和可扩展记录，或者我是否可以提供另一个适用于可扩展记录的函数？
浏览 10提问于2018-08-22得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
