Definition of the proto::make_expr()
and proto::unpack_expr()
utilities for building Proto expression nodes from child nodes or from a Fusion sequence of child
nodes, respectively.
proto::deduce_domain
A PolymorphicFunctionObject equivalent to the
proto::make_expr() function.
In all cases, proto::functional::make_expr<Tag, Domain>()(a...)
is equivalent to proto::make_expr<Tag, Domain>(a...).
proto::functional::make_expr<Tag>()(a...) is equivalent to
proto::make_expr<Tag>(a...).
proto::callable
This(A...)
proto::result_of::make_expr< Tag, Domain, A... >
typename proto::result_of::make_expr< Tag, Domain, A const... >::type const
A const &
Construct an expression node with tag type Tag and in the
domain Domain.
proto::make_expr<Tag, Domain>(a...)
proto::deduce_domain
A PolymorphicFunctionObject equivalent to the
proto::unpack_expr() function.
In all cases, proto::functional::unpack_expr<Tag, Domain>()(seq) is
equivalent to proto::unpack_expr()<Tag,
Domain>(seq).
proto::functional::unpack_expr<Tag>()(seq) is equivalent to
proto::unpack_expr()<Tag>(seq).
proto::callable
This(Sequence)
proto::result_of::unpack_expr<
Tag,
Domain,
typename boost::remove_reference< Sequence >::type
>
typename proto::result_of::unpack_expr< Tag, Domain, Sequence const >::type const
Sequence const &
A Fusion Forward Sequence
Construct an expression node with tag type Tag and in the
domain Domain.
proto::unpack_expr<Tag, Domain>(sequence)
Metafunction that computes the return type of the
proto::make_expr()
function, with a domain deduced from the domains of the children.
Computes the return type of the
proto::make_expr() function.
In this specialization, the domain is deduced from the domains of the child types.
If proto::is_domain<A0>::value
is true, then another specialization is selected.
For exposition only
domain-deduced-from-child-types
In this specialization, Proto uses the domains of the child expressions to compute the
domain of the parent. See
proto::deduce_domain for a full
description of the procedure used.
typename proto::result_of::make_expr<Tag, D, A...>::type
Tag
Domain
A
Metafunction that computes the return type of the
proto::make_expr()
function, within the specified domain.
Computes the return type of the
proto::make_expr()
function.
Let WRAP<X> be defined such that:
If X is Y &
or (possibly cv-qualified) boost::reference_wrapper<Y>,
then WRAP<X> is equivalent to
proto::result_of::as_child<Y, Domain>.
Otherwise, WRAP<X> is equivalent to
proto::result_of::as_expr<X, Domain>.
If proto::wants_basic_expr<typename Domain::proto_generator>::value
is true, then let E be
proto::basic_expr; otherwise,
let E be
proto::expr.
If Tag is
proto::tag::terminal, then
type is a typedef for
typename WRAP<A0>::type.
Otherwise, type is a typedef for
boost::result_of<Domain(E<
Tag, proto::listN<
typename WRAP<A>::type...> >)>::type
see-below
void
Metafunction that computes the return type of the
proto::unpack_expr()
function, with a domain deduced from the domains of the children.
Compute the return type of the
proto::unpack_expr()
function.
Sequence is a Fusion Forward Sequence.
In this specialization, the domain is deduced from the domains of the child types.
If proto::is_domain<Sequence>::value
is true, then another specialization is selected.
Where S is a Fusion RandomAccessSequence equivalent to Sequence, and N is the size of S.
typename proto::result_of::make_expr<
Tag,
typename fusion::result_of::value_at_c<S, 0>::type,
...
typename fusion::result_of::value_at_c<S, N-1>::type
>::type
Tag
Domain
Sequence
Metafunction that computes the return type of the
proto::unpack_expr()
function, within the specified domain.
Computes the return type of the
proto::unpack_expr()
function.
Where S is a RandomAccessSequence equivalent to Sequence, and N is the size of S.
typename proto::result_of::make_expr<
Tag,
Domain,
typename fusion::result_of::value_at_c<S, 0>::type,
...
typename fusion::result_of::value_at_c<S, N-1>::type
>::type
typename proto::result_of::make_expr<Tag, A const...>::type const
A const &
typename proto::result_of::make_expr<Tag, Domain, A const...>::type const
A const &
Construct an expression of the requested tag type with a domain and with the specified
arguments as children.
This function template may be invoked either with or without specifying a
Domain template parameter. If no domain is specified, the domain
is deduced by examining domains of the given arguments. See
proto::deduce_domain for a full
description of the procedure used.
Let WRAP(x) be defined such that:
If x is a boost::reference_wrapper<>,
WRAP(x) is equivalent to
proto::as_child<Domain>(x.get()).
Otherwise, WRAP(x) is equivalent to
proto::as_expr<Domain>(x).
If proto::wants_basic_expr<typename Domain::proto_generator>::value
is true, then let E be
proto::basic_expr; otherwise,
let E be
proto::expr.
Let MAKE(Tag, b...) be defined as
E<Tag,
proto::listN<decltype(b)...> >::make(b...).
If Tag is
proto::tag::terminal, then return
WRAP(a0).
Otherwise, return
Domain()(MAKE(Tag, WRAP(a)...)).
typename proto::result_of::unpack_expr<Tag, Sequence const>::type const
Sequence const &
A Fusion Forward Sequence.
typename proto::result_of::unpack_expr<Tag, Domain, Sequence const>::type const
Sequence const &
Construct an expression of the requested tag type with a domain and with children
from the specified Fusion Forward Sequence.
This function template may be invoked either with or without specifying a
Domain argument. If no domain is specified, the domain
is deduced by examining domains of each element of the sequence. See
proto::deduce_domain for a full
description of the procedure used.
Let s be a Fusion RandomAccessSequence equivalent to
sequence.
Let WRAP(N, s) be defined such that:
If fusion::result_of::value_at_c<decltype(s),N>::type is a reference type
or an instantiation of boost::reference_wrapper<>,
WRAP(N, s) is equivalent to
proto::as_child<Domain>(fusion::at_c<N>(s)).
Otherwise, WRAP(N, s) is equivalent to
proto::as_expr<Domain>(fusion::at_c<N>(s)).
If proto::wants_basic_expr<typename Domain::proto_generator>::value
is true, then let E be
proto::basic_expr; otherwise,
let E be
proto::expr.
Let MAKE(Tag, b...) be defined as
E<Tag,
proto::listN<decltype(b)...> >::make(b...).
If Tag is
proto::tag::terminal, then return
WRAP(0, s).
Otherwise, return
Domain()(MAKE(Tag, WRAP(0, s),...
WRAP(N-1, s))), where
N is the size of Sequence.