2 files changed, 20 insertions, 5 deletions

diff --git a/core/container/array.odin b/core/container/array.odin
index 273657eb6..123440b2e 100644
--- a/core/container/array.odin
+++ b/core/container/array.odin
@@ -47,10 +47,16 @@ array_slice :: proc(a: $A/Array($T)) -> []T {
 
 
 array_get :: proc(a: $A/Array($T), index: int) -> T {
+	assert(uint(index) < a.len);
 	return (^T)(uintptr(a.data) + size_of(T)*uintptr(index))^;
 }
+array_get_ptr :: proc(a: $A/Array($T), index: int) -> ^T {
+	assert(uint(index) < a.len);
+	return (^T)(uintptr(a.data) + size_of(T)*uintptr(index));
+}
 
 array_set :: proc(a: ^$A/Array($T), index: int, item: T)  {
+	assert(uint(index) < a.len);
 	(^T)(uintptr(a.data) + size_of(T)*uintptr(index))^ = item;
 }
 
@@ -122,7 +128,7 @@ array_clear :: proc(q: ^$Q/Queue($T)) {
 }
 
 
-array_push :: proc(a: ^$A/Array($T), items: ..T) {
+array_push_back_elems :: proc(a: ^$A/Array($T), items: ..T) {
 	if array_space(a^) < len(items) {
 		array_grow(a, a.size + len(items));
 	}
@@ -133,6 +139,8 @@ array_push :: proc(a: ^$A/Array($T), items: ..T) {
 	a.len = offset + n;
 }
 
+array_push   :: proc{array_push_back, array_push_back_elems};
+array_append :: proc{array_push_back, array_push_back_elems};
 
 array_set_capacity :: proc(a: ^$A/Array($T), new_capacity: int) {
 	if new_capacity == a.cap {
diff --git a/core/mem/mem.odin b/core/mem/mem.odin
index 99a16a6c9..bafac60d5 100644
--- a/core/mem/mem.odin
+++ b/core/mem/mem.odin
@@ -107,8 +107,12 @@ ptr_sub :: inline proc "contextless" (a, b: $P/^$T) -> int {
 
 slice_ptr :: inline proc "contextless" (ptr: ^$T, len: int) -> []T {
 	assert(len >= 0);
-	slice := Raw_Slice{data = ptr, len = len};
-	return transmute([]T)slice;
+	return transmute([]T)Raw_Slice{data = ptr, len = len};
+}
+
+slice_ptr_to_bytes :: proc "contextless" (ptr: rawptr, len: int) -> []byte {
+	assert(len >= 0);
+	return transmute([]byte)Raw_Slice{data = ptr, len = len};
 }
 
 slice_to_bytes :: inline proc "contextless" (slice: $E/[]$T) -> []byte {
@@ -127,16 +131,19 @@ slice_data_cast :: inline proc "contextless" ($T: typeid/[]$A, slice: $S/[]$B) -
 	}
 }
 
+slice_to_components :: proc "contextless" (slice: $E/[]$T) -> (data: ^T, len: int) {
+	s := transmute(Raw_Slice)slice;
+	return s.data, s.len;
+}
 
 buffer_from_slice :: inline proc(backing: $T/[]$E) -> [dynamic]E {
 	s := transmute(Raw_Slice)backing;
-	d := Raw_Dynamic_Array{
+	return transmute([dynamic]E)Raw_Dynamic_Array{
 		data      = s.data,
 		len       = 0,
 		cap       = s.len,
 		allocator = nil_allocator(),
 	};
-	return transmute([dynamic]E)d;
 }
 
 ptr_to_bytes :: inline proc "contextless" (ptr: ^$T, len := 1) -> []byte {