Merge branch 'main' of https://gitlab.com/mech-lang/mech

Author: cmontella

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mech"
-version = "0.2.6"
+version = "0.2.7"
 authors = ["Corey Montella <[email protected]>"]
 description = "Toolchain for the Mech programming language."
 documentation = "https://mech-lang.org/docs"
@@ -18,20 +18,20 @@ gitlab = { repository = "mech-lang/mech", branch = "main" }
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-mech-core = "0.2.6"
-mech-syntax = "0.2.6"
+mech-core = "0.2.7"
+mech-syntax = "0.2.7"
 #mech-program = "0.2.2"
 #mech-utilities = "0.2.2"
 
-clap = {version = "4.5.13", features = ["cargo"]}
+clap = {version = "4.5.15", features = ["cargo"]}
 colored = "2.1.0"
 #nom = "7.1.3"
 #hashbrown = "0.14.5"
 #reqwest = {version = "0.12.4", features = ["blocking"]}
 bincode = "1.3.3"
-serde = "1.0.204"
-serde_derive = "1.0.204"
-serde_json = "1.0.122"
+serde = "1.0.207"
+serde_derive = "1.0.207"
+serde_json = "1.0.124"
 crossbeam-channel = "0.5.13"
 #seahash = "4.1.0"
 crossterm = "0.28.1"
@@ -69,16 +69,7 @@ mech-utilities = { path = 'src/utilities'}
 mech-wasm = { path = 'src/wasm'}
 
 [patch.'https://gitlab.com/mech-lang/core']
-mech-core = { path = 'src/core', version = '0.2.1' }
+mech-core = { path = 'src/core', version = '0.2.7' }
 
 [patch.'https://gitlab.com/mech-lang/syntax']
-mech-syntax = { path = 'src/syntax', version = '0.2.1' }
-
-[patch.'https://gitlab.com/mech-lang/program']
-mech-program = { path = 'src/program', version = '0.2.1' }
-
-[patch.'https://gitlab.com/mech-lang/utilities']
-mech-utilities = { path = 'src/utilities', version = '0.2.1' }
-
-[patch.'https://gitlab.com/mech-lang/wasm']
-mech-wasm = { path = 'src/wasm', version = '0.2.1' }
+mech-syntax = { path = 'src/syntax', version = '0.2.7' }

src/bin/mech.rs

@@ -4,7 +4,7 @@ use mech::format_parse_tree;
 use mech_core::*;
 use mech_syntax::parser;
 //use mech_syntax::analyzer::*;
-use mech_syntax::interpreter::*;
+use mech_core::interpreter::*;
 use std::time::Instant;
 use std::fs;
 use std::env;
@@ -25,7 +25,7 @@ use serde_json;
 
 
 fn main() -> Result<(), MechError> {
-  let version = "0.2.6";
+  let version = "0.2.7";
   let text_logo = r#"
   ┌─────────┐ ┌──────┐ ┌─┐ ┌──┐ ┌─┐   ┌─┐
   └───┐ ┌───┘ └──────┘ │ │ └┐ │ │ │   │ │

src/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mech-core"
-version = "0.2.6"
+version = "0.2.7"
 authors = ["Corey Montella <[email protected]>"]
 description = "The Mech language runtime."
 documentation = "http://docs.mech-lang.org"
@@ -25,8 +25,8 @@ wasm = ["web-sys", "wasm-bindgen"]
 
 [dependencies]
 hashbrown = "0.14.5"
-serde = {version = "1.0.204", default-features = false, features = ["alloc"] }
-serde_derive = "1.0.204"
+serde = {version = "1.0.207", default-features = false, features = ["alloc"] }
+serde_derive = "1.0.207"
 rlibc = { version = "=1.0", optional = true }
 lazy_static = "1.5.0"
 seahash = "4.1.0"
@@ -38,11 +38,15 @@ getrandom = { version = "0.2.15", features = ["js"]}
 rand = {version = "0.8.5"}
 tinyrand = "0.5.0"
 rand_core = {version = "0.6.4"}
-wasm-bindgen = {version = "0.2.92", optional = true}
+wasm-bindgen = {version = "0.2.93", optional = true}
 nalgebra = "0.33.0"
+simba = "0.9.0"
+libm = "0.2.8"
+tabled = "0.16.0"
+paste = "1.0.15"
 
 [dependencies.web-sys]
-version = "0.3.69"
+version = "0.3.70"
 features = [
   'Document',
   'Element',

src/core/src/enums.rs

@@ -1,9 +1,9 @@
 use crate::types::*;
 use crate::value::*;
 use crate::interpreter::*;
+use crate::nodes::*;
+use crate::*;
 
-use mech_core::*;
-use mech_core::nodes::*;
 use hashbrown::{HashMap, HashSet};
 use indexmap::map::IndexMap;
 use std::rc::Rc;

src/syntax/src/functions.rs renamed to src/core/src/functions.rs

@@ -4,11 +4,12 @@ use crate::stdlib::math::*;
 use crate::stdlib::logic::*;
 use crate::stdlib::compare::*;
 use crate::stdlib::matrix::*;
-use crate::stdlib::range::*;
+use crate::stdlib::table::*;
+use crate::stdlib::range::{RangeInclusive, RangeExclusive};
 use crate::*;
+use crate::{MechError, MechErrorKind, hash_str, nodes::Kind as NodeKind, nodes::*};
+use crate::nodes::Matrix as Mat;
 
-use mech_core::{MechError, MechErrorKind, hash_str, nodes::Kind as NodeKind, nodes::*};
-use mech_core::nodes::Matrix as Mat;
 use na::DMatrix;
 use indexmap::set::IndexSet;
 use indexmap::map::IndexMap;
@@ -58,8 +59,6 @@ impl Interpreter {
   }
 }
 
-
-
 //-----------------------------------------------------------------------------
 
 fn program(program: &Program, plan: Plan, symbols: SymbolTableRef, functions: FunctionsRef) -> MResult<Value> {
@@ -88,7 +87,6 @@ fn section_element(element: &SectionElement, plan: Plan, symbols: SymbolTableRef
     SectionElement::Section(sctn) => todo!(),
     SectionElement::Comment(cmmnt) => Value::Empty,
     SectionElement::Paragraph(p) => Value::Empty,
-    SectionElement::MechCode(code) => todo!(),
     SectionElement::UnorderedList(ul) => todo!(),
     SectionElement::CodeBlock => todo!(),
     SectionElement::OrderedList => todo!(),
@@ -351,24 +349,12 @@ fn subscript(sbscrpt: &Subscript, val: &Value, plan: Plan, symbols: SymbolTableR
   match sbscrpt {
     Subscript::Dot(x) => {
       let key = x.hash();
-      match val {
-        Value::Record(rcrd) => {
-          match rcrd.map.get(&Value::Id(key)) {
-            Some(value) => return Ok(value.clone()),
-            None => { return Err(MechError{tokens: x.tokens(), msg: file!().to_string(), id: line!(), kind: MechErrorKind::UndefinedField(key)});}
-          }
-        }
-        Value::MutableReference(r) => match &*r.borrow() {
-          Value::Record(rcrd) => {
-            match rcrd.map.get(&Value::Id(key)) {
-              Some(value) => return Ok(value.clone()),
-              None => { return Err(MechError{tokens: x.tokens(), msg: file!().to_string(), id: line!(), kind: MechErrorKind::UndefinedField(key)});}
-            }
-          }
-          _ => todo!(),
-        }
-        _ => todo!(),
-      }
+      let fxn_input: Vec<Value> = vec![val.clone(), Value::Id(key)];
+      let new_fxn = AccessColumn{}.compile(&fxn_input)?;
+      new_fxn.solve();
+      let res = new_fxn.out();
+      plan.borrow_mut().push(new_fxn);
+      return Ok(res);
     },
     Subscript::DotInt(x) => {
       let mut fxn_input = vec![val.clone()];
@@ -584,7 +570,7 @@ fn set(m: &Set, plan: Plan, symbols: SymbolTableRef, functions: FunctionsRef) ->
 
 fn table(t: &Table, plan: Plan, symbols: SymbolTableRef, functions: FunctionsRef) -> MResult<Value> { 
   let mut rows = vec![];
-  let header = table_header(&t.header)?;
+  let (ids,col_kinds) = table_header(&t.header, functions.clone())?;
   let mut cols = 0;
   // Interpret the rows
   for row in &t.rows {
@@ -605,21 +591,35 @@ fn table(t: &Table, plan: Plan, symbols: SymbolTableRef, functions: FunctionsRef
   }
   // Build the table
   let mut data_map = IndexMap::new();
-  for (field_label,column) in header.iter().zip(data.iter()) {
-    data_map.insert(field_label.clone(),column.clone());
+  for (field_label,(column,knd)) in ids.iter().zip(data.iter().zip(col_kinds)) {
+    let val = Value::to_matrix(column.clone(),column.len(),1);
+    match knd {
+      ValueKind::I64 => {data_map.insert(field_label.clone(),(knd,val));},
+      ValueKind::U8 => {
+        let vals: Vec<Value> = val.as_vec().iter().map(|x| x.as_u8().unwrap().to_value()).collect::<Vec<Value>>();
+        data_map.insert(field_label.clone(),(knd,Value::to_matrix(vals.clone(),vals.len(),1)));
+      },
+      ValueKind::Bool => {
+        let vals: Vec<Value> = val.as_vec().iter().map(|x| x.as_bool().unwrap().to_value()).collect::<Vec<Value>>();
+        data_map.insert(field_label.clone(),(knd,Value::to_matrix(vals.clone(),vals.len(),1)));
+      },
+      _ => todo!(),
+    };
   }
   let tbl = MechTable{rows: t.rows.len(), cols, data: data_map.clone()  };
   Ok(Value::Table(tbl))
 }
 
-fn table_header(fields: &Vec<Field>) -> MResult<Vec<Value>> {
-  let mut row: Vec<Value> = Vec::new();
+fn table_header(fields: &Vec<Field>, functions: FunctionsRef) -> MResult<(Vec<Value>,Vec<ValueKind>)> {
+  let mut ids: Vec<Value> = Vec::new();
+  let mut kinds: Vec<ValueKind> = Vec::new();
   for f in fields {
     let id = f.name.hash();
-    let kind = &f.kind;
-    row.push(Value::Id(id));
+    let kind = kind_annotation(&f.kind.kind, functions.clone())?;
+    ids.push(Value::Id(id));
+    kinds.push(kind.to_value_kind(functions.clone())?);
   }
-  Ok(row)
+  Ok((ids,kinds))
 }
 
 fn table_row(r: &TableRow, plan: Plan, symbols: SymbolTableRef, functions: FunctionsRef) -> MResult<Vec<Value>> {
@@ -693,8 +693,8 @@ fn matrix_row(r: &MatrixRow, plan: Plan, symbols: SymbolTableRef, functions: Fun
     Value::I32(_)  => {Value::MatrixI32(i32::to_matrix(row.iter().map(|v| v.as_i32().unwrap().borrow().clone()).collect(),1,row.len()))},
     Value::I64(_)  => {Value::MatrixI64(i64::to_matrix(row.iter().map(|v| v.as_i64().unwrap().borrow().clone()).collect(),1,row.len()))},
     Value::I128(_) => {Value::MatrixI128(i128::to_matrix(row.iter().map(|v| v.as_i128().unwrap().borrow().clone()).collect(),1,row.len()))},
-    Value::F32(_)  => {Value::MatrixF32(F32::to_matrix(row.iter().map(|v| F32::new(v.as_f32().unwrap().borrow().clone())).collect(),1,row.len()))},
-    Value::F64(_)  => {Value::MatrixF64(F64::to_matrix(row.iter().map(|v| F64::new(v.as_f64().unwrap().borrow().clone())).collect(),1,row.len()))},
+    Value::F32(_)  => {Value::MatrixF32(F32::to_matrix(row.iter().map(|v| v.as_f32().unwrap().borrow().clone()).collect(),1,row.len()))},
+    Value::F64(_)  => {Value::MatrixF64(F64::to_matrix(row.iter().map(|v| v.as_f64().unwrap().borrow().clone()).collect(),1,row.len()))},
     _ => todo!(),
   };
   Ok(mat)
@@ -779,7 +779,7 @@ fn term(trm: &Term, plan: Plan, symbols: SymbolTableRef, functions: FunctionsRef
       FormulaOperator::Comparison(ComparisonOp::GreaterThan) => CompareGreaterThan{}.compile(&vec![lhs,rhs])?,
 
       FormulaOperator::Logic(LogicOp::And) => LogicAnd{}.compile(&vec![lhs,rhs])?,
-      FormulaOperator::Logic(LogicOp::Or) => LogicOr{}.compile(&vec![lhs,rhs])?,
+      FormulaOperator::Logic(LogicOp::Or)  => LogicOr{}.compile(&vec![lhs,rhs])?,
       FormulaOperator::Logic(LogicOp::Not) => LogicNot{}.compile(&vec![lhs,rhs])?,
       FormulaOperator::Logic(LogicOp::Xor) => LogicXor{}.compile(&vec![lhs,rhs])?,
     };