diff --git a/lib/parse.c b/lib/parse.c
index 70ad371..24e53b2 100644
--- a/lib/parse.c
+++ b/lib/parse.c
@@ -136,7 +136,7 @@ static int parse_term(const char *input, int rem, parse_term_t *out)
 			++used;
 			break;
 		case '?':
-			out->quantifier = PARSE_QUANTIFIER_QMRK;
+			out->quantifier = PARSE_QUANTIFIER_QMARK;
 			++used;
 			break;
 		default:
@@ -153,14 +153,14 @@ static int parse_sequence(const char *input, int rem, parse_sequence_t *out)
 {
 	int result, used = 0;
 
-	out->len = 0;
+	out->count = 0;
 	out->capacity = SEQUENCE_START_CAPACITY;
 	out->contents = malloc(out->capacity * sizeof(parse_term_t));
 	if (NULL == out->contents)
 		return -1;
 
 	while (used < rem) {
-		if (out->len >= out->capacity) {
+		if (out->count >= out->capacity) {
 			out->capacity *= 2;
 			out->contents = realloc(
 			    out->contents, out->capacity * sizeof(parse_term_t));
@@ -169,14 +169,14 @@ static int parse_sequence(const char *input, int rem, parse_sequence_t *out)
 		}
 
 		result
-		    = parse_term(input + used, rem - used, &out->contents[out->len]);
+		    = parse_term(input + used, rem - used, &out->contents[out->count]);
 		if (result < 0)
 			break;
-		++out->len;
+		++out->count;
 		used += result;
 	}
 
-	return out->len > 0 ? used : -1;
+	return out->count > 0 ? used : -1;
 }
 
 int parse_expr(const char *input, int rem, parse_tree_t *out)
@@ -185,11 +185,11 @@ int parse_expr(const char *input, int rem, parse_tree_t *out)
 
 	out->count = 0;
 	out->capacity = TREE_START_CAPACITY;
-	out->alternatives = malloc(out->capacity * sizeof(parse_sequence_t));
-	if (NULL == out->alternatives)
+	out->contents = malloc(out->capacity * sizeof(parse_sequence_t));
+	if (NULL == out->contents)
 		return -1;
 
-	result = parse_sequence(input + used, rem - used, &out->alternatives[0]);
+	result = parse_sequence(input + used, rem - used, &out->contents[0]);
 	if (result < 0)
 		return -1;
 	++out->count;
@@ -202,14 +202,14 @@ int parse_expr(const char *input, int rem, parse_tree_t *out)
 
 		if (out->count >= out->capacity) {
 			out->capacity *= 2;
-			out->alternatives = realloc(
-			    out->alternatives, out->capacity * sizeof(parse_sequence_t));
-			if (NULL == out->alternatives)
+			out->contents = realloc(
+			    out->contents, out->capacity * sizeof(parse_sequence_t));
+			if (NULL == out->contents)
 				return -1;
 		}
 
 		result = parse_sequence(
-		    input + used, rem - used, &out->alternatives[out->count]);
+		    input + used, rem - used, &out->contents[out->count]);
 		if (result < 0)
 			break;
 		++out->count;
@@ -221,17 +221,17 @@ int parse_expr(const char *input, int rem, parse_tree_t *out)
 
 void parse_free_tree_children(const parse_tree_t *t)
 {
-	if (NULL != t->alternatives) {
+	if (NULL != t->contents) {
 		for (int i = 0; i < t->count; ++i)
-			parse_free_sequence_children(&t->alternatives[i]);
-		free(t->alternatives);
+			parse_free_sequence_children(&t->contents[i]);
+		free(t->contents);
 	}
 }
 
 void parse_free_sequence_children(const parse_sequence_t *s)
 {
 	if (NULL != s->contents) {
-		for (int i = 0; i < s->len; ++i) {
+		for (int i = 0; i < s->count; ++i) {
 			switch (s->contents[i].type) {
 			case PARSE_TERM_CLASS:
 				parse_free_class_children(&s->contents[i].class);
diff --git a/lib/parse.h b/lib/parse.h
index 41acc22..a35b191 100644
--- a/lib/parse.h
+++ b/lib/parse.h
@@ -18,7 +18,7 @@ typedef enum {
 	PARSE_QUANTIFIER_NONE,
 	PARSE_QUANTIFIER_STAR,
 	PARSE_QUANTIFIER_PLUS,
-	PARSE_QUANTIFIER_QMRK,
+	PARSE_QUANTIFIER_QMARK,
 } parse_quantifier_t;
 
 typedef enum {
@@ -31,13 +31,13 @@ typedef enum {
 
 struct _parse_term;
 typedef struct {
-	int len, capacity;
+	int count, capacity;
 	struct _parse_term *contents;
 } parse_sequence_t;
 
 typedef struct {
 	int count, capacity;
-	parse_sequence_t *alternatives;
+	parse_sequence_t *contents;
 } parse_tree_t;
 
 typedef struct _parse_term {
diff --git a/tests/desugar_tests.c b/tests/desugar_tests.c
index b5866de..6119fa9 100644
--- a/tests/desugar_tests.c
+++ b/tests/desugar_tests.c
@@ -15,20 +15,18 @@ static void a_is_unchanged(void)
 	terms[0].type = PARSE_TERM_LITERAL;
 	terms[0].literal = 'a';
 	parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t));
-	alternatives[0].len = alternatives[0].capacity = 1;
+	alternatives[0].count = alternatives[0].capacity = 1;
 	alternatives[0].contents = terms;
-	parse_tree_t t
-	    = { .count = 1, .capacity = 1, .alternatives = alternatives };
+	parse_tree_t t = { .count = 1, .capacity = 1, .contents = alternatives };
 
 	desugar_regex(&t);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
-	ASSERT_EQ(1, t.alternatives[0].len);
-	ASSERT_NOT_NULL(t.alternatives[0].contents);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[0].contents[0].type);
-	ASSERT_EQ('a', t.alternatives[0].contents[0].literal);
+	ASSERT_NOT_NULL(t.contents);
+	ASSERT_EQ(1, t.contents[0].count);
+	ASSERT_NOT_NULL(t.contents[0].contents);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type);
+	ASSERT_EQ('a', t.contents[0].contents[0].literal);
 
 	parse_free_tree_children(&t);
 }
@@ -43,24 +41,23 @@ static void abc_is_unchanged(void)
 	terms[2].type = PARSE_TERM_LITERAL;
 	terms[2].literal = 'c';
 	parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t));
-	alternatives[0].len = alternatives[0].capacity = 3;
+	alternatives[0].count = alternatives[0].capacity = 3;
 	alternatives[0].contents = terms;
-	parse_tree_t t
-	    = { .count = 1, .capacity = 1, .alternatives = alternatives };
+	parse_tree_t t = { .count = 1, .capacity = 1, .contents = alternatives };
 
 	desugar_regex(&t);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
-	ASSERT_EQ(3, t.alternatives[0].len);
-	ASSERT_NOT_NULL(t.alternatives[0].contents);
-	ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[0].contents[0].type);
-	ASSERT_EQ('a', t.alternatives[0].contents[0].literal);
-	ASSERT_NOT_NULL(t.alternatives[0].contents);
-	ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[0].contents[1].type);
-	ASSERT_EQ('b', t.alternatives[0].contents[1].literal);
-	ASSERT_NOT_NULL(t.alternatives[0].contents);
-	ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[0].contents[2].type);
-	ASSERT_EQ('c', t.alternatives[0].contents[2].literal);
+	ASSERT_NOT_NULL(t.contents);
+	ASSERT_EQ(3, t.contents[0].count);
+	ASSERT_NOT_NULL(t.contents[0].contents);
+	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type);
+	ASSERT_EQ('a', t.contents[0].contents[0].literal);
+	ASSERT_NOT_NULL(t.contents[0].contents);
+	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[1].type);
+	ASSERT_EQ('b', t.contents[0].contents[1].literal);
+	ASSERT_NOT_NULL(t.contents[0].contents);
+	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[2].type);
+	ASSERT_EQ('c', t.contents[0].contents[2].literal);
 
 	parse_free_tree_children(&t);
 }
@@ -72,20 +69,18 @@ static void a_star_is_unchanged(void)
 	terms[0].type = PARSE_TERM_LITERAL;
 	terms[0].literal = 'a';
 	parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t));
-	alternatives[0].len = alternatives[0].capacity = 1;
+	alternatives[0].count = alternatives[0].capacity = 1;
 	alternatives[0].contents = terms;
-	parse_tree_t t
-	    = { .count = 1, .capacity = 1, .alternatives = alternatives };
+	parse_tree_t t = { .count = 1, .capacity = 1, .contents = alternatives };
 
 	desugar_regex(&t);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
-	ASSERT_EQ(1, t.alternatives[0].len);
-	ASSERT_NOT_NULL(t.alternatives[0].contents);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_STAR, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[0].contents[0].type);
-	ASSERT_EQ('a', t.alternatives[0].contents[0].literal);
+	ASSERT_NOT_NULL(t.contents);
+	ASSERT_EQ(1, t.contents[0].count);
+	ASSERT_NOT_NULL(t.contents[0].contents);
+	ASSERT_EQ(PARSE_QUANTIFIER_STAR, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type);
+	ASSERT_EQ('a', t.contents[0].contents[0].literal);
 
 	parse_free_tree_children(&t);
 }
@@ -100,22 +95,21 @@ static void a_or_b_or_c_is_unchanged(void)
 		terms[0].type = PARSE_TERM_LITERAL;
 		terms[0].literal = literals[i];
 
-		alternatives[i].len = alternatives[i].capacity = 1;
+		alternatives[i].count = alternatives[i].capacity = 1;
 		alternatives[i].contents = terms;
 	}
-	parse_tree_t t
-	    = { .count = 3, .capacity = 3, .alternatives = alternatives };
+	parse_tree_t t = { .count = 3, .capacity = 3, .contents = alternatives };
 
 	desugar_regex(&t);
 	ASSERT_EQ(3, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 	for (int i = 0; i < 3; ++i) {
-		ASSERT_EQ(1, t.alternatives[i].len);
-		ASSERT_NOT_NULL(t.alternatives[i].contents);
+		ASSERT_EQ(1, t.contents[i].count);
+		ASSERT_NOT_NULL(t.contents[i].contents);
 		ASSERT_EQ(
-		    PARSE_QUANTIFIER_NONE, t.alternatives[i].contents[0].quantifier);
-		ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[i].contents[0].type);
-		ASSERT_EQ(literals[i], t.alternatives[i].contents[0].literal);
+		    PARSE_QUANTIFIER_NONE, t.contents[i].contents[0].quantifier);
+		ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[i].contents[0].type);
+		ASSERT_EQ(literals[i], t.contents[i].contents[0].literal);
 	}
 
 	parse_free_tree_children(&t);
@@ -129,18 +123,17 @@ static void subexpr_a_is_unchanged(void)
 	inner_terms[0].literal = 'a';
 	parse_sequence_t *inner_alternatives
 	    = malloc(1 * sizeof(parse_sequence_t));
-	inner_alternatives[0].len = inner_alternatives[0].capacity = 1;
+	inner_alternatives[0].count = inner_alternatives[0].capacity = 1;
 	inner_alternatives[0].contents = inner_terms;
 	parse_term_t *terms = malloc(1 * sizeof(parse_term_t));
 	terms[0].quantifier = PARSE_QUANTIFIER_NONE;
 	terms[0].type = PARSE_TERM_SUBEXPR;
 	terms[0].subexpr.count = terms[0].subexpr.capacity = 1;
-	terms[0].subexpr.alternatives = inner_alternatives;
+	terms[0].subexpr.contents = inner_alternatives;
 	parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t));
-	alternatives[0].len = alternatives[0].capacity = 1;
+	alternatives[0].count = alternatives[0].capacity = 1;
 	alternatives[0].contents = terms;
-	parse_tree_t t
-	    = { .count = 1, .capacity = 1, .alternatives = alternatives };
+	parse_tree_t t = { .count = 1, .capacity = 1, .contents = alternatives };
 
 	desugar_regex(&t);
 
diff --git a/tests/parse_tests.c b/tests/parse_tests.c
index 528a9a1..b0f5d8c 100644
--- a/tests/parse_tests.c
+++ b/tests/parse_tests.c
@@ -41,13 +41,12 @@ static void a_is_parsed_as_unquantified_literal(void)
 	const int result = PARSE_EXPR_STRING("a", &t);
 	ASSERT_NE(-1, result);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 
-	ASSERT_EQ(1, t.alternatives[0].len);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[0].contents[0].type);
-	ASSERT_EQ('a', t.alternatives[0].contents[0].literal);
+	ASSERT_EQ(1, t.contents[0].count);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type);
+	ASSERT_EQ('a', t.contents[0].contents[0].literal);
 
 	parse_free_tree_children(&t);
 }
@@ -58,13 +57,12 @@ static void b_is_parsed_as_unquantified_literal(void)
 	const int result = PARSE_EXPR_STRING("b", &t);
 	ASSERT_NE(-1, result);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 
-	ASSERT_EQ(1, t.alternatives[0].len);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[0].contents[0].type);
-	ASSERT_EQ('b', t.alternatives[0].contents[0].literal);
+	ASSERT_EQ(1, t.contents[0].count);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type);
+	ASSERT_EQ('b', t.contents[0].contents[0].literal);
 
 	parse_free_tree_children(&t);
 }
@@ -75,21 +73,18 @@ static void abc_is_parsed_as_sequence_of_unquantified_literals(void)
 	const int result = PARSE_EXPR_STRING("abc", &t);
 	ASSERT_NE(-1, result);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 
-	ASSERT_EQ(3, t.alternatives[0].len);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[0].contents[0].type);
-	ASSERT_EQ('a', t.alternatives[0].contents[0].literal);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[1].quantifier);
-	ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[0].contents[1].type);
-	ASSERT_EQ('b', t.alternatives[0].contents[1].literal);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[2].quantifier);
-	ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[0].contents[2].type);
-	ASSERT_EQ('c', t.alternatives[0].contents[2].literal);
+	ASSERT_EQ(3, t.contents[0].count);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type);
+	ASSERT_EQ('a', t.contents[0].contents[0].literal);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[1].quantifier);
+	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[1].type);
+	ASSERT_EQ('b', t.contents[0].contents[1].literal);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[2].quantifier);
+	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[2].type);
+	ASSERT_EQ('c', t.contents[0].contents[2].literal);
 
 	parse_free_tree_children(&t);
 }
@@ -100,12 +95,11 @@ static void dot_is_parsed_as_unquantified_wildcard_term(void)
 	const int result = PARSE_EXPR_STRING(".", &t);
 	ASSERT_NE(-1, result);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 
-	ASSERT_EQ(1, t.alternatives[0].len);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_WILDCARD, t.alternatives[0].contents[0].type);
+	ASSERT_EQ(1, t.contents[0].count);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_WILDCARD, t.contents[0].contents[0].type);
 
 	parse_free_tree_children(&t);
 }
@@ -116,13 +110,12 @@ static void backslash_dot_is_parsed_as_unquantified_literal(void)
 	const int result = PARSE_EXPR_STRING("\\.", &t);
 	ASSERT_NE(-1, result);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 
-	ASSERT_EQ(1, t.alternatives[0].len);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[0].contents[0].type);
-	ASSERT_EQ('.', t.alternatives[0].contents[0].literal);
+	ASSERT_EQ(1, t.contents[0].count);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type);
+	ASSERT_EQ('.', t.contents[0].contents[0].literal);
 
 	parse_free_tree_children(&t);
 }
@@ -133,13 +126,12 @@ static void backslash_backslash_is_parsed_as_unquantified_literal(void)
 	const int result = PARSE_EXPR_STRING("\\\\", &t);
 	ASSERT_NE(-1, result);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 
-	ASSERT_EQ(1, t.alternatives[0].len);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[0].contents[0].type);
-	ASSERT_EQ('\\', t.alternatives[0].contents[0].literal);
+	ASSERT_EQ(1, t.contents[0].count);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type);
+	ASSERT_EQ('\\', t.contents[0].contents[0].literal);
 
 	parse_free_tree_children(&t);
 }
@@ -150,29 +142,26 @@ static void a_pipe_b_in_parens_is_parsed_as_subexpr_term(void)
 	const int result = PARSE_EXPR_STRING("(a|b)", &t);
 	ASSERT_NE(-1, result);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 
-	ASSERT_EQ(1, t.alternatives[0].len);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_SUBEXPR, t.alternatives[0].contents[0].type);
+	ASSERT_EQ(1, t.contents[0].count);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_SUBEXPR, t.contents[0].contents[0].type);
 
-	const parse_tree_t *inner = &t.alternatives[0].contents[0].subexpr;
+	const parse_tree_t *inner = &t.contents[0].contents[0].subexpr;
 	ASSERT_EQ(2, inner->count);
 
-	ASSERT_EQ(1, inner->alternatives[0].len);
+	ASSERT_EQ(1, inner->contents[0].count);
 	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE,
-	    inner->alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_LITERAL, inner->alternatives[0].contents[0].type);
-	ASSERT_EQ('a', inner->alternatives[0].contents[0].literal);
+	    PARSE_QUANTIFIER_NONE, inner->contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_LITERAL, inner->contents[0].contents[0].type);
+	ASSERT_EQ('a', inner->contents[0].contents[0].literal);
 
-	ASSERT_EQ(1, inner->alternatives[1].len);
+	ASSERT_EQ(1, inner->contents[1].count);
 	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE,
-	    inner->alternatives[1].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_LITERAL, inner->alternatives[1].contents[0].type);
-	ASSERT_EQ('b', inner->alternatives[1].contents[0].literal);
+	    PARSE_QUANTIFIER_NONE, inner->contents[1].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_LITERAL, inner->contents[1].contents[0].type);
+	ASSERT_EQ('b', inner->contents[1].contents[0].literal);
 
 	parse_free_tree_children(&t);
 }
@@ -183,24 +172,21 @@ static void a_in_parens_b_is_parsed_as_sequence_with_subexpr_term(void)
 	const int result = PARSE_EXPR_STRING("(a)b", &t);
 	ASSERT_NE(-1, result);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 
-	ASSERT_EQ(2, t.alternatives[0].len);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_SUBEXPR, t.alternatives[0].contents[0].type);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[1].quantifier);
-	ASSERT_EQ(PARSE_TERM_LITERAL, t.alternatives[0].contents[1].type);
-	ASSERT_EQ('b', t.alternatives[0].contents[1].literal);
+	ASSERT_EQ(2, t.contents[0].count);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_SUBEXPR, t.contents[0].contents[0].type);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[1].quantifier);
+	ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[1].type);
+	ASSERT_EQ('b', t.contents[0].contents[1].literal);
 
-	const parse_tree_t *inner = &t.alternatives[0].contents[0].subexpr;
-	ASSERT_EQ(1, inner->alternatives[0].len);
+	const parse_tree_t *inner = &t.contents[0].contents[0].subexpr;
+	ASSERT_EQ(1, inner->contents[0].count);
 	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE,
-	    inner->alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_LITERAL, inner->alternatives[0].contents[0].type);
-	ASSERT_EQ('a', inner->alternatives[0].contents[0].literal);
+	    PARSE_QUANTIFIER_NONE, inner->contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_LITERAL, inner->contents[0].contents[0].type);
+	ASSERT_EQ('a', inner->contents[0].contents[0].literal);
 
 	parse_free_tree_children(&t);
 }
@@ -211,12 +197,11 @@ static void dot_star_is_parsed_as_star_quantified_wildcard(void)
 	const int result = PARSE_EXPR_STRING(".*", &t);
 	ASSERT_NE(-1, result);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 
-	ASSERT_EQ(1, t.alternatives[0].len);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_STAR, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_WILDCARD, t.alternatives[0].contents[0].type);
+	ASSERT_EQ(1, t.contents[0].count);
+	ASSERT_EQ(PARSE_QUANTIFIER_STAR, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_WILDCARD, t.contents[0].contents[0].type);
 
 	parse_free_tree_children(&t);
 }
@@ -227,12 +212,11 @@ static void dot_plus_is_parsed_as_plus_quantified_wildcard(void)
 	const int result = PARSE_EXPR_STRING(".+", &t);
 	ASSERT_NE(-1, result);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 
-	ASSERT_EQ(1, t.alternatives[0].len);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_PLUS, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_WILDCARD, t.alternatives[0].contents[0].type);
+	ASSERT_EQ(1, t.contents[0].count);
+	ASSERT_EQ(PARSE_QUANTIFIER_PLUS, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_WILDCARD, t.contents[0].contents[0].type);
 
 	parse_free_tree_children(&t);
 }
@@ -243,12 +227,11 @@ static void dot_question_mark_is_parsed_as_qmrk_quantified_wildcard(void)
 	const int result = PARSE_EXPR_STRING(".?", &t);
 	ASSERT_NE(-1, result);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 
-	ASSERT_EQ(1, t.alternatives[0].len);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_QMRK, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_WILDCARD, t.alternatives[0].contents[0].type);
+	ASSERT_EQ(1, t.contents[0].count);
+	ASSERT_EQ(PARSE_QUANTIFIER_QMARK, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_WILDCARD, t.contents[0].contents[0].type);
 
 	parse_free_tree_children(&t);
 }
@@ -259,16 +242,15 @@ static void a_in_brackets_is_parsed_as_class_containing_only_a(void)
 	const int result = PARSE_EXPR_STRING("[a]", &t);
 	ASSERT_NE(-1, result);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 
-	ASSERT_EQ(1, t.alternatives[0].len);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_CLASS, t.alternatives[0].contents[0].type);
-	ASSERT_FALSE(t.alternatives[0].contents[0].class.negated);
-	ASSERT_EQ(1, t.alternatives[0].contents[0].class.count);
-	ASSERT_NOT_NULL(t.alternatives[0].contents[0].class.contents);
-	ASSERT_EQ('a', t.alternatives[0].contents[0].class.contents[0]);
+	ASSERT_EQ(1, t.contents[0].count);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_CLASS, t.contents[0].contents[0].type);
+	ASSERT_FALSE(t.contents[0].contents[0].class.negated);
+	ASSERT_EQ(1, t.contents[0].contents[0].class.count);
+	ASSERT_NOT_NULL(t.contents[0].contents[0].class.contents);
+	ASSERT_EQ('a', t.contents[0].contents[0].class.contents[0]);
 
 	parse_free_tree_children(&t);
 }
@@ -279,16 +261,15 @@ static void caret_a_in_brackets_parses_as_negated_class(void)
 	const int result = PARSE_EXPR_STRING("[^a]", &t);
 	ASSERT_NE(-1, result);
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.alternatives);
+	ASSERT_NOT_NULL(t.contents);
 
-	ASSERT_EQ(1, t.alternatives[0].len);
-	ASSERT_EQ(
-	    PARSE_QUANTIFIER_NONE, t.alternatives[0].contents[0].quantifier);
-	ASSERT_EQ(PARSE_TERM_CLASS, t.alternatives[0].contents[0].type);
-	ASSERT_TRUE(t.alternatives[0].contents[0].class.negated);
-	ASSERT_EQ(1, t.alternatives[0].contents[0].class.count);
-	ASSERT_NOT_NULL(t.alternatives[0].contents[0].class.contents);
-	ASSERT_EQ('a', t.alternatives[0].contents[0].class.contents[0]);
+	ASSERT_EQ(1, t.contents[0].count);
+	ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier);
+	ASSERT_EQ(PARSE_TERM_CLASS, t.contents[0].contents[0].type);
+	ASSERT_TRUE(t.contents[0].contents[0].class.negated);
+	ASSERT_EQ(1, t.contents[0].contents[0].class.count);
+	ASSERT_NOT_NULL(t.contents[0].contents[0].class.contents);
+	ASSERT_EQ('a', t.contents[0].contents[0].class.contents[0]);
 
 	parse_free_tree_children(&t);
 }