Almost Alpha

Massive improvements across the board.

One day I'll adopt incremental commits.

src/bin/features/shared.rs

@@ -0,0 +1,64 @@
+use std::io::BufReader;
+use std::thread;
+
+use orchidlang::facade::loader::Loader;
+use orchidlang::libs::asynch::system::AsynchSystem;
+use orchidlang::libs::directfs::DirectFS;
+use orchidlang::libs::io::{IOService, Sink, Source, Stream};
+use orchidlang::libs::scheduler::system::SeqScheduler;
+use orchidlang::libs::std::std_system::StdConfig;
+
+pub fn stdin_source() -> Source { BufReader::new(Box::new(std::io::stdin())) }
+pub fn stdout_sink() -> Sink { Box::new(std::io::stdout()) }
+pub fn stderr_sink() -> Sink { Box::new(std::io::stderr()) }
+
+pub fn with_std_env<T>(cb: impl for<'a> FnOnce(Loader<'a>) -> T) -> T {
+  with_env(stdin_source(), stdout_sink(), stderr_sink(), cb)
+}
+
+pub fn with_env<T>(
+  stdin: Source,
+  stdout: Sink,
+  stderr: Sink,
+  cb: impl for<'a> FnOnce(Loader<'a>) -> T,
+) -> T {
+  let mut asynch = AsynchSystem::new();
+  let scheduler = SeqScheduler::new(&mut asynch);
+  let std_streams = [
+    ("stdin", Stream::Source(stdin)),
+    ("stdout", Stream::Sink(stdout)),
+    ("stderr", Stream::Sink(stderr)),
+  ];
+  let env = Loader::new()
+    .add_system(StdConfig { impure: true })
+    .add_system(asynch)
+    .add_system(scheduler.clone())
+    .add_system(IOService::new(scheduler.clone(), std_streams))
+    .add_system(DirectFS::new(scheduler));
+  cb(env)
+}
+
+pub fn worker_cnt() -> usize { thread::available_parallelism().map(usize::from).unwrap_or(1) }
+
+macro_rules! unwrap_exit {
+  ($param:expr) => {
+    match $param {
+      Ok(v) => v,
+      Err(e) => {
+        eprintln!("{e}");
+        return ExitCode::FAILURE;
+      },
+    }
+  };
+  ($param:expr; $error:expr) => {
+    match $param {
+      Ok(v) => v,
+      Err(e) => {
+        eprintln!("{e}");
+        return $error;
+      },
+    }
+  };
+}
+
+pub(crate) use unwrap_exit;