Change uses for parapoly records to use $ always

core/container/array.odin

@@ -3,7 +3,7 @@ package container
 import "core:mem"
 import "core:runtime"
 
-Array :: struct(T: typeid) {
+Array :: struct($T: typeid) {
 	data:      ^T,
 	len:       int,
 	cap:       int,

core/container/map.odin

@@ -4,12 +4,12 @@ import "intrinsics"
 _ :: intrinsics;
 
 
-Map :: struct(Key, Value: typeid) where intrinsics.type_is_valid_map_key(Key) {
+Map :: struct($Key, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {
 	hash: Array(int),
 	entries: Array(Map_Entry(Key, Value)),
 }
 
-Map_Entry :: struct(Key, Value: typeid) where intrinsics.type_is_valid_map_key(Key) {
+Map_Entry :: struct($Key, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {
 	hash:  uintptr,
 	next:  int,
 	key:   Key,

core/container/priority_queue.odin

@@ -1,6 +1,6 @@
 package container
 
-Priority_Queue :: struct(T: typeid) {
+Priority_Queue :: struct($T: typeid) {
 	data: Array(T),
 	len: int,
 	priority: proc(item: T) -> int,

core/container/queue.odin

@@ -1,6 +1,6 @@
 package container
 
-Queue :: struct(T: typeid) {
+Queue :: struct($T: typeid) {
 	data: Array(T),
 	len: int,
 	offset: int,

core/container/ring.odin

@@ -1,7 +1,7 @@
 package container
 
 
-Ring :: struct(T: typeid) {
+Ring :: struct($T: typeid) {
 	next, prev: ^Ring(T),
 	value: T,
 }

core/container/small_array.odin

@@ -1,6 +1,6 @@
 package container
 
-Small_Array :: struct(N: int, T: typeid) where N >= 0 {
+Small_Array :: struct($N: int, $T: typeid) where N >= 0 {
 	data: [N]T,
 	len:  int,
 }

core/math/fixed/fixed.odin

@@ -6,7 +6,7 @@ import "core:strconv"
 import "intrinsics"
 _ :: intrinsics;
 
-Fixed :: struct($Backing: typeid, Fraction_Width: uint)
+Fixed :: struct($Backing: typeid, $Fraction_Width: uint)
 	where
 		intrinsics.type_is_integer(Backing),
 		0 <= Fraction_Width,

core/mem/allocators.odin

@@ -919,7 +919,7 @@ tracking_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 // Small_Allocator primary allocates memory from its local buffer of size BUFFER_SIZE
 // If that buffer's memory is exhausted, it will use the backing allocator (a scratch allocator is recommended)
 // Memory allocated with Small_Allocator cannot be freed individually using 'free' and must be freed using 'free_all'
-Small_Allocator :: struct(BUFFER_SIZE: int)
+Small_Allocator :: struct($BUFFER_SIZE: int)
 	where
 		BUFFER_SIZE >= 2*size_of(uintptr),
 		BUFFER_SIZE & (BUFFER_SIZE-1) == 0 {

core/reflect/map.odin

@@ -5,7 +5,7 @@ import "core:mem"
 _ :: runtime;
 _ :: mem;
 
-Map_Entry_Info :: struct(Key, Value: typeid) {
+Map_Entry_Info :: struct($Key, $Value: typeid) {
 	hash:  uintptr,
 	key:   Key,
 	value: Value,

core/runtime/core_builtin.odin

@@ -3,7 +3,7 @@ package runtime
 import "intrinsics"
 
 @builtin
-Maybe :: union(T: typeid) #maybe {T};
+Maybe :: union($T: typeid) #maybe {T};
 
 @thread_local global_default_temp_allocator_data: Default_Temp_Allocator;
 

core/slice/map.odin

@@ -27,12 +27,12 @@ map_values :: proc(m: $M/map[$K]$V, allocator := context.allocator) -> (values:
 	return;
 }
 
-Map_Entry :: struct(Key, Value: typeid) {
+Map_Entry :: struct($Key, $Value: typeid) {
 	key:   Key,
 	value: Value,
 }
 
-Map_Entry_Info :: struct(Key, Value: typeid) {
+Map_Entry_Info :: struct($Key, $Value: typeid) {
 	hash:  uintptr,
 	key:   Key,
 	value: Value,

core/sync/channel.odin

@@ -13,7 +13,7 @@ Channel_Direction :: enum i8 {
 	Recv = -1,
 }
 
-Channel :: struct(T: typeid, Direction := Channel_Direction.Both) {
+Channel :: struct($T: typeid, $Direction := Channel_Direction.Both) {
 	using _internal: ^Raw_Channel,
 }
 

examples/demo/demo.odin

@@ -898,14 +898,14 @@ parametric_polymorphism :: proc() {
 
 
 	{ // Polymorphic Types and Type Specialization
-		Table_Slot :: struct(Key, Value: typeid) {
+		Table_Slot :: struct($Key, $Value: typeid) {
 			occupied: bool,
 			hash:     u32,
 			key:      Key,
 			value:    Value,
 		};
 		TABLE_SIZE_MIN :: 32;
-		Table :: struct(Key, Value: typeid) {
+		Table :: struct($Key, $Value: typeid) {
 			count:     int,
 			allocator: mem.Allocator,
 			slots:     []Table_Slot(Key, Value),
@@ -1042,7 +1042,7 @@ parametric_polymorphism :: proc() {
 			Foo2,
 			Foo3,
 		};
-		Para_Union :: union(T: typeid) {T, Error};
+		Para_Union :: union($T: typeid) {T, Error};
 		r: Para_Union(int);
 		fmt.println(typeid_of(type_of(r)));
 
@@ -1594,7 +1594,7 @@ where_clauses :: proc() {
 	}
 
 	{ // Record types
-		Foo :: struct(T: typeid, N: int)
+		Foo :: struct($T: typeid, $N: int)
 			where intrinsics.type_is_integer(T),
 				  N > 2 {
 			x: [N]T,
@@ -1949,7 +1949,8 @@ constant_literal_expressions :: proc() {
 union_maybe :: proc() {
 	fmt.println("\n#union #maybe");
 
-	Maybe :: union(T: typeid) #maybe {T};
+	// NOTE: This is already built-in, and this is just a reimplementation to explain the behaviour
+	Maybe :: union($T: typeid) #maybe {T};
 
 	i: Maybe(u8);
 	p: Maybe(^u8); // No tag is stored for pointers, nil is the sentinel value