This is a stripped down version of #260. Here I only propose to add local exception definitions, with no specific compilation (which can come later or not).

Local exceptions should be encouraged, since they document a more limited scope, which helps reasoning about the code and avoid subtle bug when higher-order function use a generic exception (such as Exit) for their internal control flow but can easily get confused if they call unknown function which could also raise the same exception.

Moreover, now that it is no longer allowed to define multiple exceptions with the same name in a given structure, it becomes even more important not to pollute the global scope.

There is of course a work-around for encoding local exceptions with local modules, but it's syntactically heavier (two names need to be invented) and less efficient (unless more optimization are added). People would more be likely to use global exceptions if we don't provide something lighter than this encoding.

See https://blogs.janestreet.com/a-universal-type/ for some fun use of (previously encoded) local exceptions that would benefit from this feature:

module type Univ = sig 
  type t 
  val embed: unit -> ('a -> t) * (t -> 'a option) 
end 

module U : Univ = struct
  type t = exn

  let embed (type s) () =
    let exception E of s in
   (fun x -> E x), (function E x -> Some x | _ -> None)
end

Note: the grammar has been massaged a little bit to avoid a conflict with exception patterns:

let exception Exit = ... in ...
let exception Exit in ...

As a result, exception patterns are now disallowed in let bindings. They were rejected by the type-checker anyway.