typedesc cannot be used as a type converter

[bluenote10]

Might be related to #7160, but maybe worth tracking on its own. It looks like it is not possible to use typedescs for type conversions:

proc sum*[T](s: seq[T], R: typedesc): R =
  # sum which aggregates into a different result type
  var sum: R = 0
  for x in s:
    sum += R(x)
  return sum

echo @[1, 2, 3].sum(float)

Errors with Error: type expected in the conversion line. The same does work with generics

proc sum*[T, R](s: seq[T]): R =
  var sum = R(0)
  for x in s:
    sum += R(x)
  return sum

echo sum[int, float](@[1, 2, 3])

but this is much less elegant in some API design cases (e.g. in this case because having an overload sum[T] (implicit return type) and sum[T, R] (explicit return type) overload at the same time would be disallowed due to result type overloading).

I just noticed that there is a simple work-around for the issue though, which indicates that this is probably not a fundamental issue with typedescs. Introducing a dummy generic works:

template dummyConvert[T, R](x: T): R = R(x)

proc sum*[T](s: seq[T], R: typedesc): R =
  var sum: R = 0
  for x in s:
    sum += dummyConvert[T, R](x)
  return sum

echo @[1, 2, 3].sum(float)

[Araq]

Errors with Error: type expected in the conversion line.

Wierd error message, but doesn't this conversion mean that you want to convert x to a typedesc? If not, how would one do the conversion to a typedesc? Via type(R)(x)? typedesc is terrible. :-/

[zah]

@Araq, what?

A bound typedesc paramter such as R in the example is a concrete type. It's just a bug that the conversion doesn't work (there is a missing skipTypes somewhere).

In fact, there is a simpler work-around. The problem goes away if you give the R type a new name inside the proc:

proc sum*[T](s: seq[T], R: typedesc): R =
  # sum which aggregates into a different result type
  type RR = R
  var sum: R = 0
  for x in s:
    sum += RR(x)
  return sum

echo @[1, 2, 3].sum(float)