The family of lazy components
allows to use a dynamically returned generator component for output generation.
It calls the provided function or function object at generate time using
its return value as the actual generator to produce the output.

A function or function object that evaluates to a generator object
(an object exposing the Generator). This function
will be invoked at generate time.

The signature of fg is
expected to be

Gf(Unused,Context)

where G, the function's
return value, is the type of the generator to be invoked, and Context is the generator's Context
type (The first argument is unused
to make the Context the
second argument. This is done for uniformity with Semantic
Actions).

Semantics of an expression is defined only where it differs from, or
is not defined in Generator.

Expression

Semantics

fg

The Boost.Phoenix
function object fg
will be invoked at generate time. It is expected to return
a generator instance. This generator is then invoked in order
to generate the output. This generator will succeed as long
as the invoked generated succeeds as well (unless the underlying
output stream reports an error).

lazy(fg)

The function or function object will be invoked at generate
time. It is expected to return a generator instance (note this
version of lazy
does not require fg
to be a Boost.Phoenix
function object). This generator is then invoked in order to
generate the output. This generator will succeed as long as
the invoked generated succeeds as well (except if the underlying
output stream reports an error).