shapeless: Generic programming for Scala | This room deprecated in favour of #shapeless on the Typelevel Discord: https://discord.gg/bSQBZA3Ced
they will all have different types
and it will work brilliantly
you can then convert strings to objects at the edge (or even build some machinery with witness similarly to how record selection works)
again, if you have
A -> B and A -> C, how is that a mapping?
it sounds like you want to be able to map the value "a" to the type
Boolean and the value "b" to the type Int
this is not directly possible without full dependent types: a value is a runtime entity, whilst a type is a compile time one
the way you simulate it generally is by the pattern of creating singleton types
you create types with exactly one value, provide a type to type mapping, and then need to handle the lifting of values to their singleton types with runtime checks (if they aren't statically known) or macros (if they are)
the pattern I mention above with objects as key + HMap does exactly that
and the same pattern is used by shapeless labelled generic, without going through objects but directly exposing the singleton types of strings through macro magic
If I have a recursively-resolved typeclass like this:
trait Foo[A] {
type Repr
def to: Repr
}With at most one instance for a given A. Is there a way to write an instance summoner that looks something like this:
def instance[A](implicit foo: Foo.Aux[A,R]): R = ???? And if so, will the compiler correctly infer the concrete type rather than some Foo.Aux… type?
Will the compiler infer the concrete type of
Foo[A].repr for a given A?
Thanks Fabio!
e.g
implicit def yo: Foo.Aux[A, Int]
implicit def yo: Foo[A] won't work (that's what I meant by declaring things right)
if that fails, a small reproducible gist will do
and that means you have a logical error in your derivation somewhere
a very simple way to fix it is to remove the type sigs
however , that can hit some weird corner cases
so explicit types with
Aux is the best practice
the inferred type will infer the refinement
the problem is that you hit some bugs sometimes (pretty weird ones)
probably dotty will require explicit signatures for implicits though
It's still needed in Dotty I'm afraid.
It would be good to come up with a way to avoid it.
we don't need
Aux as much though, right? if parameters can depend on each other within lists
however perhaps you can just write the full refinement in that case, it's not that big of a deal if only the return type is affected. I think what confuses people about Aux is the prolog style it forces when thinking about your type params, mostly
and that is fixed if you can do
(implicit gen: Generic[A], foo: Foo[gen.Repr])