[Boost-users] Pattern-matching by metaprogramming - possible?

From: Zeljko Vrba (zvrba_at_[hidden])
Date: 2007-10-18 02:44:30

A short introduction: the ML language has a variant data type, tuples,
and pattern matching construct.  For example

type operand = Imm of int | Reg of string
type instruction = Insn of string | Pseudo of string

Now, we can create tuples, e.g. (Insn "push", Reg "%rbp") is of type
operand * instruction (a tuple of two typed elements).

In function definitions, it is possible to do pattern matching as
(it could be written slightly better in ML, but I want to show the
match syntactic construct):

let f x = match x with
        | (Insn "addq", Reg "%rsp") -> (* do something *)
        | (_, Imm x) -> (* any 1st item; the 2nd must be Imm type, and
                the x variable is bound to the value carried by the 2nd item *)
        | (_, Reg "%rsp") ->
                (* any value for 1st item _except_ Insn "addq" which has
                already been handled in the first alternative - alternatives
                are matched in order and first matching is taken *)
        | _ -> (* default case for anything else *)

This is only a simplified example; but even this example would
be much more ugly if rewritten with if/else statements, even if
tuple tiers were used.  Boost provides both the safe variant
type and the tuple type.  Would it be possible to construct
pattern matching with syntax similar to the above in C++ ?

[Yes, there are also other problems - incomplete matches: ML
just throws an exception in that case; or redundant cases -
nothing happens.]