struct Foo {
  int a;
  float b;
  struct Bar {
    float x;
    char y;
  } c;
};

ahso::arrays
    storage_direct;

ahso::recursive_arrays
   
     storage_recursive;
   
  

// for storage_direct: 
std::tuple
   <
   int>, std::vector<
   float>, std::vector
   
    >


    // for storage_recursive: 
std::tuple
    
     <
     int>, std::vector<
     float>, std::vector<
     float>, std::vector<
     char>> 
    
   
  

(index).position.x = 2; // Or if the proper type is provided (until we get metaclasses, see example): e[index].physics.position.x = 2; // Remove an entity e.erase(index); } ">

struct vec3 { float x,y,z; };
struct color { float r,g,b,a; };
struct physics_component {
  vec3 position;
  vec3 speed;
  vec3 acceleration;
};

struct render_component {
  color col;
};

struct entity {
  physics_component physics;
  render_component render;
}

int main()
{
  // Define our storage
  ahso::arrays
    e;

  
   // Preallocate some space like you would with std::vector
  e.
   reserve(
   1000);

  
   // Add a new entity
  
   auto 
   index = e.
   add_entity({
    .
   physics {
      .
   position { 
   0., 
   0., 
   0. }
    , .
   acceleration { 
   1., 
   0., 
   0. }
    },
    .
   render {
      .
   col { 
   0., 
   1., 
   0., 
   1. }
    }
  });

  
   // Access a specific component for entity "index"
  e.
   get
   
    (
    index).
    position.
    x = 
    2;
  
  
    // Or if the proper type is provided (until we get metaclasses, see example): 
  e[
    index].
    physics.
    position.
    x = 
    2;

  
    // Remove an entity
  e.
    erase(
    index);
}