Comment author: @garrigue

There is a specification of the dynamic semantics in "Labeled and optional arguments for Objective Caml" (http://www.math.nagoya-u.ac.jp/~garrigue/papers/index.html). Yhe problem you describe here is with the type checking, but the two are related.

For type checking, the rule is as follows:

• match the labels of the arguments with those in the type of the function
• after doing this matching, discard optional arguments in the type of the function if a non-labeled argument was passed that appears later in the type
• for labels that do not appear in the type of the function, collect them in the order in which they appear in the application, and use them to generate an expected return type, to be unified with the return type of the function
• then do all unifications

So the point is that when typing an application without parentheses, unifications are delayed to the end.
Here this means that the type inferred for id will be
(~b:'a -> 'b) -> ~b:'a -> 'b
which cannot be applied to (plus 1), which has type (?b:int -> int -> int).
By adding the parentheses, the unifications are forced first, so that (id (plus 1)) has exactly the type infered by the top-level.

So the answer is that you should be keeping the parentheses as they were in the original source code, since they may change both the static and dynamic behavior.

Comment author: @garrigue

Nothing to fix, since this is the intended semantics.

Comment author: @jberdine

Thanks a lot Jacques, I see now.