Rick Minerich's Development Wonderland

First, thanks for linking to my post, I appreciate it :)

Second, I want to make a quick comment on this: "In this context, it may be desirable for the consumer of the API to be able to extend the process involved in dispatch to handle new cases.  A single F# match function makes this quite difficult as it can’t be easily extended."

You *can* have more than one match function per union in an entire API. My post actually demonstrates three matching functions:

(* first function *)

let rec eval = function  

   | True          -> true  

   | And(e1, e2)   -> eval(e1) && eval(e2)  

   | Nand(e1, e2)  -> not(eval(e1) && eval(e2))  

   | Or(e1, e2)    -> eval(e1) || eval(e2)  

   | Xor(e1, e2)   -> eval(e1) ^^ eval(e2)  

   | Not(e1)       -> not(eval(e1))

(* second function *)

let rec prettyPrint e =  

   let rec loop = function  

       | True          -> "True"  

       | And(e1, e2)   -> sprintf "(%s) AND (%s)" (loop e1) (loop e2)  

       | Nand(e1, e2)  -> sprintf "(%s) NAND (%s)" (loop e1) (loop e2)  

       | Or(e1, e2)    -> sprintf "(%s) OR (%s)" (loop e1) (loop e2)  

       | Xor(e1, e2)   -> sprintf "(%s) XOR (%s)" (loop e1) (loop e2)  

       | Not(e1)       -> sprintf "NOT (%s)" (loop e1)  

   (loop e).Replace("(True)", "True")  

(* third function *)

let rec simplify = function  

   | True          -> True  

   | And(p, q)     -> And(simplify p, simplify q)  

   | Or(p, q)      -> Or(simplify p, simplify q)  

   | Xor(p, q)     -> Xor(simplify p, simplify q)  

   | Not(Not p)    -> simplify p  

   | Not(p)        -> Not(simplify p)  

   | Nand(p, q) when p = q -> Not(simplify p)  

   | Nand(Nand(p1, q1), Nand(p2, q2))  

       when equivalent [p1; p2] && equivalent [q1; q2]  

                   -> And(simplify p1, simplify q1)  

   | Nand(Nand(p1, p2), Nand(q1, q2))  

       when equivalent [p1; p2] && equivalent [q1; q2]  

                   -> Or(simplify p1, simplify q1)  

   | Nand(Nand(p1, Nand(p2, q1)), Nand(q2, Nand(p3, q3)))  

       when equivalent [p1; p2; p3] && equivalent [q1; q2; q3]  

                   -> Xor(simplify p1, simplify q1)  

   | Nand(p, q) -> Nand(simplify p, simplify q)  

Once I've compiled my API, any client could trivially add their own matching function based on their needs. For example, lets say they wanted to map all And's to Or's, they'd probably write something like this:

let rec map = function  

   | True                      -> True  

   | And(e1, e2) | Or(e1, e2)  -> Or(map e1, map e2)

   | Nand(e1, e2)              -> Nand(map e1, map e2)

   | Xor(e1, e2)               -> Xor(map e1, map e2)

   | Not(e1)                   -> Not(map e1)

Nothing in principle prevents a client of an F# API from adding as many match cases as they need.

Hello. I think the article is really interesting. I am even interested in reading more. How soon will you update your blog?