One attempt is here: https://gist.github.com/noelwelsh/57f7609e80fb7b752547fdd3e13f08aa
An earlier attempt is higher up in the thread :point_up: March 27, 2020 1:28 PM
An earlier attempt is higher up in the thread :point_up: March 27, 2020 1:28 PM
I noticed that some collection classes scramble their class names, for example scala.collection.immutable.List -> scala.collection.immutable.$colon$colon (which, confusingly, so does Seq) Are Seq derivatives the only collections scrambled this drastically (i.e. they don't contain the class name at all)?
:: is a subclass of List
:: is not a valid name of the JVM so it gets encoded
This helps, thank you... But I'm still wondering about ::. This is "special" because its not the actual name of the class, i.e. List, or Seq. It seems most (all?) of the other encoded collection class names feature the name of the class, like Map gives you: scala.collection.immutable.Map$Map1, so the "Map" class name is clear there. Are there others that remove the class name entirely, like ::?
(changing the "natural" name of the collection, e.g. List, for something more symbolic)
name encoding is not specific to collections
Here's another example of name encoding of a class: https://www.scala-lang.org/api/current/scala/$less$colon$less.html
I suppose that comes down to how do I know if it's single or triple quoted
@martijnhoekstra are you asking about Tasty reflection or the compiler side? There’s probably a better API, but from the compiler side, Trees store their
SourcePosition which stores a SourceFile so you can access the actual characters in the worst-case via https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/util/SourceFile.scala#L70
(not that I’m entirely sure I get the question exactly — what you describe sounds inconsistent, possibly by oversight)
so
s"""foo $bar baz""" matches Apply(Select(Apply(StringContextApply(), List(Literals(strs))), _)
and the start positions of those
strs point at the first quote and the space after $bar
oh, I can use that in a pinch, the position of
f is the length of foo before the end of the first literal
should have brought my rubber duck
final case class Col[Key, Value](data: Array[Value])
type IndexOf[F <: Tuple, Key] <: Int =
F match {
case Col[Key, v] *: cols => Int
case Col[k, v] *: cols => String
}
// Compiles after #8024 (it should already be possible to get there using inheritance)
def indexOf[F <: Tuple, Key](f: F, k: Key): IndexOf[F, Key] = {
// We need some sort of ClassTag/TypeTag to properly implement this pattern matching...
f match {
case _: Col[Key, v] *: cols => 0
case _: Col[k, v] *: cols => "1"
}
}
def get[F <: NonEmptyTuple, Key](frame: F, k: Key) =
indexOf(frame, k)
Now if
IndexOf[F, Key] reduces to String, you can get a class cast by calling get[Col[Unit] *: Unit, Unit] which returns 0 typed as a String. Similarly, if IndexOf[F, Key] reduces to Int, get[Col[Char] *: Unit, Boolean] returns "1" typed as an Int.
@OlivierBlanvillain but the original code is sound; if there’s a fix, it’s about https://gitter.im/lampepfl/dotty?at=5e7e01dc4a4f8e0a100bea68. In particular, here
?1 <:< Types.IndexOf[F, Key] implies ?1 = Types.IndexOf[F, Key].
sorry, that’s not true for any
?1 — but it should be true for the ?1 in question (which comes from... where, constValue ?)
My goal is to select an element from an HList based on a type. I was using Tuple as it is an HList in Dotty, AFAIU, but that is not an essential part of the problem. In terms of implementation my approach should not be taken to be the best approach. I started looking at Dotty metaprogramming a few days ago and I'm still learning. So if there is an approach that works I'd love to hear it. A simplified version of the problem is, given,
final case class Box[Key, Value](value: Value)
val list = Box["one", Int](1) *: Box["two", Double](2.0) *: Unitcalling
get["two"](list)should return 2.0 with type Double and
get["three"](list)should be a compile time error. The problem is to implement get in a way that gets past type checking.