Back to Questions
6.4k
views5
comments
Translating the rx join pattern matching syntax to f#
f#reactive

I am trying to translate the rx join syntax a palatable f# version. I am using FSharp.Reactive and this is what i got so far:

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

let (|F3|) f = Func<_,_,_,_> f

type MyJoin =
    static member Join (patterns: Joins.Plan<_> List) = Observable.join(patterns |> List.toArray)
    static member Pattern ((s1: 'a IObservable), s2, s3) = s1.And(s2).And(s3)
    static member Plan (p: Joins.Pattern<'a,'b,'c>, F3 f) =  p.Then(f)   //first version
    static member Plan (s1: 'a IObservable,s2,s3, F3 f) = s1.And(s2).And(s3).Then(f) //second version
    static member Plan (p: Joins.Pattern<'a,'b,'c,'d>, F4 f) =  p.Then(f)

type J = MyJoin

type IObservable<'a> with
    member x.f (f: 'a -> bool) = x.Where(Func<_,_> f)

let join1 = 
        let a,b,c=observable1,observable2,observable3
        J.Join[J.Plan(J.Pattern(a,c), (fun _ _ -> "tick")) 
               J.Plan(J.Pattern(b.f(fun x ->x>3),c), (fun _ _ -> "tock"))
              ]

I would like to achieve something like this:

1

J.Join[(a,c) ==> (fun _ _ -> "tick") ]

but cant get the infix operator to work.

.

How is your operator defined?

By on 8/3/2012 11:49 AM ()

I do not have access to my code/Visual studio for a few days (on vacation) but as far as i can remember i (among other stuff) tried something like: 

1
2

type MyJoin =
   static member (==>) ((s1: 'a IObservable,s2,s3), F3 f) = s1.And(s2).And(s3).Then(f)


Should this work?

btw. the code indentation shows up ok in the preview window but is messed up in the posting.

By on 8/3/2012 12:36 PM ()

I found this excellent blog series that explains the innards of operator definition very well:
defining operators in f#
Especially this crucial piece:
"When an operator is found the compiler first try to find a “global” definition at the local scope, if no definition is found then it is assumed as an operator defined at the type of one of the operands."

So i solved it this way:

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

  ///Joins together the result from several Plans
  let Joins (patterns: Joins.Plan<_> List) = Observable.When(patterns |> List.toArray)

  type P1<'a> = P1 of IObservable<'a> with
        static member (==>) (P1(o), F1 f) =
            o.Then(f)

  type P2<'a,'b> = P2 of IObservable<'a> * IObservable<'b> with
        static member (==>) ((P2(o1,o2)), F2 f) = 
            o1.And(o2).Then(f)

///usage
let obs4 = Joins[P2(obs1,obs2) ==> (fun a b -> a + b)  
                 P1(obs3)      ==> (fun a -> a)        ]
By on 11/21/2012 3:29 AM ()

hmm, changing tags does not seem to work.

By on 7/25/2012 3:56 AM ()

Hi,
I corrected the tags on this topic and filed the issue. Thanks for signaling the problem.

By on 7/25/2012 5:23 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