[See full code below]

I have encountered a fairly subtle issue with private types which 
doesn't occur otherwise.  The source of the issue, I believe, is 
actually the need to have a 'row variable' available to be able to use 
'private' on a polymorphic variant.

In the code below (a massive simplification of my actual case), f 
compiles, but g does not, with error
Error: This pattern matches values of type
             [> `Operator of 'a * 'b list * 'c S.pk ]
         but is here used to match values of types S.operator
        Types for tag `Operator are incompatible
(pointing to the line that starts with | `Operator ...)

First suggestion: could the error message please include what the 
incompatibility is? 
Second suggestion: could the type S.operator be (also) given in its 
'expanded' form?  It would be useful to know what the compiler thinks 
the type S.operator actually is.
Third suggestion: in this particular case, could the error message 
include some hints that the problem is one of [< ] vs [> ] ? [if my 
understanding of the issue is correct!]

I will add these suggestions to the bug system next, but I figured 
others on this list might benefit from my experience in debugging this 
issue in my code.

Jacques

PS: I actually don't want the intermediate type pk, po, pb and ps to be 
visible at all outside of S, but I do not know how to achieve that 
without adding another layer of indirection.  Any advice along these 
lines would be appreciated.

PPS: I experimented with variance annotations too, thinking that that 
might do the trick, but to no avail. 
---

module S : sig
    type 'a pk = KType | KFormula | Kind of 'a pb
    and  'a po = [`Operator of string * 'a pk list * 'a pk ]
    and  'a pb = [`Thing of string]
    type 'a ps = ['a po | 'a pb]

    type se = se ps
    type operator = private [< se po]
end = struct
    type 'a pk = KType | KFormula | Kind of 'a pb
    and  'a po = [`Operator of string * 'a pk list * 'a pk ]
    and  'a pb = [`Thing of string]
    type 'a ps = ['a po | 'a pb]

    type se = se ps
    type operator = se po
end

open S

(* this one works *)
let f (o:operator) : string =
    match o with
    | `Operator(s, [], S.KType) -> s
    | `Operator(_,_,_)          -> failwith "nope"
(* this one doesn't ! *)
let g (o:operator) : string =
    match o with
    | `Operator(s, [], S.KType) -> s
    | _                         -> failwith "nope"
;;