@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.2

package/rust/core/preprocessor/resolver/group.rs

@@ -14,26 +14,16 @@ pub fn resolve_group(
 ) -> Statement {
     let logger = Logger::new();
 
-    let Value::Map(group_map) = &stmt.value else {
-        return type_error(
-            &logger,
-            module,
-            stmt,
-            "Expected a map in group statement".to_string(),
-        );
+    // Extract identifier from several allowed shapes (map.identifier, bare string, number -> to_string)
+    let identifier = match extract_group_identifier(stmt, &logger, module) {
+        Ok(id) => id,
+        Err(err_stmt) => return err_stmt,
     };
 
-    // Check for the presence of the identifier field
-    let identifier = match group_map.get("identifier") {
-        Some(Value::String(id)) => id.clone(),
-        _ => {
-            return type_error(
-                &logger,
-                module,
-                stmt,
-                "Group statement must have an 'identifier' field".to_string(),
-            );
-        }
+    // group_map: if the value is a map we clone it, otherwise create an empty map to hold body
+    let group_map = match &stmt.value {
+        Value::Map(m) => m.clone(),
+        _ => std::collections::HashMap::new(),
     };
 
     // Ensure the identifier does not already exist
@@ -92,3 +82,41 @@ fn type_error(logger: &Logger, module: &Module, stmt: &Statement, message: Strin
         ..stmt.clone()
     }
 }
+
+// Helper to extract a group identifier from multiple Value forms
+fn extract_group_identifier(
+    stmt: &Statement,
+    logger: &Logger,
+    module: &Module,
+) -> Result<String, Statement> {
+    match &stmt.value {
+        Value::Map(map) => match map.get("identifier") {
+            Some(Value::String(s)) => Ok(s.clone()),
+            Some(Value::Identifier(s)) => Ok(s.clone()),
+            Some(Value::Number(n)) => Ok(n.to_string()),
+            Some(other) => Err(type_error(
+                logger,
+                module,
+                stmt,
+                format!("Unsupported type for 'identifier': {:?}", other),
+            )),
+            None => Err(type_error(
+                logger,
+                module,
+                stmt,
+                "Group statement must have an 'identifier' field".to_string(),
+            )),
+        },
+        Value::String(s) => Ok(s.clone()),
+        Value::Identifier(s) => Ok(s.clone()),
+        other => Err(type_error(
+            logger,
+            module,
+            stmt,
+            format!(
+                "Expected a map or string for group statement, found {:?}",
+                other
+            ),
+        )),
+    }
+}

package/rust/core/preprocessor/resolver/let_.rs

@@ -1,32 +1,32 @@
-use crate::core::{
-    parser::statement::Statement,
-    preprocessor::{module::Module, resolver::value::resolve_value},
-    store::global::GlobalStore,
-};
-
-pub fn resolve_let(
-    stmt: &Statement,
-    name: &str,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore,
-) -> Statement {
-    let resolved_value = resolve_value(&stmt.value, module, global_store);
-
-    global_store
-        .variables
-        .set(name.to_string(), resolved_value.clone());
-
-    if let Some(current_mod) = global_store.modules.get_mut(path) {
-        current_mod
-            .variable_table
-            .set(name.to_string(), resolved_value.clone());
-    } else {
-        eprintln!("[resolve_statement] ❌ Module path not found: {path}");
-    }
-
-    Statement {
-        value: resolved_value,
-        ..stmt.clone()
-    }
-}
+use crate::core::{
+    parser::statement::Statement,
+    preprocessor::{module::Module, resolver::value::resolve_value},
+    store::global::GlobalStore,
+};
+
+pub fn resolve_let(
+    stmt: &Statement,
+    name: &str,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Statement {
+    let resolved_value = resolve_value(&stmt.value, module, global_store);
+
+    global_store
+        .variables
+        .set(name.to_string(), resolved_value.clone());
+
+    if let Some(current_mod) = global_store.modules.get_mut(path) {
+        current_mod
+            .variable_table
+            .set(name.to_string(), resolved_value.clone());
+    } else {
+        eprintln!("[resolve_statement] ❌ Module path not found: {path}");
+    }
+
+    Statement {
+        value: resolved_value,
+        ..stmt.clone()
+    }
+}