diff --git a/include/semver.h b/include/semver.h
index e740261..18a9d3c 100644
--- a/include/semver.h
+++ b/include/semver.h
@@ -3,28 +3,6 @@
 
 #define u128 __uint128_t
 
-typedef struct {
-    uint16_t major;
-} __Simple;
-
-typedef struct {
-    uint16_t major;
-    uint16_t minor;
-} __Rapid;
-
-typedef struct {
-    uint16_t major;
-    uint16_t minor;
-    uint16_t patch;
-} __SemVer;
-
-typedef struct {
-    uint16_t major;
-    uint16_t minor;
-    uint16_t patch;
-    uint16_t build;
-} __Extended;
-
 typedef enum {
     Simple,
     Rapid,
@@ -63,31 +41,39 @@ typedef enum {
 } Arch;
 
 typedef struct {
-    PreReleaseTag    pr_tag;
+    PreReleaseTag    tag;
     union {
         uint16_t     alpha;
         uint16_t     beta;
         uint16_t     rc;
-        GitRevision *git;
+        GitRevision  git;
     };
 } PreRelease;
 
 typedef struct {
-    VersionKindTag  vk_tag;
+    VersionKindTag   vk_tag;
     union {
-        __Simple    simple;
-        __Rapid     rapid;
-        __SemVer    semver;
-        __Extended  extended;
-    }               vk_data;
-    PreReleaseTag   pr_tag;
-    union {
-        uint16_t    alpha;
-        uint16_t    beta;
-        uint16_t    rc;
-        GitRevision *git;
-    } pr_data;
-    Arch arch;
+        struct {
+            uint16_t major;
+        }            simple;
+        struct {
+            uint16_t major;
+            uint16_t minor;
+        }            rapid;
+        struct {
+            uint16_t major;
+            uint16_t minor;
+            uint16_t patch;
+        }            semver;
+        struct {
+            uint16_t major;
+            uint16_t minor;
+            uint16_t patch;
+            uint16_t build;
+        }            extended;
+    };
+    PreRelease       pr;
+    Arch             arch;
 } Version;
 
 typedef enum {
diff --git a/semver.c b/semver.c
index 8023ba9..ac3ee98 100644
--- a/semver.c
+++ b/semver.c
@@ -13,46 +13,46 @@ u128 u128FromVersion(Version *self) {
 
     switch (self->vk_tag) {
         case Simple:
-            out |= ((u128)self->vk_data.simple.major << (64 + 52));
+            out |= ((u128)self->simple.major << (64 + 52));
             break;
         case Rapid:
-            major = (uint64_t)self->vk_data.rapid.major << 52;
-            minor = (uint64_t)self->vk_data.rapid.minor << 40;
+            major = (uint64_t)self->rapid.major << 52;
+            minor = (uint64_t)self->rapid.minor << 40;
             out = (u128)(major | minor) << 64;
             break;
         case SemVer:
-            major = (uint64_t)self->vk_data.semver.major << 52;
-            minor = (uint64_t)self->vk_data.semver.minor << 40;
-            patch = (uint64_t)self->vk_data.semver.patch << 28;
+            major = (uint64_t)self->semver.major << 52;
+            minor = (uint64_t)self->semver.minor << 40;
+            patch = (uint64_t)self->semver.patch << 28;
             out = (u128)(major | minor | patch) << 64;
             break;
         case Extended:
-            major = (uint64_t)self->vk_data.extended.major << 52;
-            minor = (uint64_t)self->vk_data.extended.minor << 40;
-            patch = (uint64_t)self->vk_data.extended.patch << 28;
-            build = (uint64_t)self->vk_data.extended.build << 16;
+            major = (uint64_t)self->extended.major << 52;
+            minor = (uint64_t)self->extended.minor << 40;
+            patch = (uint64_t)self->extended.patch << 28;
+            build = (uint64_t)self->extended.build << 16;
             out = (u128)(major | minor | patch | build) << 64;
             break;
     }
-    switch (self->pr_tag) {
+    switch (self->pr.tag) {
         case Alpha:
             out |= ((u128)010000 << 64);
-            pre = self->pr_data.alpha & mask;
+            pre = self->pr.alpha & mask;
             out |= ((u128)pre << 64);
             break;
         case Beta:
             out |= ((u128)020000 << 64);
-            pre = self->pr_data.beta & mask;
+            pre = self->pr.beta & mask;
             out |= ((u128)pre << 64);
             break;
         case ReleaseCandidate:
             out |= ((u128)040000 << 64);
-            pre = self->pr_data.rc & mask;
+            pre = self->pr.rc & mask;
             out |= ((u128)pre << 64);
             break;
         case GitRev:
             out |= ((u128)01000 << 64);
-            ts = dateTimeGetTimestamp(&self->pr_data.git->dt);
+            ts = dateTimeGetTimestamp(&self->pr.git.dt);
             out |= (u128)ts;
             break;
         case PRNone:
@@ -106,6 +106,11 @@ int parseArch(char *s) {
         return -1;
 }
 
+int parsePreRelease(PreRelease *pr, const char *s) {
+    // todo
+    return -1;
+}
+
 int parseVersion(Version *self, const char *s) {
     // todo
     return -1;
@@ -123,53 +128,53 @@ char *versionToString(Version *self) {
     }
     switch (self->vk_tag) {
         case Simple:
-            snprintf(buf, 6, "%d", self->vk_data.simple.major);
+            snprintf(buf, 6, "%d", self->simple.major);
             break;
         case Rapid:
-            snprintf(buf, 13, "%d.%d", self->vk_data.rapid.major, self->vk_data.rapid.minor);
+            snprintf(buf, 13, "%d.%d", self->rapid.major, self->rapid.minor);
             break;
         case SemVer:
             snprintf(
                 buf, 20, "%d.%d.%d",
-                self->vk_data.semver.major,
-                self->vk_data.semver.minor,
-                self->vk_data.semver.patch
+                self->semver.major,
+                self->semver.minor,
+                self->semver.patch
             );
             break;
         case Extended:
             snprintf(
                 buf, 27, "%d.%d.%d.%d",
-                self->vk_data.extended.major,
-                self->vk_data.extended.minor,
-                self->vk_data.extended.patch,
-                self->vk_data.extended.build
+                self->extended.major,
+                self->extended.minor,
+                self->extended.patch,
+                self->extended.build
             );
             break;
     }
-    switch (self->pr_tag) {
+    switch (self->pr.tag) {
         case PRNone:
             snprintf(temp, 9, "-%s", archToString(self->arch));
             break;
         case Alpha:
-            snprintf(temp, 25, "_alpha%d-%s", self->pr_data.alpha, archToString(self->arch));
+            snprintf(temp, 25, "_alpha%d-%s", self->pr.alpha, archToString(self->arch));
             break;
         case Beta:
-            snprintf(temp, 25, "_beta%d-%s", self->pr_data.beta, archToString(self->arch));
+            snprintf(temp, 25, "_beta%d-%s", self->pr.beta, archToString(self->arch));
             break;
         case ReleaseCandidate:
-            snprintf(temp, 25, "_rc%d-%s", self->pr_data.rc, archToString(self->arch));
+            snprintf(temp, 25, "_rc%d-%s", self->pr.rc, archToString(self->arch));
             break;
         case GitRev:
             snprintf(
                 temp, 50, "_git_%c%c%c%c%c%c%c.%li-%s",
-                self->pr_data.git->hash[0],
-                self->pr_data.git->hash[1],
-                self->pr_data.git->hash[2],
-                self->pr_data.git->hash[3],
-                self->pr_data.git->hash[4],
-                self->pr_data.git->hash[5],
-                self->pr_data.git->hash[6],
-                dateTimeGetTimestamp(&self->pr_data.git->dt),
+                self->pr.git.hash[0],
+                self->pr.git.hash[1],
+                self->pr.git.hash[2],
+                self->pr.git.hash[3],
+                self->pr.git.hash[4],
+                self->pr.git.hash[5],
+                self->pr.git.hash[6],
+                dateTimeGetTimestamp(&self->pr.git.dt),
                 archToString(self->arch)
             );
     }