Crate v9

v9 is a clean, easy to use, and flexible data engine.

It provides a means to implement applications using Data Oriented Design.

#[v9::table]
struct engines {
    pub cylinder_count: u8,
    pub lines_of_code: u64,
}

use v9::prelude::Universe;
let mut universe = Universe::new();

use v9::prelude::Register;
engines::Marker::register(&mut universe);

let (v9, v11) = universe.eval(|mut engines: engines::Write| {
    (
        engines.push(engines::Row {
            cylinder_count: 9,
            lines_of_code: 5000,
        }),
        engines.push(engines::Row {
            cylinder_count: 11,
            lines_of_code: std::u64::MAX,
        }),
    )
});

#[v9::table]
struct projects {
    pub name: &'static str,
    pub engine: crate::engines::Id,
}

projects::Marker::register(&mut universe);
universe.eval(|mut projects: projects::Write| {
    projects.push(projects::Row {
        name: "TOP SECRET!",
        engine: v9,
    });
    projects.push(projects::Row {
        name: "Stinky Cheese Inc!",
        engine: v11,
    });
});

universe.eval(|projects: projects::Read| {
    assert_eq!(projects.iter().count(), 2);
});

universe.eval(|mut engines: engines::Write| {
    engines.remove(v11);
});

universe.eval(|projects: projects::Read| {
    // No dangling pointers!
    assert_eq!(projects.iter().count(), 1);
});

(Another example.)

Design

A Universe works like a HashMap<TypeId, Any>. A single instance of any type can be inserted into the universe. Changes can then be made by running a Kernel. A Kernel is any closure whose arguments all implement Extract, a trait that works like fn extract(&Universe) -> Self.

Encapsulation

This crate makes an unreasonable amount of things public. It’s very intentional! It’s hard to foresee all needs; hopefully you can do something useful with them, and this is more honest than making things pub to satisfy my whims.

A serious application should provide its own interfaces to hide v9 behind.

Safety

┐(ツ)┌

My priorities are:

1. A beautiful API.
2. Gotta go fast:
   • Compile-times must be fast.
   • Bulk operations (via kernels) must be h*ckin’ fast.
3. Safety.

Monkey-proofing is not a high priority. That said, you’ll probably only have trouble if you go looking for it.

If you’ve tripped over something, that we’d maybe wish didn’t compile, and it doesn’t blow up at runtime in an obvious way, then I’ll be concerned.

Modules

column	Columns and their extractions.
event	Mechanisms for responding to events.
extract	Extracting values from the Universe.
id	Ids, lists of Ids, and various iterators.
kernel	Running functions over the Universe.
linkage	Connecting tables.
lock	Low-level locking.
object	The Universe, and interacting with it as a data structure.
prelude	A tasteful set of items.
prelude_lib	An indiscriminant selection of most things.
prelude_macro	Provides a single import statement for decl_table!.
property	Singleton values.
table
util

Macros

decl_context	Extract many things at once.
decl_property	Declares a singleton property.
decl_table	Defines a table. This is the most important item in the crate!