Matching generics

[kyouko-taiga]

It would be interesting to be able to match generic arguments against some form of pattern:

match a {
  let x: Map<T, _> { ... }
  ...
}

In this example, x would match any type that is a map from T to some arbitrary type. The question is, what is the type of x?

It cannot be Map<T, Any> because it would imply some kind of conversion of a's value representation.

[dabrahams]

match type(of: a) {
  Map<K, let v> { ... }
}

Is probably more feasible.

match a {
  let m where Map<T, _> ~= type(of: m) { ... }
}

might work, but in this case I think the type of m is Any.

I don't suppose Map<K, some Any> is a reasonable thing. This is a case where recovery of the monomorphized static type is almost certainly impossible, so we need to be careful.