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_base_expr matches Grammar::proto_base_expr, 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::expr<AT, proto::listN <A₀,...A_n> > matches a grammar proto::expr<BT, proto::listN <B₀,...B_n> > if BT is proto::_ or AT, and if A_x matches B_x for each x in [0,n].
An expression proto::expr<AT, proto::listN <A₀,...A_n,U₀,...U_m> > matches a grammar proto::expr<BT, proto::listM <B₀,...B_n,proto::vararg<V> > > if BT is proto::_ or AT, and if A_x matches B_x for each x in [0,n] and if U_x matches V for each x in [0,m].
An expression E matches proto::or_<B₀,...B_n> if E matches some B_x for x in [0,n].
An expression E matches proto::and_<B₀,...B_n> if E matches all B_x 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> if E matches C::case_<E::proto_tag>.

A terminal expression proto::expr<AT, proto::term<A> > matches a grammar proto::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<B₀,...B_n> and A is T<A₀,...A_n> and for each x in [0,n], A_x and B_x are types such that A_x lambda-matches B_x