为什么我的“代码不够通用。类型变量 'a 无法泛化，因为它会超出其范围”？

Question

Is there a way to get this generic function to work?

module MarketData
open System.Collections.Generic

//start of mocks
type Name = Name of string with static member GetName = Name
type Element = 
    Element of string
    with
        member this.GetElementAsString x = ""
        member this.HasElement x = true
        member this.GetElement x = this
        member this.GetValueAsElement x = this
        member this.NumValues = 0

type MessageType = MessageType of string with member this.Equals s = this = MessageType s
type Msg = 
    {
        msg: string
        MessageType: MessageType
    }
    member this.HasElement x = true
    member this.GetElement x = Element ""

module Event =
    type EventType =
    |RESPONSE
    |PARTIAL_RESPONSE
    |SESSION_STATUS

type Event =
    {
        Messages: Msg seq
        Type: Event.EventType
    }
    interface IEnumerable<Msg> with
        member this.GetEnumerator () =
            this.Messages.GetEnumerator()

type Session =
    Session of string
    with
        member this.NextEvent() = {Messages = Seq.empty; Type = Event.EventType.RESPONSE}
// end of mocks


type FieldName = 
        FieldName of Name
    with 
        member this.AsName = let (FieldName x) = this in x
        static member FromString s = Name.GetName(s) |> FieldName

type SecurityName = SecurityName of string with member this.AsString = let (SecurityName x) = this in x

type ExtractState<'a> = 
    {
        Errors:string list
        Data:'a list
    }
    member this.ConsError e = {this with Errors = e::this.Errors}
    member this.ConsData x = {this with Data = x::this.Data}
    static member Empty = {Errors =[]; Data = []}

type RecordConstructor<'a> = SecurityName -> Element -> 'a
type SecurityProcessor<'a> = ExtractState<'a> -> Element -> ExtractState<'a>

module BbdData =
    [<RequireQualifiedAccess>]
    module Names =
        let SecurityData = Name.GetName("securityData")
        let Security = Name.GetName("security")
        let FieldData = Name.GetName("fieldData")
        let ResponseError = Name.GetName("responseError")
        let SecurityError = Name.GetName("securityError")
        let FieldExceptions = Name.GetName("fieldExceptions")
        let FieldId = Name.GetName("fieldId")
        let ErrorInfo = Name.GetName("errorInfo")
        let Category = Name.GetName("category")
        let Message = Name.GetName("message")

    let (|CompleteResponse|_|) (event:Event) =
        if event.Type = Event.EventType.RESPONSE then
            event |> Some
        else
            None

    let (|PartialResponse|_|) (event:Event) =
        if event.Type = Event.EventType.PARTIAL_RESPONSE then
            event |> Some
        else
            None 

    let (|SessionTerminated|_|) (event:Event) =
        if event.Type = Event.EventType.SESSION_STATUS then
            if event |> Seq.exists (fun m -> m.MessageType.Equals("SessionTerminated")) then
                Some ()
            else
                None
        else
            None
            

    //let sessionOptions = SessionOptions()
    //let session = new Session(sessionOptions)
    //session.Start() |> printfn "session open: %b" 
    //session.OpenService("//blp/refdata") |> printfn "service is open: %b"
    let session = Session ""

    let eventErrorMsg errorPrefix (elemError:Element) =
        let category = elemError.GetElementAsString(Names.Category)
        let msg = elemError.GetElementAsString(Names.Message)
        sprintf "%s -> %s -> %s" errorPrefix category msg

    let processRefSecurity<'a> (f:RecordConstructor<'a>) (state:ExtractState<'a>) (elemSecurity:Element) =
        let strSecurity = elemSecurity.GetElementAsString(Names.Security)
        if elemSecurity.HasElement(Names.SecurityError) then
            elemSecurity.GetElement(Names.SecurityError) |> eventErrorMsg strSecurity |> state.ConsError
        else
            elemSecurity.GetElement(Names.FieldData) |> f (SecurityName strSecurity) |> state.ConsData

    let processSecurities<'a> (securityData:Element) (f:SecurityProcessor<'a>) n initialState =
        let rec innerLoop iSec state =
            if iSec > n - 1 then
                state
            else
                securityData.GetValueAsElement(iSec) |> f state |> innerLoop (iSec - 1)
        innerLoop 0 initialState            

    let processResponseEvent<'a> (event:Event) f (state:ExtractState<'a>) =
        event |> Seq.fold (fun (innerState:ExtractState<'a>) msg ->
            if msg.HasElement(Names.ResponseError) then
                msg.GetElement(Names.ResponseError) |> eventErrorMsg "Request Failed" |> innerState.ConsError
            else
                let securityData = msg.GetElement(Names.SecurityData)
                let n = securityData.NumValues          
                processSecurities securityData f n innerState
        ) state

    let eventLoop f outerState =
        let rec innerLoop state =
            match session.NextEvent() with
            |PartialResponse event ->
                let newState = processResponseEvent event f state
                innerLoop newState
            |CompleteResponse event ->
                let newState = processResponseEvent event f state
                newState
            |SessionTerminated() ->
                failwith "session terminated"
            |_ -> innerLoop state
        innerLoop outerState        

    let sendRefRequest<'a> securities fields (f:RecordConstructor<'a>) =
        //let refDataService = session.GetService("//blp/refdata")
        //let request = refDataService.CreateRequest("ReferenceDataRequest")
        //let elemSecurities = request.GetElement("securities")
        //securities |> Seq.iter(fun (s:string) -> elemSecurities.AppendValue(s))
        //let elemFields = request.GetElement("fields")
        //fields |> Seq.iter(fun (s:string) -> elemFields.AppendValue(s))
        //session.SendRequest(request, null) |> ignore
        let secProcessor : SecurityProcessor<'a> = processRefSecurity f
        eventLoop secProcessor ExtractState<'a>.Empty

This is supposed to be a convenience wrapper around an API provided by Bloomberg. The idea is that the user supplies a function that creates a record from an Element provided by Bloomberg. The contents of the element depends on the specific fields requested. The RecordConstructor<'a> takes extracts all those field values from the Element and makes 'a .

sendRefRequest is, according to the compiler, not sufficiently generic.

Answer 1

It seems to me that the problem is here:

type ExtractState<'a> = 
    {
        Errors:string list
        Data:'a list
    }
    member this.ConsError e = {this with Errors = e::this.Errors}
    member this.ConsData x = {this with Data = x::this.Data}
    static member Empty = {Errors =[]; Data = []}

The last line doesn't constraint the empty list Data to be a list<'a> .

If you add a type annotation somewhere to fix that, the error message will go away:

static member Empty = {Errors =[]; Data = []}: ExtractState<'a>

BTW: this will take you to the next error:

~vsFE66.fsx(36,19): error FS0366: No implementation was given for 'System.Collections.IEnumerable.GetEnumerator(): System.Collections.IEnumerator'. Note that all interface members must be implemented and listed under an appropriate 'interface' declaration, eg 'interface... with member...'.

Just add: interface System.Collections.IEnumerable with member this.GetEnumerator () = this.Messages.GetEnumerator():> System.Collections.IEnumerator