shapeless

问题 Assuming that I intend to use the singleton/literal type feature in a scala program, this feature is provided in shapeless library in scala 2.12 (scala 2.13 supports native literal type but let's use shapeless as an example) In shapeless, literal type is represented as a path-dependent inner type of Witness object, which can be implicitly converted from a scala literal/const: import com.tribbloids.spike.BaseSpec import shapeless.Witness import scala.util.Random val w: Witness.Lt[Int] = 3 val

问题 Assuming if I have the following Record typed data, and a hlist of keys: val rr = ("a" ->> 1) :: ("b" -> "s") :: ("c" -> 3) :: HNil val hh = "c" :: "b" :: HNil And I want to extract values in rr for each key in hh , then combine them into a type level object, eventually yielding: (3: Int) :: ("s": String) :: HNil How this can be achieved with least amount of code? I could obviously write a inductively-summoned implicit function but it seems to be overkill 回答1: Firstly, you have typos. ->>

问题 Assuming if I have the following Record typed data, and a hlist of keys: val rr = ("a" ->> 1) :: ("b" -> "s") :: ("c" -> 3) :: HNil val hh = "c" :: "b" :: HNil And I want to extract values in rr for each key in hh , then combine them into a type level object, eventually yielding: (3: Int) :: ("s": String) :: HNil How this can be achieved with least amount of code? I could obviously write a inductively-summoned implicit function but it seems to be overkill 回答1: Firstly, you have typos. ->>

问题 I'm trying to foldLeft on a HList with an accumulator of type (HL, Int) , where HL is a HList. The program below does not compile. However, if I switch to a simpler accumulator of type HL (by just switching the commented lines with the ones above), it compiles and it works. Wrapping an HList in a tuple breaks the implicit resolution for the leftFolder. What am I missing? package foo.bar import shapeless.{:+:, ::, CNil, Coproduct, Generic, HList, HNil, Lazy, Poly2} import shapeless.ops.hlist.

问题 Consider the following setup: trait Foo[A] object Foo extends Priority2 trait Priority0 { implicit def foo1: Foo[Int] = new Foo[Int] {} } trait Priority1 extends Priority0 { implicit def foo2: Foo[Boolean] = new Foo[Boolean] {} } trait Priority2 extends Priority1 { implicit def foo3: Foo[Double] = new Foo[Double] {} } Now, in a REPL (having loaded the above code up), I can do the following: scala> def implicitlyFoo[A](implicit foo: Foo[A]) = foo implicitlyFoo: [A](implicit foo: Foo[A])Foo[A]

问题 Here is a simple example in shapeless 2.3.3: val book = ("author" ->> "Benjamin Pierce") :: ("title" ->> "Types and Programming Languages") :: ("id" ->> 262162091) :: ("price" ->> 44.11) :: HNil val v1 = book.values assert(v1.head == "Benjamin Pierce") // works fine // summoning Values[_] type class explicitly, the HList & TypeTag are optional case class HasValues[T <: HList: TypeTag](v: T) { def vs(implicit v: Values[T]): Values[T] = v } val _vs = HasValues(book).vs val v2 = book.values(_vs)

问题 I'm writing a type-safe code and want to replace apply() generated for case class es with my own implementation. Here it is: import shapeless._ sealed trait Data case object Remote extends Data case object Local extends Data case class SomeClass(){ type T <: Data } object SomeClass { type Aux[TT] = SomeClass { type T = TT } def apply[TT <: Data](implicit ev: TT =:!= Data): SomeClass.Aux[TT] = new SomeClass() {type T = TT} } val t: SomeClass = SomeClass() // <------------------ still compiles,

问题 If I have these two case classes: case class Address(street : String, zip : Int) case class Person(name : String, address : Address) and an instance: val person = Person("Jane", Address("street address", 12345)) Is there a way in shapeless to automatically convert person to an extensible record? I am interested in both shallow and deep conversions. The shallow copy would be something like: 'name ->> "Jane" :: 'address ->> Address("street address", 12345) :: HNil In the deep conversion, the

问题 Lets say I have the following: case class TestField(value: String) case class TestField2(value: String) implicit class ProductExtensions[T <: Product](val value T) extends AnyVal { def mapTo[R <: Product](implicit tGen: Generic.Aux[T, String :: HNil], rGen: Generic.Aux[R, String :: HNil]: R = ??? } val testField2 = TestField("my value").mapTo[TestField2] // TestField2("my value") Can I "genersize" the mapTo function to work for types other than String without having to specify the type? Note

问题 Lets say I have the following: case class TestField(value: String) case class TestField2(value: String) implicit class ProductExtensions[T <: Product](val value T) extends AnyVal { def mapTo[R <: Product](implicit tGen: Generic.Aux[T, String :: HNil], rGen: Generic.Aux[R, String :: HNil]: R = ??? } val testField2 = TestField("my value").mapTo[TestField2] // TestField2("my value") Can I "genersize" the mapTo function to work for types other than String without having to specify the type? Note