[Feature Request] Ellipses for Parametric Contracts

[Tuplanolla]

I would like to endow apply and other such procedures
with more precise contracts, as seen below.

(define/contract apply/contract
  (parametric->/c (src ... dst)
    (-> (-> src ... dst)
        (list/c src ...)
        dst))
  apply)

Alas, I cannot, because parametric->/c does not support ... or
any other mechanism for binding arbitrarily many type parameters.
It seems that I have to ignore the domain completely, as shown below.

(define/contract apply/contract
  (parametric->/c (dst)
    (-> (unconstrained-domain-> dst)
        list?
        dst))
  apply)

Is this the best I can do right now?
Could support for ellipses be added in the future?

[usaoc]

It seems to me that this pseudo-contract has two problems:

1. The ellipsis ... actually identifies
   • the number of arguments the procedure accepts, and
   • the number of elements in the list;
2. (list/c src ...) cannot make sense (remember that list/c is nothing more than a procedure).

Put these together, it doesn’t seem possible to make sense of what the ellipsis ... means. What exactly is the pseudo-contract trying to express, anyway? That if we have a list with n elements, then we should wrap those elements in opaque structs (negative position), and unwrap them when they are supplied to the procedure (positive position), as well as checking that the procedure accepts n arguments? If arity checking is all you need, then I think doing that alone is fine, otherwise you’re checking in extra that apply is, well, applying.

The short answer is that contracts are not types, that’s it.

[usaoc]

Just for reference, I think this issue is asking for an equivalent of this Typed Racket program in terms of contracts:

#lang typed/racket/base
(: my-apply (All (t s ...)
              ((s ... -> t) (List s ...) -> t)))
(define (my-apply proc args)
  (apply proc args))

(my-apply + (list 1 2 3))