Is a function that curries the first argument of a list of functions typeable in Typed Racket?

Question

I can write a simple function in untyped Racket called curry-all that takes a list of functions, all of which accept the same kind of value for their first argument, and produces a list of functions with their first arguments curried.

(define (curry-all fs arg)
  (map (λ (f) (curry f arg)) fs))

_{For a running example of the above function, see this snippet on pasterack.}

This is a valid function, but I'm not sure if it's even possible to type in Typed Racket given its polymorphic typing constructs. The type of curry itself is already fairly complex, and obviously the type of curry-all would need to be necessarily more complex.

I made a relatively simple attempt at typing this function, though I was quite aware that it would not function as I liked:

(: curry-all
   (All [a c b ...]
        (Listof (-> a b ... b c)) a
     -> (Listof (-> b ... b c))))
(define (curry-all fs arg)
  (map (λ ([f : (-> a b ... b c)])
         (curry f arg))
       fs))

Obviously, this works if all the functions have identical types (which isn’t worthless!), but it fails if they have different arities, even if their first arguments’ types are shared.

Is there any way to specify this function’s type so that it will work in a more general case?

Time

I would be very impressed if there is a solution :) – Tucker

@Tucker As would I. ;) I'm guessing there isn't one, but I figured I'd ask anyway. – Time

Based the original paper, it seems to take a similar approach to C++ templates where a type contract is generated at a callsite. Given this, I cant see the approach would work for procedures with a different 'signature'. – Tucker

@Tucker Not quite. Contracts are not generated at the call site—they're only generated on typed/untyped boundaries. This includes using typed code in untyped code or using require/typed to import code from untyped code. No contracts are applied to values used within typed code, since the typechecker guarantees soundness. As you note, though, many polymorphic types can't be converted to contracts, so you're correct that this would not be usable from untyped code. – Time

The arity of functions is available at runtime via procedure-arity and the implementation of curryr uses it. That code may be modifiable to provide the required implementation of a my-curry to do what you want. – Acetify

What type do you want this function to have? And in what context would you use it? – Hellenic

@SamTobin-Hochstadt I ran into this while attempting to emulate generic interfaces with some trickery involving currying. It would actually work, if the typing could support it. – Time

I don't understand how you'd describe the type that you want, or a case in which you'd use it. There has to be some regularity described by the type. – Hellenic

@SamTobin-Hochstadt All the functions in the list have the same type for their first argument. That's the unifying factor. – Time

Right, but how would you call the functions you get back? Do you really want a sequence of sequences of types? – Hellenic

can't you use some defunctionalization operator inside map ? – Flamen