shapeless: Generic programming for Scala | This room deprecated in favour of #shapeless on the Typelevel Discord: https://discord.gg/bSQBZA3Ced
if you have no idea how to start that, I'd recommend to read (or reread) the
type astronaut guide to Shapeless
:D
@crakjie So I cheated a little bit. In my case, I'm not passing the list in as a parameter. If that works in your case, here's the code I ended up with.
import shapeless.ops.hlist.Selector
import shapeless.{::, HNil}
object Program {
case class Cat(name: String)
case class Dog(name: String)
case class Fish(name: String)
val animals = Cat("silver") :: Dog("daisy") :: Fish("nemo") :: HNil
def main(args: Array[String]): Unit = {
animalHandling(catNoise)
}
def catNoise(c: Cat): Unit = println("meow")
def animalHandling[A,B](f: A => B)(implicit ev: Selector[Cat :: Dog :: Fish :: HNil,A]): B = f(animals.select[A])
}
Actually, I was able to make it more generic.
import shapeless.ops.hlist.Selector
import shapeless.{::, HList, HNil}
object Program {
case class Cat(name: String)
case class Dog(name: String)
case class Fish(name: String)
val animals = Cat("silver") :: Dog("daisy") :: Fish("nemo") :: HNil
def main(args: Array[String]): Unit = {
animalHandling(catNoise)(animals)
}
def catNoise(c: Cat): Unit = println("meow")
def animalHandling[A,B, H <: HList](f: A => B)(xs: H)(implicit ev: Selector[H,A]): B = f(xs.select[A])
}
Or at least mathemagically. :D
Hey, I'm trying to verify that for a given
Coproduct and a given Seq, the Seq contains at least one element of every member in the Coproduct. Currently, it's using union.Keys and ops.hlist.ToTraversable to string compare the symbols to the class SimpleNames. It feels like there should be a better way of doing this. Is there a more correct/canonical approach to solving that problem?
def check[A, C <: Coproduct, K <: HList](data: Seq[A])(
implicit
gen: LabelledGeneric.Aux[A,C]
keys: ops.union.Keys.Aux[C,K]
toList: ops.hlist.ToTraversable.Aux[K,List,Symbol]
): List[(String,Boolean)] = {
val classes: List[Symbol] = toList(keys())
classes.map(sym => (sym.name, data.exists(_.getClass.getSimpleName == sym.name)))
}
Hey guys, I'm trying to use shapeless's HMap class, and I'm running into trouble. The docs say that it supports "an arbitrary relation between the key type and the corresponding value type", but it looks like you cannot reuse the key type. I.e., you cannot define both a
Int -> Double and Int -> String. Is this correct? Or am I using the library incorrectly?
if you have both
Rel[Int, Double] and Rel[Int, String], and you do get(1), how will the typesystem know whether the value is of type Double or String?
you might also want to look at the
vault library for a similar abstraction with different constraints
in that case the keys are represented by a value of type
Key[A], and then you can get the corresponding value
it's not quite a Map though, more like a store
and just not use Int in the HMap
although it does seem like you might be able to do this if you specify the return type as well (not sure if that would work with HMap, but some sort of Poly wrapper around a Map should do it)
I can use
implicit ev: SelectAll[H,I] to ensure all members of I are in H.
And I can use
implicit ev: IsHCons[I] to ensure that I is not empty.
But if I combine the two like so...
def foo[H <: Hlist, I <: HList](xs: H, ys: I)(implicit ev: SelectAll[H,I], ev2: IsHCons[I]): Unit = {
println(xs.select[ev2.H])
}
It says that there's no proof that
ev2.H is in H.
SelectAll does not guarantee order, so SelectAll[H, I] does not provide proof that IsHCons[I] is equal to IsHCons[H].
So you cannot do
ev2.head(xs) because while they have the same types, it’s not given that the head of H is the same type as head of I. It could be a type not existing in I, or one of the types in the tail of I. And if you wanna do xs.select, you need to provide a Selector instance for it.
But it looks way better than what I finally arrived at last night.
or rather, there are two different approaches to this problem: HMap and Vault
if you have
A -> B and A -> C then by definition it's not a mapping
what does
A ->map to, at the type level?
B or C?
they will all have different types