Since F# partial active patterns are simply functions, they can be combined just like any other functions to form up more complex patterns. Suppose you want to define active pattern for extracting MethodInfo from lambda expression (with sole parameter).

The pure code will looks like this:

1
2
3
4
5
6

    let (|MethodCall|_|) (expr: Expr) =
        match expr with
        | Lambdas (_, methodExpr) -> match methodExpr with
                                     | Call (_, methodInfo, _) -> Some methodInfo
                                     | _ -> None
        | _ -> None

It’s quite straightforward, but still has some boilerplate (default rules returning None) and it will become more ugly when we will need deeper match.

Fortunately we can define functions which will let us eliminate boilerplate and write it down it more readable (I hope) form.

Let’s try monadic combinators first. Following combinators are defined for Option monad (also known as Maybe monad in Haskell’s world)

1
2
3
4
5
6
7
8

    // Promote a function to a monad.
    let liftM f m = 
        match m with
        | Some a -> Some (f a)
        | None -> None

    // Left-to-right Kleisli composition.
    let (>=>) m1 m2 = m1 >> (function | Some a -> m2 a | None -> None)

Now we can write down our pattern like this:

1
2
3

    // Actually we will have to provide type annotations here
    let (|MethodCall|_|) =  (|Lambdas|_|) >> liftM (fun (_, methodExpr) -> methodExpr)
                        >=> (|Call|_|)    >> liftM (fun (_, methodInfo, _) -> methodInfo)

Monadic combinators can be generalized to arbitrary monad (not just to Option/Maybe) with few syntactic overhead (due to lack of type classes support in F#), so use of it is the common pattern, easily recognized by any Haskell programmer (and F# programmer, I hope). We can go further and make use of so called “computation workflows” that actually introduces syntactic sugar for monadic operations. Let’s define computation workflow for the Maybe monad:

1
2
3
4
5
6
7
8
9
10

    type OptionBuilder() =
        // a -> m a
        member this.Return a = Some a

        //  m a -> (a -> m b) -> m b
        member this.Bind (m, f) = match m with
                                  | Some x -> f x
                                  | _ -> None

    let option = OptionBuilder()   

Now our pattern definition will looks like this:

1
2
3
4

let (|MethodCall|_|) (expr: Expr) = option { let! (_, methodExpr)    = (|Lambdas|_|) expr 
                                             let! (_, methodInfo, _) = (|Call|_|) methodExpr
                                             return methodInfo }

Finally we can use another common structure, called “arrow”. We will use two combinators:

1
2
3
4
5

    // Lift a function to an arrow.
    let arr f = (fun x -> Some (f x))

    // Left-to-right composition
    let (>>>) f g = f >> (function | Some x -> g x | None -> None)

First – “lift” operator, used to create an arrow from the arbitrary function, second left-to-right composition, used to compose arrows (generally arrow definition contains more functions, but we don’t need them in this sample). Now we can write down pattern using just this two combinators:

1
2

    let (|MethodCall|_|) =  (|Lambdas|_|) >>> arr (fun (_, methodExpr)    -> methodExpr) 
                        >>> (|Call|_|)    >>> arr (fun (_, methodInfo, _) -> methodInfo)

Unfortunately F# does not have any syntactic sugar for arrows support, so monads might be better choice.

----

Some F# libraries with monad support: [link:sharpmalib.codeplex.com] [link:fml.codeplex.com]