Boost logo

Boost :

From: Aleksey Gurtovoy (agurtovoy_at_[hidden])
Date: 2002-11-15 07:51:50


Rozental, Gennadiy wrote:
> I am having hard time grasping how this %#$% lambda facility
> is working.

I hope you mean "what it does/how to use it" as opposite to "how it does
what it does" ;).

> Unfortunally paper does not provide enough information.
> Could you at least provide general scetch? Amoung other things I
> would like to know when I need to use _ and when _1,_2,...?

The numbered placeholders (_1, _2, ...) have the same semantics as those in
equivalent run-time libraries, Boost.Bind and Boost.Lambda. You can always
use them and forget about unnamed form (_). The only real value associated
with the latter is its visual appeal :).

The "table" below demonstrates the semantics of both forms:

    // numbered placeholders semantics
    plus<_1, int_c<5> > == bind<meta_fun2<plus>,_1,int_c<5> >
    plus< int_c<5>,_1 > == bind<meta_fun2<plus>,int_c<5>,_1 >
    plus< int_c<5>,_2 > == bind<meta_fun2<plus>,int_c<5>,_2 >
    plus<_1,_2> == bind<meta_fun2<plus>,_1,_2>
    plus<_2,_1> == bind<meta_fun2<plus>,_2,_1>
    
    logical_or< is_same<_1,int>, is_same<_1,long> >
        = bind< meta_fun2<logical_or>
            , bind< meta_fun2<is_same>,_1,int >
            , bind< meta_fun2<is_same>,_1,long >
>

    is_same< _1, add_pointer<_2> >
        == bind< meta_fun2<is_same>
            , _1
            , bind< meta_fun1<add_pointer>, _2 >
>

    // unnamed placeholder semantics
    plus< _,int_c<5> > == plus<_1, int_c<5> >
    plus< int_c<5>,_ > == plus< int_c<5>,_1 >
    ??? == plus< int_c<5>,_2 > // can't be built using unnamed notation
    plus<_,_> == plus<_1,_2>
    ??? == plus<_2,_1>

    logical_or< is_same<_,int>, is_same<_,long> >
        = logical_or< is_same<_1,int>, is_same<_1,long> >

    is_same< _, add_pointer<_> > != is_same< _1, add_pointer<_2> > // !!!
    is_same< _, add_pointer<_> >
        == bind< meta_fun2<is_same>
            , _1
            , bind< meta_fun1<add_pointer>, _1 > // !!!
>

> Could you write in a form of step by step description how
> fold-family algorithms are working?

>From the reference docs
(http://www.mywikinet.com/mpl/ref/Reference/iter_fold.html):

    Expression
    ~~~~~~~~~~

    typedef iter_fold<Sequence,T,Op>::type t;

    Semantics
    ~~~~~~~~~

    Equivalent to

    typedef lambda<Op>::type op;
    typedef begin<Sequence>::type i1;
    typedef apply<op,T,i1>::type t1;
    typedef i1::next i2;
    typedef apply<op,t1,i2>::type t2;
    ...
    typedef apply<op,T,in>::type tn;
    typedef in::next last;
    typedef tn t;

    , where n == size<Sequence>::type::value and last is identical to
end<Sequence>::type;

    Equivalent to typedef T t; if the sequence is empty.

> Also is there gen_scattered/linear_hierarchy implementation
> somewhere for MPL sequenses?

MPL's 'inherit_linearly' algorithm + 'inherit' metafunction (in the CVS now)
cover both of these. Please see
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/*checkout*/boost/boost/libs/m
pl/example/inherit_linearly.cpp and
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/*checkout*/boost/boost/libs/m
pl/example/inherit_multiply.cpp for the corresponding examples.

HTH,
Aleksey


Boost list run by bdawes at acm.org, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk