| Home | Libraries | People | FAQ | More

## Struct template matches

boost::proto::matches — A Boolean metafunction that evaluates whether a given expression type matches a grammar.

## Synopsis

    // In header: <boost/proto/matches.hpp>

    template<typename Expr, typename Grammar>
    struct matches :  mpl::bool_<true-or-false> {
    };

## Description

`proto::matches<Expr, Grammar>` inherits from `mpl::true_` if `Expr::proto_grammar` matches `Grammar::proto_grammar`, and from `mpl::false_` otherwise.

Non-terminal expressions are matched against a grammar according to the following rules:

- The wildcard pattern, `proto::_` , matches any expression.

- An expression `proto::basic_expr<AT, proto::listN <A0,...An> >` matches a grammar `proto::basic_expr<BT, proto::listN <B0,...Bn> >` if `BT` is `proto::_` or `AT`, and if `Ax` matches `Bx` for each `x` in `[0,n]`.

- An expression `proto::basic_expr<AT, proto::listN <A0,...An,U0,...Um> >` matches a grammar `proto::basic_expr<BT, proto::listM <B0,...Bn,proto::vararg<V> > >` if `BT` is `proto::_` or `AT`, and if `Ax` matches `Bx` for each `x` in `[0,n]` and if `Ux` matches `V` for each `x` in `[0,m]`.

- An expression `E` matches `proto::or_<B0,...Bn>` if `E` matches some `Bx` for `x` in `[0,n]`.

- An expression `E` matches `proto::and_<B0,...Bn>` if `E` matches all `Bx` for `x` in `[0,n]`.

- An expression `E` matches `proto::if_<T,U,V>` if:

  - `boost::result_of<proto::when<proto::_,T>(E)>::type::value` is `true` and `E` matches `U`, or
  - `boost::result_of<proto::when<proto::_,T>(E)>::type::value` is `false` and `E` matches `V`.

  Note: `U` defaults to `proto::_` and `V` defaults to `proto::not_<proto::_>` .

- An expression `E` matches `proto::not_<T>` if `E` does not match `T`.

- An expression `E` matches `proto::switch_<C, T>` if `E` matches `C::case_<boost::result_of<proto::when<proto::_,T>(E)>::type>`. Note: `T` defaults to `proto::tag_of<proto::_>()`

A terminal expression can trivially match the grammar proto::_. In addition, a terminal expression `proto::basic_expr<AT, proto::term<A> >` matches a grammar `proto::basic_expr<BT, proto::term<B> >` if `BT` is `proto::_` or `AT` and one of the following is true:

- `B` is the wildcard pattern, `proto::_`

- `A` is `B`

- `A` is `B &`

- `A` is `B const &`

- `B` is `proto::exact<A>`

- `B` is `proto::convertible_to<X>` and `boost::is_convertible<A,X>::value` is `true`.

- `A` is `X[M]` or `X(&)[M]` and `B` is `X[proto::N]` .

- `A` is `X(&)[M]` and `B` is `X(&)[proto::N]` .

- `A` is `X[M]` or `X(&)[M]` and `B` is `X*`.

- `B` `lambda-matches` `A` (see below).

A type `B` `lambda-matches` `A` if one of the following is true:

- `B` is `A`

- `B` is the wildcard pattern, `proto::_`

- `B` is `T<B0,...Bn>` and `A` is `T<A0,...An>` and for each `x` in `[0,n]`, `Ax` and `Bx` are types such that `Ax` `lambda-matches` `Bx`