Thus if you have a type in there that aligns to 12 bytes, variant
requires another 12 bytes just for the type discriminator!

is to preserve the 12 byte alignment for the oddly aligned type when the
variant is put into an array. By storing the type discriminant in the
1st 12 bytes of the containing structure, then when the containing structure
is put into a 2 element array, the 2nd array element will have the properly
aligned oddly aligned type. Now I suppose you could avoid this restriction
if you’re sure never to put utree into an array.

IOW, the following code:

#include
#include
#include 

#include 

struct x { void* a; void* b; void* c; };

struct x_union
{
      union
      { x u_x
      ; int u_int
      ; double u_dbl
      ;}
    storage
    ;
      char
    tag
    ;
};
struct x_oneof
: boost::composite_tagged_seq
  < boost::composite_tags::one_of_maybe
  , boost::mpl::integral_c
  , boost::mpl::list

  >
{
};

int main(void)
{
    std::cout<<"sizeof(x)="<<sizeof(x)<<"\n";
    std::cout<<"sizeof(x_union)="<<sizeof(x_union)<<"\n";
    std::cout<<"sizeof(x_oneof)="<<sizeof(x_oneof)<<"\n";
    return 0;
}

produces:

sizeof(x)=24
sizeof(x_union)=32
sizeof(x_oneof)=32

http://boost-spirit.com/dl_more/scheme/scheme_v0.1/detail/utree_detail1.hpp