Currently, for [sig ... end with type lhs := rhs] to be valid, rhs needs to
be an application of a type constructor to the same type parameters as lhs.

I'd like to do, at a minimum, [sig ... end with type 'a t := 'a], but this
is currently forbidden. Are there conceptual obstacles to permitting
arbitrary type expressions on the RHS, or are they simply not implemented
yet?

Note that I can do [type 'a id = 'a] and then [... with type 'a t := 'a
id], but it's clumsy to have to define an auxiliary type for this and it's
not always easy to find an appropriate place to do so.

In particular, I have modules with a blocking interface and an Async
interface, so I define:

module type Thing = sig
  type 'a result
  val read_thing : in_channel -> thing result
  val write_thing : out_channel -> unit result
end

thing_async.mli:
include Thing with type 'a result := 'a Deferred.t
thing_or_error.mli:
include Thing with type 'a result := 'a Or_error.t
thing_exn.mli:
include Thing with type 'a result := 'a (* fails :( *)

Having Thing_exn.id be a useless type constructor would be pretty sad.