The allocating Java thread requests a thread-local area (TLA) from the nursery (generational garbage collector) or from the heap (single-generational garbage collector) for allocation of these objects. The TLA is reserved from the heap or the nursery and given to the thread for exclusive use. This allows the thread to allocate small objects in its own TLA without taking any kind of lock. When the TLA gets full the thread simply requests a new TLA.

a thread will try to allocate the object in the currently held TLA. It puts the object at the beginning of the free space in the TLA and moves the free space pointer forward to the end of the object.

In sum, var(x) creates a nullary lambda functor, which stores a reference to the variable x. When the lambda functor is invoked, a reference to x is returned.

var(obj).Prop1.Prop2

var(obj.Prop1).Prop2

mapM_ (return.length.words) $ replicate 1000000 "123 345 asdf 23453 asdfas"

_1 ->* &B::foo
bind(&A::data, _1)

_.foo
_.data

obj => obj.Prop1.Prop2.Prop3

V>Понял, в чем прикол?

int index = 0; 
for_each(a.end(), a.end(), cout << ++index << ':' << _1 << '\n');

     private static int test() {
         int answer = 0;
         for (int i = 0; i < 1000000; i++) {
             answer+=StringUtils.split("123 345 asdf 23453 asdfas", " 
").length;
         }
         return answer;
     }

V>>var(obj).Prop1.Prop2
V>>

NB>так юзать не получится

template<typename T>
var_type<T&>::type lvar(T& obj) { return obj; }

V>>>var(obj).Prop1.Prop2
V>>>

NB>>так юзать не получится

V>template<typename T>
V>var_type<T&>::type lvar(T& obj) { return obj; }
V>

bind(&A::Prop1, _1);