I noticed poor performance coping a structure with a bunch of optionals. The reason is the cost of checking if the optionals are set. CPU's hate branching it breaks their pipelining. if(that->a) this->a=*that->a; At the end of the day I just wrote a copy construct which does a memcpy(), since the data types were just POD. It makes me a bit nervous since my code might break with a different impl of opitonal. Then I thought hey wouldn't it be cool if defined a metafunction that specified memcpy/memmove are allowed? It looks like has_trivial_copy<> fits the bill. // Suggested code: namespace boost{ template<typename T> struct has_trivial_copy< boost::optional<T> > : has_trivial_copy<T> {}; }//namespace boost typedef boost::optional<int> OptionalInt; BOOST_STATIC_ASSERT(( has_trivial_copy<OptionalInt>::value )); //fixed thanks to code above struct SomeOptionals{ OptionalInt a,b;}; BOOST_STATIC_ASSERT(( has_trivial_copy<SomeOptionals>::value )); //fails The second test fails. It can't imagine how to make it work without some compiler magic. I wonder if a compiler could use metafunctions to know which optimizations were legal. Similar meta function specializations could be written for boost::variant and boost::fusion::map. I could imagine contains like std::vector using this to do memmove() for example. Chris