Back to Questions
1.3k
views2
comments
active patterns as class members?
f#

Dear list,

I would like to have an active pattern definition as a class member in order to use member functions within the pattern.

I tried to guess the right syntax for matching the pattern, without success...

Here is a toy example...

/// any member function

member this.Convert a = a+1

/// my active pattern as a member (so far no complaints)

member this.(|MyPattern|) ((a,b)) = (this.Convert a, b)

/// method that uses the active pattern

member this.MyMethod x =

match x with

| this.MyPattern (c,b) -> printfn "%A %A" c b //<--- fsharp complains here...

In the last line fsharp complains about "this." with "Namespace or module this is not defined."

If I remove "this." it complains that "The pattern discriminator MyPattern is not defined"

Any ideas?

Laura

.

Hi Laura,

I think problems is that this is been interpreted as a type or namespace prefix to a union type. I think the solution is move your pattern into a let binding, gives a warning because of the this but basically seems to work:

type MyType() as this =

let (|MyPattern|) ((a,b)) = (this.Convert a, b)

/// any member function

member this.Convert a = a+1

/// method that uses the active pattern

member this.MyMethod x =

match x with

| MyPattern (c,b) -> printfn "%A %A" c b

Cheers,

Rob

By on 12/23/2008 8:11 AM ()

Hi,

Robert beat me to it, but I came up with:

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

type MyType() =

    member this.Convert a = a+1

let (|MyPattern|) (this:MyType) (a,b) = (this.Convert a, b)

type MyType with

    member this.MyMethod x =

       match x with

        | MyPattern this (c,b) -> printfn "%A %A" c b

In all honesty, I would never write that, unless Convert would be a method on some interface that is implemented by several MyTypes. But it is educational in the sense that it points to a key limitation in F#: you need to define almost everything "in order", and you can define mutually referring types and mutually referring functions, but not a mutually referring function and type without resorting to tricks like the above.

have fun with F#,

By on 12/23/2008 8:26 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