From fe0b6d7eaf6ffdcb01146356f373ac66cba2f642 Mon Sep 17 00:00:00 2001
From: ptrace <adam@p-trace.com>
Date: Sun, 18 Jan 2026 00:35:09 +0100
Subject: [PATCH 1/2] Updated module stubborn to the latest version of Aug 3,
 2025

---
 modules/stubborn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/stubborn b/modules/stubborn
index 4939f5e..cacd221 160000
--- a/modules/stubborn
+++ b/modules/stubborn
@@ -1 +1 @@
-Subproject commit 4939f5e755b050c3c4f36597ff2de8d64fc6de7a
+Subproject commit cacd221e2c5e27b33aeb46a074e79c1e4f49c922

From 63d8baad3f17ac9256e53be6e551d0c7756fec26 Mon Sep 17 00:00:00 2001
From: ptrace <adam@p-trace.com>
Date: Sun, 18 Jan 2026 00:55:46 +0100
Subject: [PATCH 2/2] Removed deprecation warnings as of Jai version beta
 0.2.024; Replaced old deref syntax with the new one

---
 compile.jai  | 18 +++++-----
 match.jai    |  2 +-
 nfa.jai      |  2 +-
 parse.jai    | 94 ++++++++++++++++++++++++++--------------------------
 program.jai  | 80 ++++++++++++++++++++++----------------------
 simplify.jai | 12 +++----
 sparse.jai   |  8 ++---
 walk.jai     |  2 +-
 8 files changed, 109 insertions(+), 109 deletions(-)

diff --git a/compile.jai b/compile.jai
index 5f3f71e..0c1ac86 100644
--- a/compile.jai
+++ b/compile.jai
@@ -33,7 +33,7 @@ compile :: (pattern: string, parse_flags := ParseFlags.LikePerl) -> Regexp, succ
         uninit(*regexp);
 		return .{}, false;
 	}
-	#if REGEXP_DEBUG	print("Compiled suffix:\n%\n", to_string(<<regexp.prog));
+	#if REGEXP_DEBUG	print("Compiled suffix:\n%\n", to_string(regexp.prog));
 
 	regexp.num_capture_groups = compute_num_captures(regexp.suffix_regexp);
 // 	// @ToDo: For one-pass NFA
@@ -72,12 +72,12 @@ make_patch_list :: (p: int) -> PatchList {
 patch  :: (inst: *[..] Inst, l: PatchList, p: int) {
 	head := l.head;
 	while head != 0 {
-		ip := *(<<inst)[head>>1];
+		ip := *(inst.*)[head>>1];
 		if head & 1 {
 			head = ip.out1;
 			ip.out1 = cast(u32)p;
 		} else {
-			head = get_out(<<ip);
+			head = get_out(ip.*);
 			set_out(ip, p);
 		}
 	}
@@ -88,7 +88,7 @@ append :: (inst: *[..] Inst, l1: PatchList, l2: PatchList) -> PatchList {
 	if l1.head == 0		return l2;
 	if l2.head == 0		return l1;
 
-	ip := *(<<inst)[l1.tail>>1];
+	ip := *(inst.*)[l1.tail>>1];
 	if l1.tail & 1 {
 		ip.out1 = l2.head;
 	} else {
@@ -260,13 +260,13 @@ finish :: (using comp: *Compiler, re: *Regexp_Node) -> *Prog {
 	prog.inst = inst;
 
 	optimize(prog);
-	#if REGEXP_DEBUG	print("Optimized:\n%\n", to_string(<<prog));
+	#if REGEXP_DEBUG	print("Optimized:\n%\n", to_string(prog.*));
 	flatten(prog);
-	#if REGEXP_DEBUG	print("Flattened:\n%\n", to_string(<<prog));
+	#if REGEXP_DEBUG	print("Flattened:\n%\n", to_string(prog.*));
 	compute_byte_map(prog);
 
 	if (!prog.reversed) {
-		prefix, prefix_foldcase := required_prefix_for_accel(<<re);
+		prefix, prefix_foldcase := required_prefix_for_accel(re.*);
 		if prefix.count && !prefix_foldcase {
 			prog.prefix_size = prefix.count;
 			prog.prefix_front = prefix[0];
@@ -330,7 +330,7 @@ cat :: (using comp: *Compiler, a: Frag, b: Frag) -> Frag {
 
 	// Elide no-op.
 	begin := *inst[a.begin];
-	if get_opcode(<<begin) == .kInstNop && a.end.head == (a.begin << 1) && get_out(<<begin) == 0 {
+	if get_opcode(begin.*) == .kInstNop && a.end.head == (a.begin << 1) && get_out(begin.*) == 0 {
 		// in case refs to a somewhere
 		patch(*inst, a.end, b.begin);
 		return b;
@@ -497,7 +497,7 @@ make_rune_cache_key :: (lo: u8, hi: u8, foldcase: bool, next: int) -> u64 {
 cached_rune_byte_suffix :: (using comp: *Compiler, lo: u8, hi: u8, foldcase: bool, next: int) -> int {
 	key := make_rune_cache_key(lo, hi, foldcase, next);
 	ptr := table_find_pointer(*rune_cache, key);
-	if ptr	return <<ptr;
+	if ptr	return ptr.*;
 	id := uncached_rune_byte_suffix(comp, lo, hi, foldcase, next);
 	table_add(*rune_cache, key, id);
 	return id;
diff --git a/match.jai b/match.jai
index 63e2252..8a878f1 100644
--- a/match.jai
+++ b/match.jai
@@ -145,7 +145,7 @@ ascii_strcasecmp :: (a: string, b: string) -> int {
 compute_num_captures :: (re: *Regexp_Node) -> int {
 	count_pre_visit :: (num: *int, re: *Regexp_Node, v: *void) -> *void, bool {
 		if re.op == .Capture {
-			<<num += 1;
+			num.* += 1;
 		}
 		return null, false;
 	}
diff --git a/nfa.jai b/nfa.jai
index 828b282..42ad384 100644
--- a/nfa.jai
+++ b/nfa.jai
@@ -332,7 +332,7 @@ add_to_queue :: (using nfa: *Nfa, q: *Thread_Queue, id0: int, c: int, ctx: strin
 
 		id := a.id;
 		if id == 0	continue;
-		if contains(<<q, id)		continue;
+		if contains(q.*, id)		continue;
 
 		// Create entry in q no matter what.  We might fill it in below,
 		// or we might not.  Even if not, it is necessary to have it,
diff --git a/parse.jai b/parse.jai
index 6b9c295..fe8df0e 100644
--- a/parse.jai
+++ b/parse.jai
@@ -438,11 +438,11 @@ make_status :: (code := StatusCode.Success, error_arg := "") -> Status {
 }
 
 rep :: (ps: *ParseState, op: RegexpOp, t: *string, lastunary: string) -> isunary: string, success: bool  {
-	opstr := <<t;
+	opstr := t.*;
 	nongreedy := false;
 	advance(t);  // '*' or '+' or '?'
 	if (ps.flags & .PerlX) {
-		if (t.count && (<<t)[0] == #char "?") {
+		if (t.count && (t.*)[0] == #char "?") {
 			nongreedy = true;
 			advance(t);  // '?'
 		}
@@ -2119,14 +2119,14 @@ add_rune_to_string :: (re: *Regexp_Node, r: Rune) {
 // Parses a decimal integer, storing it in *np.
 // Sets *s to span the remainder of the string.
 parse_integer :: (s: *string) -> int, success: bool {
-	if !s.count || !isdigit((<<s)[0])		return 0, false;
+	if !s.count || !isdigit((s.*)[0])		return 0, false;
 
 	// Disallow leading zeros.
-	if s.count >= 2 && (<<s)[0] == #char "0" && isdigit((<<s)[1])	return 0, false;
+	if s.count >= 2 && (s.*)[0] == #char "0" && isdigit((s.*)[1])	return 0, false;
 
 	n := 0;
-	while s.count && isdigit((<<s)[0]) {
-		c := (<<s)[0];
+	while s.count && isdigit((s.*)[0]) {
+		c := (s.*)[0];
 		// Avoid overflow.
 		if n >= 100000000	return 0, false;
 		n = n*10 + c - #char "0";
@@ -2145,7 +2145,7 @@ parse_integer :: (s: *string) -> int, success: bool {
 // doesn't fail even if ParseRepetition does, so the StringPiece
 // s must NOT be edited unless MaybeParseRepetition returns true.
 maybe_parse_repetition :: (sp: *string) -> lo: int, hi: int, success: bool {
-	s := <<sp;
+	s := sp.*;
 	if !s.count || s[0] != #char "{"	 return 0, 0, false;
 
 	advance(*s);
@@ -2175,14 +2175,14 @@ maybe_parse_repetition :: (sp: *string) -> lo: int, hi: int, success: bool {
 	}
 	if !s.count || s[0] != #char "}"	return 0, 0, false;
 	advance(*s);
-	<<sp = s;
+	sp.* = s;
 
 	return lo, hi, true;
 }
 
 // @ToDo: Move to unicode module?
 consume_rune :: (str: *string) -> Rune, len: int, status: Status {
-	result, len := rune_from_string(<<str);
+	result, len := rune_from_string(str.*);
 	if !len		return 0, 0, make_status(.BadUTF8);
 
 	advance(str, len);
@@ -2219,13 +2219,13 @@ parse_escape :: (s: *string, rune_max: s32) -> r: Rune, status: Status, success:
 		return status;
 	}
 
-	assert(s.count && (<<s)[0] == #char "\\");
+	assert(s.count && (s.*)[0] == #char "\\");
 
 	if s.count == 1 {
 		return 0, make_status(.TrailingBackslash), false;
 	}
 
-	begin := <<s;
+	begin := s.*;
 
 	advance(s); // backslash
 
@@ -2252,18 +2252,18 @@ parse_escape :: (s: *string, rune_max: s32) -> r: Rune, status: Status, success:
 		case #char "6"; #through;
 		case #char "7";
 			// Single non-zero octal digit is a backreference; not supported.
-			if !s.count || (<<s)[0] < #char "0" || (<<s)[0] > #char "7"	 return 0, bad_escape(begin, s), false;
+			if !s.count || (s.*)[0] < #char "0" || (s.*)[0] > #char "7"	 return 0, bad_escape(begin, s), false;
 			#through;
 		case #char "0";
 			// consume up to three octal digits; already have one.
 			code := c - #char "0";
 			if !s.count		return 0, bad_escape(begin, s), false;
-			c = (<<s)[0];
+			c = (s.*)[0];
 			if #char "0" <= c && c <= #char "7" {
 				code = code * 8 + c - #char "0";
 				advance(s); // digit
 				if s {
-					c = (<<s)[0];
+					c = (s.*)[0];
 					if #char "0" <= c && c <= #char "7" {
 						code = code * 8 + c - #char "0";
 						advance(s); // digit
@@ -2459,11 +2459,11 @@ add_unicode_group :: (cc: *CharClass, g: *UGroup, sign: int, parse_flags: ParseF
 // The StringPiece must *NOT* be edited unless the call succeeds.
 maybe_parse_perl_cc_escape :: (s: *string, parse_flags: ParseFlags) -> *UGroup {
 	if !(parse_flags & .PerlClasses)	return null;
-	if s.count < 2 || (<<s)[0] != #char "\\"		return null;
+	if s.count < 2 || (s.*)[0] != #char "\\"		return null;
 
 	// Could use StringPieceToRune, but there aren't
 	// any non-ASCII Perl group names.
-	name := slice(<<s, 0, 2);
+	name := slice(s.*, 0, 2);
 	g := lookup_perl_group(name);
 	if g == null		return null;
 	advance(s, name.count);
@@ -2483,9 +2483,9 @@ maybe_parse_unicode_group :: (s: *string, parse_flags: ParseFlags, cc: *CharClas
 	status: Status;
 	// Decide whether to parse.
 	if !(parse_flags & .UnicodeGroups)	return status, .kParseNothing;
-	if s.count < 2 || (<<s)[0] != #char "\\"  return status, .kParseNothing;
+	if s.count < 2 || (s.*)[0] != #char "\\"  return status, .kParseNothing;
 
-	c: Rune = (<<s)[1];
+	c: Rune = (s.*)[1];
 	if c != #char "p" && c != #char "P"		return status, .kParseNothing;
 
 	// Committed to parse.  Results:
@@ -2493,12 +2493,12 @@ maybe_parse_unicode_group :: (s: *string, parse_flags: ParseFlags, cc: *CharClas
 	if (c == #char "P")	{
 		sign = -sign;
 	}
-	seq := <<s; // \p{Han} or \pL
+	seq := s.*; // \p{Han} or \pL
 	name: string;  // Han or L
 	advance(s, 2);  // '\\', 'p'
 
 
-	if (<<s)[0] != #char "{" {
+	if (s.*)[0] != #char "{" {
 		status: Status;
 		len: int;
 		c, len, status = consume_rune(s);
@@ -2508,7 +2508,7 @@ maybe_parse_unicode_group :: (s: *string, parse_flags: ParseFlags, cc: *CharClas
 		name = slice(seq, 2, len);
 	} else {
 		// Name is in braces. Look for closing }
-		end := find_index_from_left(<<s, #char "}");
+		end := find_index_from_left(s.*, #char "}");
 		if end != -1 {
 			valid: bool;
 			valid, status = is_valid_utf8(seq);
@@ -2516,7 +2516,7 @@ maybe_parse_unicode_group :: (s: *string, parse_flags: ParseFlags, cc: *CharClas
 
 			return make_status(.BadCharRange, seq), .kParseError;
 		}
-		name = slice(<<s, 1, end - 1); // without '}'
+		name = slice(s.*, 1, end - 1); // without '}'
 		advance(s, end + 1);
 		valid: bool;
 		valid, status = is_valid_utf8(name);
@@ -2573,16 +2573,16 @@ maybe_parse_unicode_group :: (s: *string, parse_flags: ParseFlags, cc: *CharClas
 // Adds the ranges corresponding to the class to ranges.
 parse_cc_name :: (s: *string, parse_flags: ParseFlags, cc: *CharClass) -> status: Status, result: ParseResult {
 	// Check begins with [:
-	if s.count < 2	|| (<<s)[0] != #char "[" || (<<s)[1] != #char ":"		return Status.{}, .kParseNothing;
+	if s.count < 2	|| (s.*)[0] != #char "[" || (s.*)[1] != #char ":"		return Status.{}, .kParseNothing;
 
 	// Look for closing :].
-	end := find_index_from_left(<<s, ":]");
+	end := find_index_from_left(s.*, ":]");
 
 	// If no closing :], then ignore.
 	if !end		return Status.{}, .kParseNothing;
 
 	// Got it.  Check that it's valid.
-	name := slice(<<s, 2, end - 2);
+	name := slice(s.*, 2, end - 2);
 	g := lookup_posix_group(name);
 	if (g == null) {
 		return make_status(.BadCharRange, name), .kParseError;
@@ -2601,7 +2601,7 @@ parse_cc_character :: (using ps: *ParseState, s: *string, whole_class: string) -
 
 	// Allow regular escape sequences even though
 	// many need not be escaped in this context.
-	if (<<s)[0] == #char "\\" {
+	if (s.*)[0] == #char "\\" {
 		rune, status, success := parse_escape(s, rune_max);
 		return rune, status, success;
 	} else {
@@ -2616,14 +2616,14 @@ parse_cc_character :: (using ps: *ParseState, s: *string, whole_class: string) -
 // For single characters, rr.lo == rr.hi.
 // Sets *s to span the remainder of the string.
 parse_cc_range :: (using ps: *ParseState, s: *string, whole_class: string) -> RuneRange, status: Status, success: bool {
-	os := <<s;
+	os := s.*;
 	rr: RuneRange;
 	success: bool;
 	rr.lo, status, success = parse_cc_character(ps, s, whole_class);
 	if !success		return rr, status, false;
 
 	// [a-] means (a|-), so check for final ].
-	if s.count >= 2 && (<<s)[0] == #char "-" && (<<s)[1] != #char "]" {
+	if s.count >= 2 && (s.*)[0] == #char "-" && (s.*)[1] != #char "]" {
 		advance(s);  // #char "-"
 
 		rr.hi, status, success = parse_cc_character(ps, s, whole_class);
@@ -2642,16 +2642,16 @@ parse_cc_range :: (using ps: *ParseState, s: *string, whole_class: string) -> Ru
 // Sets *s to span the remainder of the string.
 // Sets *out_re to the regexp for the class.
 parse_char_class :: (using ps: *ParseState, s: *string) -> *Regexp_Node, status: Status, success: bool {
-	whole_class := <<s;
+	whole_class := s.*;
 	// Caller checked this.
-	assert(s.count && (<<s)[0] == #char "[");
+	assert(s.count && (s.*)[0] == #char "[");
 
 	negated: bool;
 	re := new_regexp(*ps.pool, .CharClass, flags & ~.FoldCase);
 	re.char_class = New(CharClass);
 	re.char_class_finished = false;
 	advance(s);  // '['
-	if s.count && (<<s)[0] == #char "^" {
+	if s.count && (s.*)[0] == #char "^" {
 		advance(s); // '^'
 		negated = true;
 		if !(flags & .ClassNL) || flags & .NeverNL {
@@ -2661,25 +2661,25 @@ parse_char_class :: (using ps: *ParseState, s: *string) -> *Regexp_Node, status:
 		}
 	}
 	first := true;  // ] is okay as first char in class
-	while s.count && (first || (<<s)[0] != #char "]") {
+	while s.count && (first || (s.*)[0] != #char "]") {
 		// - is only okay unescaped as first or last in class.
 		// Except that Perl allows - anywhere.
-		if !first && (<<s)[0] == #char "-" && !(flags & .PerlX) && (s.count == 1 || (<<s)[1] != #char "]") {
+		if !first && (s.*)[0] == #char "-" && !(flags & .PerlX) && (s.count == 1 || (s.*)[1] != #char "]") {
 			remove_regexp(*ps.pool, re);
 
-			t := <<s;
+			t := s.*;
 			advance(*t);  // '-'
 			r, n, status := consume_rune(*t);
 			if !n {
 				return null, status, false;
 			}
 
-			return null, make_status(.BadCharRange, slice(<<s, 0, 1 + n)), false;
+			return null, make_status(.BadCharRange, slice(s.*, 0, 1 + n)), false;
 		}
 		first = false;
 
 		// Look for [:alnum:] etc.
-		if s.count > 2 && (<<s)[0] == #char "[" && (<<s)[1] == #char ":" {
+		if s.count > 2 && (s.*)[0] == #char "[" && (s.*)[1] == #char ":" {
 			status, result := parse_cc_name(s, flags, re.char_class);
 			if #complete result == {
 				case .kParseOk;
@@ -2692,7 +2692,7 @@ parse_char_class :: (using ps: *ParseState, s: *string) -> *Regexp_Node, status:
 		}
 
 		// Look for Unicode character group like \p{Han}
-		if s.count > 2 && (<<s)[0] == #char "\\" && ((<<s)[1] == #char "p" || (<<s)[1] == #char "P") {
+		if s.count > 2 && (s.*)[0] == #char "\\" && ((s.*)[1] == #char "p" || (s.*)[1] == #char "P") {
 			status, result := maybe_parse_unicode_group(s, flags, re.char_class);
 			if #complete result == {
 				case .kParseOk;
@@ -2763,9 +2763,9 @@ is_valid_capture_name :: (name: string) -> bool {
 // well-formed or not supported, sets status and returns false.
 parse_perl_flags :: (using ps: *ParseState, s: *string) -> Status, success: bool {
 	// Caller is supposed to check this.
-	assert(flags & .PerlX && s.count >= 2 && (<<s)[0] == #char "(" && (<<s)[1] == #char "?");
+	assert(flags & .PerlX && s.count >= 2 && (s.*)[0] == #char "(" && (s.*)[1] == #char "?");
 
-	t := <<s;
+	t := s.*;
 	advance(*t, 2); // "(?"
 
 	// Check for named captures, first introduced in Python's regexp library.
@@ -2788,13 +2788,13 @@ parse_perl_flags :: (using ps: *ParseState, s: *string) -> Status, success: bool
 		// Pull out name.
 		end := find_index_from_left(t, #char ">");
 		if end == -1 {
-			valid, status := is_valid_utf8(<<s);
+			valid, status := is_valid_utf8(s.*);
 			if !valid		return status, false;
-			return make_status(.BadNamedCapture, <<s), false;
+			return make_status(.BadNamedCapture, s.*), false;
 		}
 
 		// t is "name>...", t[end] == '>'
-		capture := slice(<<s, 2, end + 3);
+		capture := slice(s.*, 2, end + 3);
 		name := slice(t, 0, end);
 		valid, status := is_valid_utf8(name);
 		if !valid		return status, false;
@@ -2812,12 +2812,12 @@ parse_perl_flags :: (using ps: *ParseState, s: *string) -> Status, success: bool
 	nflags := flags;
 	done: bool;
 	while !done {
-		if !t.count		return make_status(.BadPerlOp, <<s), false;
+		if !t.count		return make_status(.BadPerlOp, s.*), false;
 		c, len, status :=  consume_rune(*t);
 		if !len		return status, false;
 		if c == {
 			case;
-				return make_status(.BadPerlOp, slice(<<s, 0, s.count - t.count)), false;
+				return make_status(.BadPerlOp, slice(s.*, 0, s.count - t.count)), false;
 			// Parse flags.
 			case #char "i";
 				sawflags = true;
@@ -2853,7 +2853,7 @@ parse_perl_flags :: (using ps: *ParseState, s: *string) -> Status, success: bool
 
 			// Negation
 			case #char "-";
-				if negated		return make_status(.BadPerlOp, slice(<<s, 0, s.count - t.count)), false;
+				if negated		return make_status(.BadPerlOp, slice(s.*, 0, s.count - t.count)), false;
 
 				negated = true;
 				sawflags = false;
@@ -2869,10 +2869,10 @@ parse_perl_flags :: (using ps: *ParseState, s: *string) -> Status, success: bool
 		}
 	}
 
-	if negated && !sawflags		return make_status(.BadPerlOp, slice(<<s, 0, s.count - t.count)), false;
+	if negated && !sawflags		return make_status(.BadPerlOp, slice(s.*, 0, s.count - t.count)), false;
 
 	flags = nflags;
-	<<s = t;
+	s.* = t;
 	return .{}, true;
 }
 
diff --git a/program.jai b/program.jai
index ab11755..103161f 100644
--- a/program.jai
+++ b/program.jai
@@ -288,24 +288,24 @@ optimize :: (using prog: *Prog) {
 	add_if_nonzero(*q, start);
 	for id: q {
 		ip := *inst[id];
-		j := get_out(<<ip);
+		j := get_out(ip.*);
 		// ToDo: Why is this a pointer????
 		jp: *Inst;
 		while true {
 			if j == 0	break;
 			jp = *inst[j];
-			if get_opcode(<<jp) != .kInstNop	break;
-			j = get_out(<<jp);
+			if get_opcode(jp.*) != .kInstNop	break;
+			j = get_out(jp.*);
 		}
 		set_out(ip, j);
 		add_if_nonzero(*q, j);
-		if get_opcode(<<ip) == .kInstAlt {
+		if get_opcode(ip.*) == .kInstAlt {
 			j = ip.out1;
 			while true {
 				if j == 0	break;
 				jp = *inst[j];
-				if get_opcode(<<jp) != .kInstNop	break;
-				j = get_out(<<jp);
+				if get_opcode(jp.*) != .kInstNop	break;
+				j = get_out(jp.*);
 			}
 			ip.out1 = j;
 			add_if_nonzero(*q, j);
@@ -323,12 +323,12 @@ optimize :: (using prog: *Prog) {
 	add_if_nonzero(*q, start);
 	for id: q {
 		ip := *inst[id];
-		add_if_nonzero(*q, get_out(<<ip));
-		if get_opcode(<<ip) == .kInstAlt {
+		add_if_nonzero(*q, get_out(ip.*));
+		if get_opcode(ip.*) == .kInstAlt {
 			add_if_nonzero(*q, ip.out1);
 
 			// ToDo: Why are these pointers????
-			j := inst[get_out(<<ip)];
+			j := inst[get_out(ip.*)];
 			k := inst[ip.out1];
 			if get_opcode(j) == .kInstByteRange && get_out(j) == id && j.lo == 0x00 && j.hi == 0xFF && is_match(prog, k) {
 				set_opcode(ip, .kInstAltMatch);
@@ -426,11 +426,11 @@ compute_byte_map :: (using prog: *Prog) {
 
 	for id: 0..inst.count - 1 {
 		ip := *inst[id];
-		if get_opcode(<<ip) == .kInstByteRange {
+		if get_opcode(ip.*) == .kInstByteRange {
             lo: s32 = ip.lo;
             hi: s32 = ip.hi;
 			mark(*builder, lo, hi);
-			if get_foldcase(<<ip) && lo <= #char "z" && hi >= #char "a" {
+			if get_foldcase(ip.*) && lo <= #char "z" && hi >= #char "a" {
 				foldlo := lo;
 				foldhi := hi;
 				if foldlo < #char "a" {
@@ -447,11 +447,11 @@ compute_byte_map :: (using prog: *Prog) {
 			}
 			// If this Inst is not the last Inst in its list AND the next Inst is
 			// also a ByteRange AND the Insts have the same out, defer the merge.
-			if !get_last(<<ip) && get_opcode(inst[id + 1]) == .kInstByteRange && get_out(<<ip) == get_out(inst[id+1]) {
+			if !get_last(ip.*) && get_opcode(inst[id + 1]) == .kInstByteRange && get_out(ip.*) == get_out(inst[id+1]) {
 				continue;
 			}
 			merge(*builder);
-		} else if get_opcode(<<ip) == .kInstEmptyWidth {
+		} else if get_opcode(ip.*) == .kInstEmptyWidth {
 			if ip.empty & (EmptyOp.kEmptyBeginLine|.kEmptyEndLine) && !marked_line_boundaries {
 				mark(*builder, #char "\n", #char "\n");
 				merge(*builder);
@@ -714,10 +714,10 @@ flatten :: (using prog: *Prog) {
 	// Fourth pass: Remaps outs to flat-ids.
 	// Counts instructions by opcode.
 	for * flat {
-		if (get_opcode(<<it) != .kInstAltMatch) { // handled in EmitList()
-			set_out(it, flatmap[get_out(<<it)]);
+		if (get_opcode(it.*) != .kInstAltMatch) { // handled in EmitList()
+			set_out(it, flatmap[get_out(it.*)]);
 		}
-		inst_count[get_opcode(<<it)] += 1;
+		inst_count[get_opcode(it.*)] += 1;
 	}
 
 	total := 0;
@@ -755,16 +755,16 @@ flatten :: (using prog: *Prog) {
 mark_successors :: (using prog: *Prog, reachable: *Sparse_Set, stk: *[..] int) -> rootmap: Sparse_Array(int), predmap: Sparse_Array(int), preds_list: [..] [..] int {
 	get_or_add_preds :: (preds_list: *[..] [..] int, predmap: *Sparse_Array(int), id: int) -> *[..] int {
 		preds: * [..] int;
-		if !contains(<<predmap, id) {
+		if !contains(predmap.*, id) {
 			add_unchecked(predmap, id, preds_list.count);
 			array_reserve(preds_list, preds_list.count + 1);
 			memset(preds_list.data + preds_list.count, 0, size_of(type_of(preds_list[0])));
 			preds_list.count += 1;
-			preds = *(<<preds_list)[preds_list.count - 1];
+			preds = *(preds_list.*)[preds_list.count - 1];
 			preds.data = null;
 			preds.count = 0;
 		} else {
-			preds = *(<<preds_list)[get(<<predmap, id)];
+			preds = *(preds_list.*)[get(predmap.*, id)];
 		}
 		return preds;
 	}
@@ -791,7 +791,7 @@ mark_successors :: (using prog: *Prog, reachable: *Sparse_Set, stk: *[..] int) -
 	array_add(stk, start_unanchored);
 	while stk.count {
 		id := pop(stk);
-		if contains(<<reachable, id)	 continue;
+		if contains(reachable.*, id)	 continue;
 		add_unchecked(reachable, id);
 
 		i := inst[id];
@@ -836,10 +836,10 @@ mark_dominator :: (using prog: *Prog, root: int, rootmap: *Sparse_Array(int), pr
 
 	while stk.count {
 		id := pop(stk);
-		if contains(<<reachable, id) continue;
+		if contains(reachable.*, id) continue;
 		add_unchecked(reachable, id);
 
-		if id != root && contains(<<rootmap, id) {
+		if id != root && contains(rootmap.*, id) {
 			// We reached another "tree" via epsilon transition.
 			continue;
 		}
@@ -866,10 +866,10 @@ mark_dominator :: (using prog: *Prog, root: int, rootmap: *Sparse_Array(int), pr
 	for id: reachable {
 		if contains(predmap, id) {
 			for pred: preds_list[get(predmap, id)] {
-				if !contains(<<reachable, pred) {
+				if !contains(reachable.*, pred) {
 					// id has a predecessor that cannot be reached from root!
 					// Therefore, id must be a "root" too - mark it as such.
-					if !contains(<<rootmap, id) {
+					if !contains(rootmap.*, id) {
 						add_unchecked(rootmap, id, rootmap.count);
 					}
 				}
@@ -884,15 +884,15 @@ emit_list :: (using prog: *Prog, root: int, rootmap: *Sparse_Array(int), flat: *
 	array_add(stk, root);
 	while stk.count {
 		id := pop(stk);
-		if contains(<<reachable, id) continue;
+		if contains(reachable.*, id) continue;
 		add_unchecked(reachable, id);
 
-		if id != root && contains(<<rootmap, id) {
+		if id != root && contains(rootmap.*, id) {
 			// We reached another "tree" via epsilon transition. Emit a kInstNop
 			// instruction so that the Prog does not become quadratically larger.
 			i: Inst;
 			set_opcode(*i, .kInstNop);
-			set_out(*i, get(<<rootmap, id));
+			set_out(*i, get(rootmap.*, id));
 			array_add(flat, i);
 			continue;
 		}
@@ -916,7 +916,7 @@ emit_list :: (using prog: *Prog, root: int, rootmap: *Sparse_Array(int), flat: *
 			case .kInstCapture; #through;
 			case .kInstEmptyWidth;
 				newi := i;
-				set_out(*newi, get(<<rootmap, get_out(i)));
+				set_out(*newi, get(rootmap.*, get_out(i)));
 				array_add(flat, newi);
 
 			case .kInstNop;
@@ -945,24 +945,24 @@ compute_hints :: (using prog: *Prog, flat: *[..] Inst, begin: int, end: int) {
 		// Like ByteMapBuilder, we split at lo-1 and at hi.
 		lo := lo_in - 1;
 
-		if lo >= 0 && !(<<splits)[lo] {
+		if lo >= 0 && !(splits.*)[lo] {
 			set_bit(splits, lo);
-			next := find_next_set_bit(<<splits, lo + 1);
-			(<<colors)[lo] = (<<colors)[next];
+			next := find_next_set_bit(splits.*, lo + 1);
+			(colors.*)[lo] = (colors.*)[next];
 		}
-		if !(<<splits)[hi] {
+		if !(splits.*)[hi] {
 			set_bit(splits, hi);
-			next := find_next_set_bit(<<splits, hi + 1);
-			(<<colors)[hi] = (<<colors)[next];
+			next := find_next_set_bit(splits.*, hi + 1);
+			(colors.*)[hi] = (colors.*)[next];
 		}
 
 		c := lo + 1;
 		while c < 256 {
-			next := find_next_set_bit(<<splits, c);
+			next := find_next_set_bit(splits.*, c);
 			// Ratchet backwards...
-			(<<first) = min(<<first, (<<colors)[next]);
+			(first.*) = min(first.*, (colors.*)[next]);
 			// Recolor with id - because it's the new nearest conflict!
-			(<<colors)[next] = id;
+			(colors.*)[next] = id;
 			if next == hi	break;
 			c = next+1;
 		}
@@ -974,7 +974,7 @@ compute_hints :: (using prog: *Prog, flat: *[..] Inst, begin: int, end: int) {
 
 	dirty := false;
 	for < id: begin..end {
-		if (id == end || get_opcode((<<flat)[id]) != .kInstByteRange) {
+		if (id == end || get_opcode((flat.*)[id]) != .kInstByteRange) {
 			if (dirty) {
 				dirty = false;
 				clear_all_bits(*splits);
@@ -992,11 +992,11 @@ compute_hints :: (using prog: *Prog, flat: *[..] Inst, begin: int, end: int) {
 		// from end to the nearest conflict (if any) during recoloring.
 		first := end;
 
-		ip := *(<<flat)[id];
+		ip := *(flat.*)[id];
 		lo: s32 = ip.lo;
 		hi: s32 = ip.hi;
 		recolor(*splits, *colors, lo, hi, *first, id);
-		if get_foldcase(<<ip) && lo <= #char "z" && hi >= #char "a" {
+		if get_foldcase(ip.*) && lo <= #char "z" && hi >= #char "a" {
 			foldlo := lo;
 			foldhi := hi;
 			if (foldlo < #char "a") {
diff --git a/simplify.jai b/simplify.jai
index 2307076..9d22f9b 100644
--- a/simplify.jai
+++ b/simplify.jai
@@ -189,12 +189,12 @@ can_coalesce :: (r1: *Regexp_Node, r2: *Regexp_Node) -> bool {
 do_coalesce :: (pool: *Regexp_Pool, r1ptr: **Regexp_Node, r2ptr: **Regexp_Node) {
 	leave_empty :: (r1ptr: **Regexp_Node, r2ptr: **Regexp_Node, pool: *Regexp_Pool, nre: *Regexp_Node) {
 		// @ToDo, @Speed: Why don’t we set this to null instead of allocing a temporary new regexp?
-		<<r1ptr = new_regexp(pool, .EmptyMatch, .NoParseFlags);
-		<<r2ptr = nre;
+		r1ptr.* = new_regexp(pool, .EmptyMatch, .NoParseFlags);
+		r2ptr.* = nre;
 	}
 
-	r1 := <<r1ptr;
-	r2 := <<r2ptr;
+	r1 := r1ptr.*;
+	r2 := r2ptr.*;
 
 	nre := new_repeat(pool, r1.subs[0], r1.parse_flags, 0, 0);
 
@@ -266,8 +266,8 @@ do_coalesce :: (pool: *Regexp_Pool, r1ptr: **Regexp_Node, r2ptr: **Regexp_Node)
 			if n == r2.runes.count {
 				leave_empty(r1ptr, r2ptr, pool, nre);
 			} else {
-				<<r1ptr = nre;
-				<<r2ptr = new_literal_string(pool, slice(r2.runes, n, r2.runes.count - n), r2.parse_flags);
+				r1ptr.* = nre;
+				r2ptr.* = new_literal_string(pool, slice(r2.runes, n, r2.runes.count - n), r2.parse_flags);
 			}
 
 		case;
diff --git a/sparse.jai b/sparse.jai
index 26f18d9..23b58da 100644
--- a/sparse.jai
+++ b/sparse.jai
@@ -12,13 +12,13 @@ init :: (set: *Sparse_Set, size: int) {
 }
 
 add :: (set: *Sparse_Set, i: int) {
-	if !contains(<<set, i) {
+	if !contains(set.*, i) {
         add_unchecked(set, i);
 	}
 }
 
 add_unchecked :: (using set: *Sparse_Set, i: int) {
-  assert(!contains(<<set, i));
+  assert(!contains(set.*, i));
   assert(count < dense.count);
   sparse[i] = count;
   dense[count] = cast(u32)i;
@@ -68,7 +68,7 @@ add_or_set :: (array: *Sparse_Array($T), i: int, value: T) {
 }
 
 add_unchecked :: (using array: *Sparse_Array($T), i: int, value: T) {
-  assert(!contains(<<array, i));
+  assert(!contains(array.*, i));
   assert(count < dense.count);
   sparse[i] = count;
   dense[count].index = cast(u32)i;
@@ -77,7 +77,7 @@ add_unchecked :: (using array: *Sparse_Array($T), i: int, value: T) {
 }
 
 set :: (using array: *Sparse_Array($T), i: int, value: T) {
-	assert(contains(<<array, i));
+	assert(contains(array.*, i));
 	dense[sparse[i]].value = value;
 }
 
diff --git a/walk.jai b/walk.jai
index 9c4b4fa..08687da 100644
--- a/walk.jai
+++ b/walk.jai
@@ -43,7 +43,7 @@ Walk :: struct (C: Type, T: Type) {
 
 walk :: (ctx: C, re: *Regexp_Node, initial_value: T, w: Walk($C, $T)) -> T, stopped_early: bool {
 	do_visit :: (ctx: C, stack: *[..] Walk_State(T), w: *Walk(C, T)) -> T, stopped_early: bool, done: bool {
-		s := *(<<stack)[stack.count - 1];
+		s := *(stack.*)[stack.count - 1];
 		if s.n == -1 {
 			w.max_visits -= 1;
 			if (w.max_visits < 0) {