NOTINDEX of the current position
An ellipsis means there's more than 1 index for the current position rule
NOTINDEX of the current position
An ellipsis means there's more than 1 index for the current position rule 
2
"Upgraded" == "Upgradеd" >>> "Upgraded" == "Upgradеd"
False
>>> str("Upgraded") == str("Upgraded")
True 1
1
mod opaque_vec {
extern fn malloc(size: u64) -> *mut u8;
extern fn realloc(ptr: *mut u8, size: u64) -> *mut u8;
struct OpaqueVec {
ptr: *mut u8,
len: u64,
cap: u64,
element_size: u64,
}
impl OpaqueVec {
pub fn push<T>(&mut self, value: T) {
if self.len <= self.cap {
let new_cap: u64 = self.cap * 2;
self.ptr = realloc(self.ptr, self.element_size * new_cap);
self.cap = new_cap;
}
let target_ptr: *mut T = (self.ptr + (self.len * self.element_size)) as *mut T;
*target_ptr = value;
self.len = self.len + 1;
}
pub fn get<T>(&self, at: u64) -> &T {
// todo: bounds check
let target_ptr: *mut T = (self.ptr + (at * self.element_size)) as *mut T;
return target_ptr as &T;
}
}
fn main() -> i32 {
// Still missing impl static methods.
let element_size: u64 = 4;
let mut vec: OpaqueVec = OpaqueVec {
ptr: malloc(element_size * 32),
len: 0,
cap: 32,
element_size: element_size,
};
vec.push::<i32>(2);
vec.push::<i32>(3);
vec.push::<i32>(4);
vec.push::<i32>(5);
let pushed: &i32 = vec.get::<i32>(2);
return *pushed;
}
}
@MilkeeyCat no impl<T> generics yet, but i managed to get this compiling and it works, returns 4 idiv instruction 
ConvertToGreyscale does what it says 
mod vec {
extern fn malloc(size: u64) -> *mut u8;
extern fn realloc(ptr: *mut u8, size: u64) -> *mut u8;
struct Vec<T> {
ptr: *mut T,
len: u64,
cap: u64,
// needed cuz missing sizeof instrinsic
type_size: u64,
}
impl<T> Vec<T> {
pub fn push(&mut self, value: T) {
if self.len <= self.cap {
let new_cap: u64 = self.cap * 2;
self.ptr = realloc(self.ptr as *mut u8, self.type_size * new_cap) as *mut T;
self.cap = new_cap;
}
let target_ptr: *mut T = (self.ptr + (self.len * self.type_size)) as *mut T;
*target_ptr = value;
self.len = self.len + 1;
}
pub fn get(&self, at: u64) -> &T {
// todo: bounds check
let target_ptr: *mut T = (self.ptr + (at * self.type_size)) as *mut T;
return target_ptr as &T;
}
}
pub fn new_vec<T>(type_size: u64) -> Vec<T> {
let vec: Vec<T> = Vec::<T> {
ptr: malloc(type_size * 32) as *mut T,
len: 0,
cap: 32,
type_size: type_size,
};
return vec;
}
fn main() -> i32 {
// Still missing impl static methods.
let type_size: u64 = 4;
let mut vec: Vec<i32> = new_vec::<i32>(type_size);
vec.push(2);
vec.push(3);
vec.push(4);
vec.push(5);
let pushed: &i32 = vec.get(2);
return *pushed;
}
}
@MilkeeyCat even better, got impl generics working 
? I have some time on the weekend to work on it
? I have some time on the weekend to work on it 
mod vec {
extern fn malloc(size: u64) -> *mut u8;
extern fn realloc(ptr: *mut u8, size: u64) -> *mut u8;
struct Vec<T> {
ptr: *mut T,
len: u64,
cap: u64,
// needed cuz missing sizeof instrinsic
type_size: u64,
}
impl<T> Vec<T> {
pub fn push(&mut self, value: T) {
if self.len <= self.cap {
let new_cap: u64 = self.cap * 2;
self.ptr = realloc(self.ptr as *mut u8, self.type_size * new_cap) as *mut T;
self.cap = new_cap;
}
let target_ptr: *mut T = (self.ptr + (self.len * self.type_size)) as *mut T;
*target_ptr = value;
self.len = self.len + 1;
}
pub fn get(&self, at: u64) -> &T {
// todo: bounds check
let target_ptr: *mut T = (self.ptr + (at * self.type_size)) as *mut T;
return target_ptr as &T;
}
}
pub fn new_vec<T>(type_size: u64) -> Vec<T> {
let vec: Vec<T> = Vec::<T> {
ptr: malloc(type_size * 32) as *mut T,
len: 0,
cap: 32,
type_size: type_size,
};
return vec;
}
fn main() -> i32 {
// Still missing impl static methods.
let type_size: u64 = 4;
let mut vec: Vec<i32> = new_vec::<i32>(type_size);
vec.push(2);
vec.push(3);
vec.push(4);
vec.push(5);
let pushed: &i32 = vec.get(2);
return *pushed;
}
}
@MilkeeyCat even better, got impl generics working 
1mod vec {
extern fn malloc(size: u64) -> *mut u8;
extern fn realloc(ptr: *mut u8, size: u64) -> *mut u8;
struct Vec<T> {
ptr: *mut T,
len: u64,
cap: u64,
// needed cuz missing sizeof instrinsic
type_size: u64,
}
impl<T> Vec<T> {
pub fn push(&mut self, value: T) {
if self.len <= self.cap {
let new_cap: u64 = self.cap * 2;
self.ptr = realloc(self.ptr as *mut u8, self.type_size * new_cap) as *mut T;
self.cap = new_cap;
}
let target_ptr: *mut T = (self.ptr + (self.len * self.type_size)) as *mut T;
*target_ptr = value;
self.len = self.len + 1;
}
pub fn get(&self, at: u64) -> &T {
// todo: bounds check
let target_ptr: *mut T = (self.ptr + (at * self.type_size)) as *mut T;
return target_ptr as &T;
}
}
pub fn new_vec<T>(type_size: u64) -> Vec<T> {
let vec: Vec<T> = Vec::<T> {
ptr: malloc(type_size * 32) as *mut T,
len: 0,
cap: 32,
type_size: type_size,
};
return vec;
}
fn main() -> i32 {
// Still missing impl static methods.
let type_size: u64 = 4;
let mut vec: Vec<i32> = new_vec::<i32>(type_size);
vec.push(2);
vec.push(3);
vec.push(4);
vec.push(5);
let pushed: &i32 = vec.get(2);
return *pushed;
}
}
@MilkeeyCat even better, got impl generics working 
2
1
