Update a few things, put some more basics into place

Author: spacejam

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "puke"
+name = "seaslug"
 version = "0.0.0"
 authors = ["Tyler Neely <[email protected]>"]
 edition = "2018"
@@ -9,3 +9,10 @@ homepage = "https://github.com/spacejam/puke"
 repository = "https://github.com/spacejam/puke"
 
 [dependencies]
+lalrpop-util = "0.19.5"
+regex = "1.4.4"
+libc = "0.2.88"
+num_cpus = "1.13.0"
+
+[build-dependencies]
+lalrpop = "0.19.5"

README.md

@@ -1,57 +1,45 @@
-# puke
+# seaslug
 
-a language that is happy and eager to suck at many things in pursuit of 
-low-boilerplate, low-noise, highly reliable, high performance state machines 
-with enforced strict error handling and built-in fault injection.
+small, beautiful, knowable, DOESN'T EXIST YET LOL
 
-puke may become a language that encourages users to write
-code that is usable by others and respectful to themselves
-by providing superior scheduling and concurrency facilities
-compared to what is generally available in current industrial
-languages.
+* non-turing complete, verified terminating code placed into well-defined interfaces similar to Erlang behaviors
+* strongly typed, powerful inference to minimize type noise
+* a runtime built from the beginning to take advantage of io_uring, immutable messaging, optimistic STM, and generally paying attention to modern scheduling research
+  * the runtime tracks overall utilization and saturation
+  * aims to maximize utilization while minimizing saturation (writes before reads before accepts for sockets)
+  * infers contention causality encountered in the optimistic state layer and learns to step in as
+    a traffic director, letting users avoid thinking about contention
+* leans into linear logic to enforce error handling in well-specified hierarchies, similar to Erlang supervisors
+* interpreter-first, but the interpreter itself aims to compile quickly so you can produce static optimized native binaries
+* built-in first-class fault injection, fuzzing, network simulation, model-based testing, and concurrent interleaving exploration
+* rich built-in data structures, first-class json support, first-class binary parsing support
 
-##### puke should be an ideal language for building
+##### seaslug should be an ideal language for building
 
 * databases
 * distributed systems
+* servers
+* scalable concurrent systems
 * multitenant infrastructure
 
-##### puke does not aim to excel at
+##### seaslug does not aim to excel at
 
 * building your own data structures
 * intensive numerical processing
 * short-lived CLI applications
 * embedded programming
 
-##### ideas that may or may not lead to puke
+##### ideas that may or may not lead to seaslug
 
-* erlang's terseness, focus on immutable message passing, explicit supervisor hierarchies, pattern matching
-* celf's nondeterminism and linear logic 
+* erlang's terseness, behaviors, focus on immutable message passing, explicit supervisor hierarchies, pattern matching, binary parsing capabilities
+* celf's nondeterminism and linear logic
+* constraint handling rules's verification opportunities
 * prolog's declarative debugging, tables, provability of pure code
-* total functional programming
-* unison's effect systems
-* rust's restricted linear typing
-
-##### puke should excel at
-
-* testability
-  * built-in network simulation, fail-points, concurrent interleaving exploration, model-based testing support
-* optimistic concurrency
-  * shared mutable state regulated by optimistic software transactional memory, letting users avoid
-    thinking about data races
-* scheduling
-  * the runtime tracks overall utilization and saturation
-  * aims to maximize utilization while minimizing saturation (writes before reads before accepts for sockets)
-  * infers contention causality encountered in the optimistic state layer and learns to step in as 
-    a traffic director, letting users avoid thinking about contention
-* rich built-in data structures, first-class json support, first-class binary parsing support
+* total functional programming's restrictions on recursion and looping
 
-##### puke is written in rust and takes advantage of things like
+##### seaslug is written in rust and takes advantage of things like
 
 * io_uring
 * simdjson
 * sled
 * software transactional memory
-
-
-##### puke will have a gross name until it becomes something that is not actually gross

src/bin/puke.rs

@@ -1,3 +1,6 @@
+use puke::{Args, Interpreter};
+
 fn main() {
-    println!("Hello, world!");
+    let args = Args::parse();
+    Interpreter::run(args);
 }

src/lib.rs

@@ -6,3 +6,95 @@
 //! * first-class fault injection, simulation and model-based testing capabilities
 //! * built-in data structures
 //! * high quality scheduling built from the beginning to play well with io_uring and iocp
+
+mod args;
+mod ast;
+mod cache_padded;
+mod ebr;
+mod histogram;
+mod io;
+mod lazy;
+mod machine_table;
+mod stack;
+
+use lalrpop_util::lalrpop_mod;
+
+pub use self::args::Args;
+
+use self::{
+    cache_padded::CachePadded, ebr::pin, histogram::Histogram, lazy::Lazy,
+    machine_table::MachineTable, stack::Stack,
+};
+
+#[cfg(any(test, feature = "lock_free_delays"))]
+mod debug_delay;
+
+#[cfg(any(test, feature = "lock_free_delays"))]
+use debug_delay::debug_delay;
+
+lalrpop_mod!(pub syntax);
+
+/// This function is useful for inducing random jitter into our atomic
+/// operations, shaking out more possible interleavings quickly. It gets
+/// fully eliminated by the compiler in non-test code.
+#[cfg(not(any(test, feature = "lock_free_delays")))]
+const fn debug_delay() {}
+
+/// The puke interpreter.
+pub struct Interpreter {
+    ast: Ast,
+    scheduler: Scheduler,
+}
+
+impl Interpreter {
+    pub fn run(args: Args) {
+        println!(
+            "
+            +-------------------------------+
+             w e l c o m e   2   p u k e  :]
+            +-------------------------------+"
+        );
+        println!();
+        println!("{:?}", args);
+        println!();
+
+        let mut interpreter = Interpreter {
+            ast: args.module.as_ref().map(|m| Ast::load(&m)).unwrap_or(Ast),
+            scheduler: Scheduler::start(&args),
+        };
+
+        interpreter.repl();
+    }
+
+    fn repl(&mut self) {}
+}
+
+/// The puke AST.
+struct Ast;
+
+impl Ast {
+    fn load(path: &str) -> Ast {
+        todo!()
+    }
+}
+
+/// The puke scheduler.
+struct Scheduler {
+    work: MachineTable,
+}
+
+impl Scheduler {
+    fn start(args: &Args) -> Scheduler {
+        Scheduler {
+            work: MachineTable::default(),
+        }
+    }
+}
+
+struct MessageBus;
+
+struct Stm;
+
+struct Machine {
+    ast: Ast,
+}