not-python-rust/Cargo.toml

[package]
name = "not-python-rs"
version = "0.1.0"
edition = "2021"

[dependencies]
assert_matches = "1.5.0"
clap = { version = "4.5.8", features = ["derive"] }
common_macros = "0.1.1"
thiserror = "1.0.63"
gc = { version = "0.5", features = ["derive"] }
hashbrown = "0.15.0"
Base initial commit Still WIP, working on object system still, which in Rust, makes me want to kill myself Signed-off-by: Alek Ratzloff <alekratz@gmail.com> 2024-09-20 16:04:30 -07:00			`[package]`
			`name = "not-python-rs"`
			`version = "0.1.0"`
			`edition = "2021"`

			`[dependencies]`
			`assert_matches = "1.5.0"`
			`clap = { version = "4.5.8", features = ["derive"] }`
			`common_macros = "0.1.1"`
			`thiserror = "1.0.63"`
Revamp object system, start using `gc` crate Wow, what a ride. I think everything should be working now. In short: * Objects use the `gc` crate, which as a `Gc` garbage-collected pointer type. I may choose to implement my own in contiguous memory in the future. We will see. * The type system is no longer global. This is a bit of a burden, because now, whenever you want to create a new object, you need to pass its type object into the `Obj::instantiate` method, as well as its `::create` static method. * This burden is somewhat alleviated by the `ObjFactory` trait, which helps create new objects as long as you have access to a `builtins` hashmap. So something that would normally look like this: fn init_builtins(builtins: &mut HashMap<String, ObjP>) { let print_builtin = upcast_obj(BuiltinFunctionInst::create( ObjP::clone(&builtins.get("BuiltinFunction").unwrap()), "print", print, 1 ); builtins.insert("print".to_string(), print_builtin) // other builtins inserted here... } now looks like this: fn init_builtins(builtins: &mut HashMap<String, ObjP>) { let print_builtin = builtins.create_builtin_function("print", print, 1); builtins.insert("print".to_string(), print_builtin); } (turns out, if all you need is a HashMap<String, ObjP>, you can implement ObjFactory for HashMap<String, ObjP> itself(!)) Overall, I'm happier with this design, and I think this is what is going to get merged. It's a little weird to be querying type names that are used in the language itself to get those type objects, but whatever works, I guess. Next up is vtables. Signed-off-by: Alek Ratzloff <alekratz@gmail.com> 2024-09-23 18:12:32 -07:00			`gc = { version = "0.5", features = ["derive"] }`
Add Map type, add hashbrown crate dependency We should have a preliminary implementation of maps going right now. Thus far we have: * Map.insert * Map.__index__ * Map.remove And some other minor functions. The big news with this is the couple of pretty hot `unsafe` calls that borrow the VM mutably in two different closures, simultaneously. This should be safe since these two different closures aren't being called at the same time, somehow. Maybe one could be calling the other. But that's not happening (I checked). This also adds the hashbrown crate to handle the actual hashtable implementation, so we don't have to implement our own hashtables. Signed-off-by: Alek Ratzloff <alekratz@gmail.com> 2024-10-14 19:05:27 -07:00			`hashbrown = "0.15.0"`