Comment author: @jhjourdan

This issue appeared quite recently in the OCaml compiler (4.0 or so). It is interesting to avoid quadratic behavior with respect to arities in the case of Coq extracted code : it is not rare to have inductive types with dozens of constructors, and the induction predicates for those types have a big arity.

Comment author: @gasche

I see that the patch actually does two different thing:

1. the _app business
2. turning polymorphic compare into specialized int comparisons

The first change is subtle and needs careful review. The second seems easy to merge, provided there is evidence that it actually helps. Could you report changes in compilation times due only to the second change, on realistic programs?

Comment author: @sliquister

I don't remember measuring the second specialization by itself, but if I remember right, the first specialization made the linking of core and core_extended take 5s instead of 8.5s.
The impact of the specialization should be less noticeable if the rest of the patch is applied though.

Comment author: @xavierleroy

I guess this is a consequence of the change proposed first in #5287. I agree we must avoid code size quadratic in the arity of a curried function, at all costs.

Comment author: @sliquister

Turns out the previous patch was not quite right.
I attached a better one which mirrors the patch that introduced the _app functions in the first place: in the few places where the initial
patch added 'if some condition then apply optimization else do normal stuff', it now becomes 'if same condition and arity is not too big then ... else ...'.
I checked that when the optimization is always deactivated (max_optimized_arity = 0), the compiler bootstraps (instead of segfaulting with my first patch).

Comment author: @gasche

I reviewed this later patch and trust it is correct. I applied it in the SVN trunk.