I'm starting to dislike this method more and more. Don Syme had a post addressing a similar issue on his blog a while back. Basically it boiled down to that he did keep a state variable, but it was hidden from inaccessible to anything except for the event in question.

[link:blogs.msdn.com]

The code he used was this:

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

let mkMouseTracker (c : #Control) =
    let fire,event = IEvent.create() in
    let lastArgs = ref None in
    c.MouseDown.Add(fun args -> lastArgs := Some args);
    c.MouseUp  .Add(fun args -> lastArgs := None);
    c.MouseMove.Add(fun args ->
        match !lastArgs with
        | Some last -> fire(last,args); lastArgs := Some args
        | None -> ()); 
    event

let mouseEvent = mkMouseTracker form
do mouseEvent.Add(fun (args1,args2) -> move view args1 args2)

Modifying this to create a down/up combined event could be done like this:

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

let handleDownUp down up = 
   MessageBox.Show(String.Format("Down at {0}, Up at {1}", down, up))

let mkDownUpEvent : (c : #Control) = 
   let fire, event = Event.create()
   let downargs:MouseEventArgs ref = ref null
   c.MouseDown.Add(fun args -> downargs : args);
   c.MouseUp.Add(fun args -> fire(!downargs, args));
   event

let form = new Form()
mkDownUpEvent form
   |> Event.listen(fun (down, up) -> PrintStuff down.Location up.Location)

There may be a way to do it more statelessly, but the more I think about it, the more I think you should just use state, but hide the state as much as possible

Cyclic dependencies between F# and C# within a single project would make compiling both sources in a single project tricky.

If the dependencies are one way (C# to F#), then you might be able to run the fsc.exe first and csc.exe (is that the C# compiler?) second, leaving your project fully built.

The way the Groovy language handles cyclic dependencies between languages is to have a joint compiler... the compiler phase 1 runs through all the Groovy code and generates object file stubs so that the next phase has something to link against. The 2nd phase compiles the java code against the groovy stubs, linking correctly. The 3rd phase then recompiles the Groovy object files linking correctly against the classes compiled in Phase 2.

The problem with this is what to do when you want to have cyclic dependencies between F#, C# and Boo. And there's also an issue with large C# projects with a little F# code... you'd have to change the compiler for all the C# code to this new F# joint compiler which probably triggers regressions testing. (Those were our two issues anyway).

My group decided to settle on a core language and define an extension language (Core=Java, extension=Groovy). And then only allow unidirectional dependencies from core to extension. With dependency injection frameworks like Spring, we can easily hide dependencies behind interfaces and everything works well. I'd recommend that.