| [/ |
| / Copyright (c) 2008 Eric Niebler |
| / |
| / Distributed under the Boost Software License, Version 1.0. (See accompanying |
| / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| /] |
| |
| [/===============] |
| [section Glossary] |
| [/===============] |
| |
| [def _T_ [~T]] |
| |
| [template anchor[x] '''<anchor id="boost_proto.users_guide.glossary.'''[x]'''" />'''] |
| |
| [variablelist |
| [ [ [anchor callable_transform] callable transform] |
| [A transform of the form `R(A0,A1,...)` (i.e., a function type) where |
| `proto::is_callable<R>::value` is `true`. `R` is treated as a polymorphic |
| function object and the arguments are treated as transforms that yield the |
| arguments to the function object.] ] |
| [ [ [anchor context] context] |
| [In Proto, the term /context/ refers to an object that can be passed, along |
| with an expression to evaluate, to the `proto::eval()` function. The context |
| determines how the expression is evaluated. All context structs define a |
| nested `eval<>` template that, when instantiated with a node tag type (e.g., |
| `proto::tag::plus`), is a binary polymorphic function object that accepts an |
| expression of that type and the context object. In this way, contexts |
| associate behaviors with expression nodes.] ] |
| [ [ [anchor domain] domain] |
| [In Proto, the term /domain/ refers to a type that associates expressions |
| within that domain with a /generator/ for that domain and optionally a |
| /grammar/ for the domain. Domains are used primarily to imbue expressions |
| within that domain with additional members and to restrict Proto's operator |
| overloads such that expressions not conforming to the domain's grammar are |
| never created. Domains are empty structs that inherit from |
| `proto::domain<>`.]] |
| [ [ [anchor dsel] domain-specific embedded language] |
| [A domain-specific language implemented as a library. The language in which |
| the library is written is called the "host" language, and the language |
| implemented by the library is called the "embedded" language.]] |
| [ [ [anchor dsl] domain-specific language] |
| [A programming language that targets a particular problem space by providing |
| programming idioms, abstractions and constructs that match the constructs |
| within that problem space.]] |
| [ [ [anchor expression] expression] |
| [In Proto, an /expression/ is a heterogeneous tree where each node is either |
| an instantiation of `boost::proto::expr<>`, `boost::proto::basic_expr<>` or |
| some type that is an extension (via `boost::proto::extends<>` or |
| `BOOST_PROTO_EXTENDS()`) of such an instantiation.]] |
| [ [ [anchor expression_template] expression template] |
| [A C++ technique using templates and operator overloading to cause |
| expressions to build trees that represent the expression for lazy evaluation |
| later, rather than evaluating the expression eagerly. Some C++ libraries use |
| expression templates to build domain-specific embedded languages.]] |
| [ [ [anchor generator] generator] |
| [In Proto, a /generator/ is a unary polymorphic function object that you |
| specify when defining a /domain/. After constructing a new expression, Proto |
| passes the expression to your domain's generator for further processing. |
| Often, the generator wraps the expression in an extension wrapper that adds |
| additional members to it.]] |
| [ [ [anchor grammar] grammar] |
| [In Proto, a /grammar/ is a type that describes a subset of Proto expression |
| types. Expressions in a domain must conform to that domain's grammar. The |
| `proto::matches<>` metafunction evaluates whether an expression type matches |
| a grammar. Grammars are either primitives such as `proto::_`, composites |
| such as `proto::plus<>`, control structures such as `proto::or_<>`, or some |
| type derived from a grammar.]] |
| [ [ [anchor object_transform] object transform] |
| [A transform of the form `R(A0,A1,...)` (i.e., a function type) where |
| `proto::is_callable<R>::value` is `false`. `R` is treated as the type of an |
| object to construct and the arguments are treated as transforms that yield |
| the parameters to the constructor.]] |
| [ [ [anchor polymorphic_function_object] polymorphic function object] |
| [An instance of a class type with an overloaded function call operator and a |
| nested `result_type` typedef or `result<>` template for calculating the |
| return type of the function call operator.]] |
| [ [ [anchor primitive_transform] primitive transform] |
| [A type that defines a kind of polymorphic function object that takes three |
| arguments: expression, state, and data. Primitive transforms can be used to |
| compose callable transforms and object transforms.]] |
| [ [ [anchor transform] transform] |
| [Transforms are used to manipulate expression trees. They come in three |
| flavors: primitive transforms, callable transforms, or object transforms. A |
| transform `_T_` can be made into a ternary polymorphic function object with |
| `proto::when<>`, as in `proto::when<proto::_, _T_>`. Such a function object |
| accepts /expression/, /state/, and /data/ parameters, and computes a result |
| from them.]] |
| ] |
| |
| [endsect] |