Add TypeOf utility

[Atry]

No description provided.

[milessabin]

Could you add a test where the expression performs a type-level computation via an implicit?

[Atry]

@milessabin The last one is via implicit:

val tu2: Either[String, TypeOf.`the.apply: Bar[String]`.U] = Right(23)

Note the the.apply

[milessabin]

Ahh, right. I really meant something a little more sophisticated than that, which justifies using this construct rather than expanding the type by hand. A non-trivial type-level computation would be good here (maybe a Sum of Nat's), and maybe a use of (Labelled)Generic[Foo].Repr.

the.apply is fairly odd usage TBH ... I wouldn't expect to see it in real code.

[codecov-io]

Codecov Report

Merging #692 into master will increase coverage by 0.04%.
The diff coverage is 100%.

@@            Coverage Diff             @@
##           master     #692      +/-   ##
==========================================
+ Coverage   83.39%   83.44%   +0.04%     
==========================================
  Files          65       65              
  Lines        2590     2591       +1     
  Branches       91       91              
==========================================
+ Hits         2160     2162       +2     
+ Misses        430      429       -1

Impacted Files	Coverage Δ
core/src/main/scala/shapeless/typeoperators.scala	100% <100%> (ø)	✅
core/src/main/scala/shapeless/syntax/hlists.scala	90.47% <0%> (+0.79%)	✅

---

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 20013c4...ca45457. Read the comment docs.

[Atry]

@milessabin I added a zipWithIndex test on HList

[Atry]

One more thing, I think it would be possible to create a compiler plugin, which supports a special @forExample annotation:

type A = T@forExample(expr)

which converts to

type A = TypeOf.`expr:T`.type

[Atry]

For example:

type T = Any@forExample(Generic[(Int, String, Boolean)].to((1, "foo", true)).zipWithIndex)

As a result, T is (Int, _0) :: (String, _1) :: (Boolean, _2]) :: HNil

[milessabin]

Interesting. I think you're getting into refined and singleton-ops territory here.

[milessabin]

A test using Generic?

[Atry]

@milessabin I hope it can perform type-level ops like singleton-ops. However, it is evaluated before method applying, preventing it get the actually type of a value.

[milessabin]

Does this work?

case class Baz(i: Int, s: String)
implicit val genBaz: TypeOf.`Generic[Baz]` = cachedImplicit
val reprBaz = genBaz.to(Bar(23, "foo"))
typed[Int :: String :: HNil](reprBaz)

If it does, could you add it as a test. If it doesn't it'd be good if we could make it work.

[milessabin]

Or should that be,

implicit val genBaz: TypeOf.`Generic[Baz]`.type = cachedImplicit

[milessabin]

Anyhow, the point is that this would capture the Repr type in the type ascription which is quite awkward to do otherwise. See here.

[milessabin]

Or, rather, here.

[Atry]

Of course, TypeOf can infer Repr from implicits. ca45457#diff-9e42d9f002bf1026dba49cfe00ca4ebbR175

[milessabin]

Great stuff. It's not immediately obvious that that would work, because the interactions with cachedImplicit and the semantics around implicit definitions with and without type ascriptions are quite subtle. I could easily believe that the val might be initialized to null in that case.

It's great that this works ... it's a really useful addition to the toolbox ... thanks! :-)

[Atry]

I guess the would work as well:

implicit val genBaz: the.`Generic[Baz]`.type = cachedImplicit

[milessabin]

Oh! Interesting ... that hadn't occurred to me ... does it work?

[Atry]

Works for me