Seq constraint in type definition - f#

Question

This type definition works:
type Model<'t,'u when 't :> seq<'u> >(query: unit -> 't) = class end
However, as for me the 'u is redundant here, but next definition:
type Model<'t when 't :> seq<_> >(query: unit -> 't) = class end
produces the error:
Anonymous type variables are not permitted in this declaration - F# Compiler (715)
Compact
The most compact form:
type Model<'t>(query:unit -> #seq<'t>) = class end
during instance creation:
Query.users |> Model
produces error:
Type constraint mismatch. The type unit -> (string * int) list
is not compatible with type unit -> 'a
F# Compiler (193)
Probably, because of described here Why are flexible types not allowed in record type definitions?. But anyway the error description is unclear for me, what is wrong in substituting (string * int) list instead of 'a?
Background
The real type Model is a wrapper for a database query, it implements INotifyPropertyChanged and contains mutable state of type Outcome:
type 't Outcome =
| Empty
| Loading
| Success of 't
| Fault of string * string
The #seq<'t> type constraint is needed to detect Empty case with Seq.isEmpty in generic way due to a query can return seq or list or array

Answer 1

As explained by #kvb, the problem is that you cannot have generic constructors - so you can either introduce a new type parameter to the entire class (as you did in your first example), or the return type of query will need to be just seq<'t> (as the compiler forces you to do in your other examples).
If you want to keep things encapsulated in a class, one nice trick is to make the constructor private and add a static Create method which can have the extra generic parameter that you need:
type Model<'t> private(query:unit -> seq<'t>) =
static member Create(query:unit -> #seq<'t>) =
Model(fun () -> query () :> _)

Answer 2

The problem with the definition
type Model<'t>(query:unit -> #seq<'t>) = class end
is that the # introduces an implicit type parameter, but constructors can't have their own type parameters in addition to the class's. For instance, you also can't define something like this:
type IntConverter(conv:'a -> int) = class end
because the constructor can't have its own free type parameter 'a.
However, the good news is that even if you change your definition to
type Model<'t>(query:unit -> seq<'t>) = class end
it's easy to accept an input of type unit -> #seq<'t>:
let model f = Model(fun () -> upcast f())

Answer 3

I guess as long as you are willing to add that helper function you can get somewhat close:
type Model<'t>(query:unit -> seq<'t>) =
class
static member Unwrap<'s when 's :> seq<'t>> (cpar: unit -> 's) =
cpar >> (fun (s: 's) -> (s :> seq<'t>))
static member New (cpar) =
new Model<'t>(Model.Unwrap<_> cpar)
end
At least that will allow you to use something like (I think)
Query.users |> Model.New
As soon as I do something similar with an actual constructor (overload) the compiler says "The type variable 's has been constrained to be type 'seq<'t>'.". So apparently different rules apply to constructors than to static methods (why do I sound surprised).