Re: [boost] [local_function] any interest in a LocalFunction library?

Subject: Re: [boost] [local_function] any interest in a LocalFunction library?
From: Lorenzo Caminiti (lorcaminiti_at_[hidden])
Date: 2010-08-24 09:32:13

On Mon, Aug 23, 2010 at 10:05 AM, Mathias Gaunard
<mathias.gaunard_at_[hidden]> wrote:
> On 23/08/10 13:43, Dmitry Goncharov wrote:
>
>> What's wrong with the following?
>> Aside from the know limitations. (local::f cannot be a template arg or be
>> a function template).
>> void f()
>> {
>>        struct local
>>        {
>>                static void f() {}
>>        };
>>        local::f();
>> }
>>
>> Does your library have advantages over this?
>
> I believe his macro has mechanisms for catching some variables in scope (at
> least, ScopeExit had).
>
> Something you would do with
>
> struct local
> {
>    local(int j_) : j(j_) {}
>
>    int operator()(int i)
>    {
>        return i + j;
>    }
>
> private:
>    int j;
> };
> local f(j);
>
> could be written as something like
>
> LOCAL_FUNCTION_BEGIN(f, (j), (int i))
> {
>   return i + j;
> }
> LOCAL_FUNCTION_END
>
> Surely you would agree the second form is quite more succint

That is correct: The advantage of Boost.LocalFunction over simply
using a static member of a local class is that Boost.LocalFunction
supports binding of variables in scope (similarly to what
Boost.ScopeExit does).

In addition, note how the binding of `j` in the example above does not
require you to specify its type (the example above just assumes `j` is
`int` but Boost.LocalFunction, as well as Boost.ScopeExit, can
automatically determine the type using typeof-like features). That is
important because you might want to simply say "I am using the
variable in scope `j` in my local function" without worrying about
specifying its type. This type might change later and if it were
specified explicitly also in the local function declaration it would
require to change the code in multiple places making maintainance
harder.

Finally, note that the binding can be done by value (in which case the
local function will use a copy of the binded variable with its value
at the point of the local function declaration), or by reference (in
which case the local function will use the current binded variable
value at the point of the local function invocation), or by const
value, or by const reference.

-- 
Lorenzo