Merge branch 'v0.2-beta' into 'main'

V0.2.26 beta

See merge request mech-lang/mech!89

Author: cmontella

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mech"
-version = "0.2.25"
+version = "0.2.26"
 authors = ["Corey Montella <[email protected]>"]
 description = "Mech is a reactive programming language for building robots, games, and animations."
 documentation = "https://mech-lang.org/docs"
@@ -18,9 +18,9 @@ gitlab = { repository = "mech-lang/mech", branch = "main" }
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-mech-core = "0.2.25"
-mech-syntax = "0.2.25"
-mech-interpreter = "0.2.25"
+mech-core = "0.2.26"
+mech-syntax = "0.2.26"
+mech-interpreter = "0.2.26"
 
 clap = {version = "4.5.21", features = ["cargo"]}
 colored = "2.1.0"
@@ -60,10 +60,10 @@ mech-interpreter = { path = 'src/interpreter'}
 #mech-logic = { path = '../machines/logic' }
 
 [patch.'https://gitlab.com/mech-lang/core']
-mech-core = { path = 'src/core', version = '0.2.25' }
+mech-core = { path = 'src/core', version = '0.2.26' }
 
 [patch.'https://gitlab.com/mech-lang/syntax']
-mech-syntax = { path = 'src/syntax', version = '0.2.25' }
+mech-syntax = { path = 'src/syntax', version = '0.2.26' }
 
 [patch.'https://gitlab.com/mech-lang/interpreter']
-mech-interpreter = { path = 'src/interpreter', version = '0.2.25' }
+mech-interpreter = { path = 'src/interpreter', version = '0.2.26' }

README.md

@@ -18,22 +18,45 @@ Comprehensive documentation is available at [mech-lang.org](https://mech-lang.or
 
 Download the latest release for your platform [here](https://github.com/mech-lang/mech/releases/latest).
 
-### 🔨 From Source
+### 📦 From Source
 
-To build Mech from source, you’ll need to install [Rust](https://www.rust-lang.org/learn/get-started) (nightly version). Follow the instructions below to compile the Mech toolchain, bundled in a single executable called `mech`:
+To build Mech from source, you’ll first need to install [Rust](https://www.rust-lang.org/learn/get-started) (make sure to install a recent version on the nightly release channel). 
+
+Then follow the instructions below to compile the Mech toolchain, bundled in a single executable called `mech`:
 
 ```bash
 git clone https://gitlab.com/mech-lang/mech
 cd mech
 cargo build --bin mech --release
 ```
 
-## 🚧 Project Roadmap
+### 🪐 Community
+
+- 👾 [Discord](https://discord.gg/asqP25NNTH) - for live chat
+- 🐙 [GitHub](https://github.com/mech-lang) - for code and issues
+- 📺 [YouTube](https://youtube.com/@coreymontella3520?si=EUy2Mrv1aNo-4uQr) - for video tutorials
+- 🛸 [Reddit](https://www.reddit.com/r/mechlang/) - for help and discussion
+
+## 🗺️ Project Roadmap
+
+Mech v0.2 is currecntly **beta** status, meaning most intended features are implemented, but there are still rough edges and a general lack of documentation.
+
+This release focuses on specifying data and formulas.
+
+A Brief Roadmap:
+
+- 📍 v0.2 - data specification - formulas, defining and manipulating data
+- v0.3 - program specification - functions, modules, state machines
+- v0.4 - system specification - tools, distributed programs, capabilities
+
+For more details, read the [ROADMAP](ROADMAP.mec).
+
+A new version of Mech is [released every week](https://github.com/mech-lang/mech/releases).
 
-Mech is being redesigned to integrate state machines into the language, with development happening in the v0.2-beta branch.
+## 🐲 Notice
 
-The v0.2 release is planned for October 2024. For more details, check out the [ROADMAP.mec](ROADMAP.mec).
+Mech should be considered unstable and therefore unfit for use in critical systems until v1.0 is released.
 
 ## ⚖️ License
 
-Licensed under [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0).
+Licensed under [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0).

ROADMAP.mec

@@ -9,20 +9,73 @@ Mech Project Roadmap
 Conception: started 2014
 Implementation: started 2018
 
-(b) Stage 2 - Beta v0.1.0 - ?
+(b) Stage 2 - Beta v0.1.0 - v0.4+ (???)
 
 Started: December 2022
-Currently: v0.2.7 (2024)
+Currently: v0.2.25 (2024)
 
-- v0.2 (data specification)
-- v0.3 (program specification) 
-- v0.4 (system specification) 
+- v0.2 (data specification)    (Wrapping Up)
+- v0.3 (program specification) (Starting in 2025)
+- v0.4 (system specification)
 
 (c) Stage 3 - Stable v1.0.0
 
 Target release date: ???
 
-2. Nearterm Goals
+2. Feature Status
+-------------------------------------------------------------------------------
+
+o - concept
+p - proof of concept implementation
+a - alpha implementation
+b - beta implementation
+c - feature complete
+
+a) Data Specification
+  - variety of numerical datatypes
+  - imaginary and scientific numbers
+  - flexible matrix type with fixed and dynamic sizes for homogeneous data
+  - typed tables for heterogeneous data
+  - sets
+  - maps
+  - enums
+  - bools
+  - strings
+  - atoms
+  - variable slicing
+  - operator broadcasting
+  - builtin linear algebra tools
+  - logical indexing
+  - matrix builder notation
+  - variable type and size checking
+  - variable type inference
+  - standard library functions
+
+b) Program Specification
+  - physical units with dimension checking
+  - state machines
+  - user functions
+  - automatic differentiation
+  - introspection
+  - tests
+  - profiler
+  - file/parameter server
+  - repl
+  - gui
+  - executables
+  - time travel debugging
+  - literate programming
+  - live coding
+  - multiple dynamic dispatch
+  - language server
+  
+c) System specification
+  - capability permissions
+  - gpgpu
+  - distributed programs
+  - concurrent programming
+
+3. Nearterm Goals
 -------------------------------------------------------------------------------
 
 Version 0.3.0 (Spring 2025) ---------------------------------------------------

src/bin/main.rs

@@ -11,6 +11,7 @@ use std::time::Instant;
 use std::fs;
 extern crate nalgebra as na;
 use na::{Vector3, DVector, RowDVector, Matrix1, Matrix3, Matrix4, RowVector3, RowVector4, RowVector2, DMatrix, Rotation3, Matrix2x3, Matrix6, Matrix2};
+use std::thread;
 
 fn main() -> Result<(),MechError> {
 
@@ -20,43 +21,49 @@ fn main() -> Result<(),MechError> {
 
     match parser::parse(&s) {
         Ok(tree) => { 
-          println!("----------- SYNTAX TREE ---------");
-          println!("{:?}",hash_str(&format!("{:#?}", tree)));
-          println!("{:#?}", tree);
-          //let result = analyze(&tree);
-          //println!("A: {:#?}", result);
-          let mut intrp = Interpreter::new();
-          let result = intrp.interpret(&tree)?;
-          
-          println!("{:#?}", intrp.symbols);
-          println!("{}", result.pretty_print());
-
-          /*{
-            let plan_brrw = intrp.plan.borrow();
-            let p1 = &plan_brrw[1];
-            println!("&&& {:?}", p1.out());
-          }*/
-
-          println!("Plan: ");
-          for fxn in intrp.plan.borrow().iter() {
-            println!("  - {}", fxn.to_string());
-          }
-
-          let now = Instant::now();
-          let n = 1e3 as usize;
-          for _ in 0..n {
+          let handle = thread::spawn(move || {
+            println!("----------- SYNTAX TREE ---------");
+            println!("{:?}",hash_str(&format!("{:#?}", tree)));
+            println!("{:#?}", tree);
+            //let result = analyze(&tree);
+            //println!("A: {:#?}", result);
+            let mut intrp = Interpreter::new();
+            let result = intrp.interpret(&tree).unwrap();
+            
+            println!("{:#?}", intrp.symbols);
+            println!("{}", result.pretty_print());
+
+            /*{
+              let plan_brrw = intrp.plan.borrow();
+              let p1 = &plan_brrw[1];
+              println!("&&& {:?}", p1.out());
+            }*/
+
+            println!("Plan: ");
             for fxn in intrp.plan.borrow().iter() {
-              fxn.solve();
+              println!("  - {}", fxn.to_string());
             }
-          }
-          let elapsed_time = now.elapsed();
-          let cycle_duration = elapsed_time.as_nanos() as f64;
-          println!("{:0.2?} ns", cycle_duration / n as f64);
 
-          let tree_string = hash_str(&format!("{:#?}", tree));
-          println!("{:?}", tree_string);
+            let plan_brrw = intrp.plan.borrow();
+            let now = Instant::now();
+            let n = 1e6 as usize;
+            for _ in 0..n {
+              for fxn in plan_brrw.iter() {
+                fxn.solve();
+              }
+            }
+            let elapsed_time = now.elapsed();
+            let cycle_duration = elapsed_time.as_nanos() as f64;
+            println!("Total Time: {:0.2?} ns", cycle_duration as f64);
+            println!("Cycle Time: {:0.2?} ns", cycle_duration / n as f64);
+
+             
 
+            let tree_string = hash_str(&format!("{:#?}", tree));
+            println!("{:?}", tree_string);
+          });
 
+          handle.join().unwrap();
 
           //let mut ast = Ast::new();
           //ast.build_syntax_tree(&tree);