1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495 |
- [/
- / 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 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 edsl] embedded domain-specific 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 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 embedded domain-specific 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 subdomain] sub-domain]
- [A sub-domain is a domain that declares another domain as its super-domain.
- Expressions in sub-domains can be combined with expressions in the
- super-domain, and the resulting expression is in the super-domain.]]
- [ [ [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]
|