Back to Questions
2.4k
views4
comments
Type mismatch compiler error with forward referred type
f#compilerasync

Hi

I have been staring at the following compile error the last couple of hours:

1

Error    1    Type mismatch. Expecting a  LazyMessage<'send> but given a  LazyMessage<'a>. The type ''send' does not match the type ''a'    C:\src\netbash\trunk\NetBashModel\communication.fs    193    12

The code looks like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

[...]
let serialize msg = 
        let formatter = new BinaryFormatter()
        let seri = 
            use ms = new MemoryStream()
            formatter.Serialize(ms, box msg)
            ms.GetBuffer()
        seri
type ComPoint<'recv, 'send>() =
    [...]
    let sendMessage (stream : ByteMessageStream) message = async { do! stream.Send(message)}
    
    let sendLazy receiver (lazyMsg : LazyMessage<'send>)=
        let byteMessage = lazyMsg.Data
        sendMessage receiver byteMessage
    [...]  
    member x.SendAsyncLazy : ByteMessageStream -> LazyMessage<'send> -> Async<unit> = sendLazy    

and LazyMessage<'a> (msg : 'a) =
    let lazymsg = lazy(serialize(msg))
    member x.Data with get() = lazymsg.Value   //<----- the compiler error is here

I don't understand the compiler error, since I specifically say in the signature for SendAsyncLazy that it must be of LazyMessage<'send>. Can anyone see the problem?

The LazyMessage type is used to avoid serializing the same message several times (if I need to send it over several ByteMessageStreams) and still have the compiler type check that I don't send other messages than of type 'send. The ByteMessageStream takes care of asyn reading/writing byte[] from the network and the ComPoint is meant to work on top of that to provide typing.

Best regards,
Jacob

.

I wonder if the problem of ordering and "and" type decleration ?

1
2
3
4
5
6
7
8
9
10
11
12

type LazyMessage<'a> (msg : 'a) =
    let lazymsg = lazy(serialize(msg))
    member x.Data 
        with get() = lazymsg.Value   //<----- the compiler error is here      
           
type ComPoint<'recv, 'send>() =
    let sendMessage (stream : Stream) message = async { do! stream.Send(message)}
   
    let sendLazy receiver (lazyMsg : LazyMessage<'send>)=
        let byteMessage = lazyMsg.Data
        sendMessage receiver byteMessage
    member x.SendAsyncLazy : Stream -> LazyMessage<'send> -> Async<unit> = sendLazy
By on 1/29/2008 7:28 AM ()

Whoops!

Yes you are right - no reason for the LazyMessage to know anything about the ComPoint. I must be blind.

Thanks :)
Jacob

By on 1/29/2008 7:38 AM ()

I'm still not sure I understand why it wouldn't work with type definitions as they were. Anyone care to offer an explanation?

By on 1/29/2008 12:57 PM ()

You're right Robert,it should work anyway.

By on 1/30/2008 1:39 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper