jaclang 0.7.20__tar.gz → 0.7.21__tar.gz

{jaclang-0.7.20 → jaclang-0.7.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.20
+Version: 0.7.21
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 Home-page: https://jaseci.org
 License: MIT

{jaclang-0.7.20 → jaclang-0.7.21}/jaclang/compiler/jac.lark

@@ -25,7 +25,7 @@ from_path: (DOT | ELLIPSIS)* import_path
          | (DOT | ELLIPSIS)+
 
 import_path: named_ref (DOT named_ref)* (KW_AS NAME)?
-import_items: (import_item COMMA)* import_item
+import_items: (import_item COMMA)* import_item COMMA?
 import_item: named_ref (KW_AS NAME)?
 sub_name: COLON NAME
 include_stmt: KW_INCLUDE sub_name? import_path SEMI
@@ -63,7 +63,7 @@ enum: decorators? enum_decl
 
 enum_decl: KW_ENUM access_tag? STRING? NAME inherited_archs? (enum_block | SEMI)
 enum_def: arch_to_enum_chain enum_block
-enum_block: LBRACE ((enum_stmt COMMA)* enum_stmt)? RBRACE
+enum_block: LBRACE ((enum_stmt COMMA)* enum_stmt COMMA?)? RBRACE
 
 enum_stmt: NAME (COLON STRING)? EQ expression
          | NAME (COLON STRING)?
@@ -83,7 +83,7 @@ abstract_ability: KW_OVERRIDE? KW_STATIC? KW_CAN access_tag? STRING? named_ref (
 genai_ability: KW_OVERRIDE? KW_STATIC? KW_CAN access_tag? STRING? named_ref (func_decl) KW_BY atomic_call SEMI
 event_clause: KW_WITH expression? (KW_EXIT | KW_ENTRY) (STRING? RETURN_HINT expression)?
 func_decl: (LPAREN func_decl_params? RPAREN)? (RETURN_HINT (STRING COLON)? expression)?
-func_decl_params: (param_var COMMA)* param_var
+func_decl_params: (param_var COMMA)* param_var COMMA?
 param_var: (STAR_POW | STAR_MUL)? NAME (COLON STRING)? type_tag (EQ expression)?
 
 // Global variables
@@ -364,9 +364,9 @@ index_slice: LSQUARE expression? COLON expression? (COLON expression?)? RSQUARE
 // Function calls
 atomic_call: atomic_chain LPAREN param_list? (KW_BY atomic_call)? RPAREN
 
-param_list: expr_list COMMA kw_expr_list
-          | kw_expr_list
-          | expr_list
+param_list: expr_list COMMA kw_expr_list COMMA?
+          | kw_expr_list COMMA?
+          | expr_list COMMA?
 
 // Atom
 atom: named_ref
@@ -412,20 +412,20 @@ set_compr: LBRACE expression inner_compr+ RBRACE
 dict_compr: LBRACE kv_pair inner_compr+ RBRACE
 inner_compr: KW_ASYNC? KW_FOR atomic_chain KW_IN pipe_call (KW_IF walrus_assign)*
 
-dict_val: LBRACE ((kv_pair COMMA)* kv_pair)? RBRACE
-list_val: LSQUARE expr_list? RSQUARE
+dict_val: LBRACE ((kv_pair COMMA)* kv_pair COMMA?)? RBRACE
+list_val: LSQUARE (expr_list COMMA?)? RSQUARE
 tuple_val: LPAREN tuple_list? RPAREN
-set_val: LBRACE expr_list RBRACE
+set_val: LBRACE expr_list COMMA? RBRACE
 
 kv_pair: expression COLON expression | STAR_POW expression
 expr_list: (expr_list COMMA)? expression
 
 // Tuples and Jac Tuples
-tuple_list: expression COMMA expr_list COMMA kw_expr_list
-          | expression COMMA kw_expr_list
-          | expression COMMA expr_list
+tuple_list: expression COMMA expr_list COMMA kw_expr_list COMMA?
+          | expression COMMA kw_expr_list COMMA?
+          | expression COMMA expr_list COMMA?
           | expression COMMA
-          | kw_expr_list
+          | kw_expr_list COMMA?
 
 kw_expr_list: (kw_expr_list COMMA)? kw_expr
 kw_expr: named_ref EQ expression | STAR_POW expression
@@ -662,4 +662,4 @@ FSTR_BESC.1: /{{|}}/
 COMMENT: /#\*(.|\n|\r)*?\*#|#.*/
 WS.-2: /[ \t\f\r\n]/+
 %ignore COMMENT
-%ignore WS
+%ignore WS

{jaclang-0.7.20 → jaclang-0.7.21}/jaclang/compiler/parser.py

@@ -429,7 +429,7 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.ModuleItem]:
             """Grammar rule.
 
-            import_items: (import_item COMMA)* import_item
+            import_items: (import_item COMMA)* import_item COMMA?
             """
             ret = ast.SubNodeList[ast.ModuleItem](
                 items=[i for i in kid if isinstance(i, ast.ModuleItem)],
@@ -693,7 +693,7 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.EnumBlockStmt]:
             """Grammar rule.
 
-            enum_block: LBRACE ((enum_stmt COMMA)* enum_stmt)? RBRACE
+            enum_block: LBRACE ((enum_stmt COMMA)* enum_stmt COMMA?)? RBRACE
             """
             ret = ast.SubNodeList[ast.EnumBlockStmt](items=[], delim=Tok.COMMA, kid=kid)
             ret.items = [i for i in kid if isinstance(i, ast.EnumBlockStmt)]
@@ -1022,7 +1022,7 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.ParamVar]:
             """Grammar rule.
 
-            func_decl_params: (param_var COMMA)* param_var
+            func_decl_params: (param_var COMMA)* param_var COMMA?
             """
             ret = ast.SubNodeList[ast.ParamVar](
                 items=[i for i in kid if isinstance(i, ast.ParamVar)],
@@ -1267,29 +1267,30 @@ class JacParser(Pass):
         def statement(self, kid: list[ast.AstNode]) -> ast.CodeBlockStmt:
             """Grammar rule.
 
-            statement: py_code_block
-                    | walker_stmt
-                    | return_stmt SEMI
-                    | report_stmt SEMI
-                    | delete_stmt SEMI
-                    | ctrl_stmt SEMI
-                    | assert_stmt SEMI
-                    | raise_stmt SEMI
-                    | with_stmt
+            statement: import_stmt
+                    | ability
+                    | architype
+                    | if_stmt
                     | while_stmt
                     | for_stmt
                     | try_stmt
-                    | if_stmt
-                    | expression SEMI
-                    | (yield_expr | KW_YIELD) SEMI
-                    | static_assignment
-                    | assignment SEMI
+                    | match_stmt
+                    | with_stmt
                     | global_ref SEMI
                     | nonlocal_ref SEMI
                     | typed_ctx_block
-                    | ability
-                    | architype
-                    | import_stmt
+                    | return_stmt SEMI
+                    | (yield_expr | KW_YIELD) SEMI
+                    | raise_stmt SEMI
+                    | assert_stmt SEMI
+                    | check_stmt SEMI
+                    | assignment SEMI
+                    | delete_stmt SEMI
+                    | report_stmt SEMI
+                    | expression SEMI
+                    | ctrl_stmt SEMI
+                    | py_code_block
+                    | walker_stmt
                     | SEMI
             """
             if isinstance(kid[0], ast.CodeBlockStmt) and len(kid) < 2:
@@ -2180,30 +2181,21 @@ class JacParser(Pass):
         def arithmetic(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            arithmetic: term MINUS arithmetic
-                      | term PLUS arithmetic
-                      | term
+            arithmetic: (arithmetic (MINUS | PLUS))? term
             """
             return self.binary_expr_unwind(kid)
 
         def term(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            term: factor MOD term
-                 | factor DIV term
-                 | factor FLOOR_DIV term
-                 | factor STAR_MUL term
-                 | factor
+            term: (term (MOD | DIV | FLOOR_DIV | STAR_MUL | DECOR_OP))? power
             """
             return self.binary_expr_unwind(kid)
 
         def factor(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            factor: power
-                  | BW_NOT factor
-                  | MINUS factor
-                  | PLUS factor
+            factor: (BW_NOT | MINUS | PLUS) factor | connect
             """
             if len(kid) == 2:
                 if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.Expr):
@@ -2221,8 +2213,7 @@ class JacParser(Pass):
         def power(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            power: connect STAR_POW power
-                  | connect
+            power: (power STAR_POW)? factor
             """
             return self.binary_expr_unwind(kid)
 
@@ -2513,8 +2504,7 @@ class JacParser(Pass):
         def yield_expr(self, kid: list[ast.AstNode]) -> ast.YieldExpr:
             """Grammar rule.
 
-            yield_expr:
-                | KW_YIELD KW_FROM? expression
+            yield_expr: KW_YIELD KW_FROM? expression
             """
             if isinstance(kid[-1], ast.Expr):
                 return self.nu(
@@ -2565,7 +2555,7 @@ class JacParser(Pass):
         def multistring(self, kid: list[ast.AstNode]) -> ast.AtomExpr:
             """Grammar rule.
 
-            multistring: (fstring | STRING)+
+            multistring: (fstring | STRING | DOC_STRING)+
             """
             valid_strs = [i for i in kid if isinstance(i, (ast.String, ast.FString))]
             if len(valid_strs) == len(kid):
@@ -2582,6 +2572,7 @@ class JacParser(Pass):
             """Grammar rule.
 
             fstring: FSTR_START fstr_parts FSTR_END
+                | FSTR_SQ_START fstr_sq_parts FSTR_SQ_END
             """
             if len(kid) == 2:
                 return self.nu(
@@ -2605,7 +2596,7 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.String | ast.ExprStmt]:
             """Grammar rule.
 
-            fstr_parts: (FSTR_PIECE | FSTR_BESC | LBRACE expression RBRACE | fstring)*
+            fstr_parts: (FSTR_PIECE | FSTR_BESC | LBRACE expression RBRACE )*
             """
             valid_parts: list[ast.String | ast.ExprStmt] = [
                 (
@@ -2651,7 +2642,7 @@ class JacParser(Pass):
         def list_val(self, kid: list[ast.AstNode]) -> ast.ListVal:
             """Grammar rule.
 
-            list_val: LSQUARE expr_list? RSQUARE
+            list_val: LSQUARE (expr_list COMMA?)? RSQUARE
             """
             if len(kid) == 2:
                 return self.nu(
@@ -2695,7 +2686,7 @@ class JacParser(Pass):
         def set_val(self, kid: list[ast.AstNode]) -> ast.SetVal:
             """Grammar rule.
 
-            set_val: LBRACE expr_list RBRACE
+            set_val: LBRACE expr_list COMMA? RBRACE
             """
             if len(kid) == 2:
                 return self.nu(
@@ -2822,25 +2813,37 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.Expr | ast.KWPair]:
             """Grammar rule.
 
-            tuple_list: expression COMMA expr_list COMMA kw_expr_list
-                    | expression COMMA kw_expr_list
-                    | expression COMMA expr_list
-                    | expression COMMA
-                    | kw_expr_list
+            tuple_list: expression COMMA expr_list    COMMA kw_expr_list COMMA?
+                      | expression COMMA kw_expr_list COMMA?
+                      | expression COMMA expr_list    COMMA?
+                      | expression COMMA
+                      | kw_expr_list COMMA?
             """
             chomp = [*kid]
             first_expr = None
             if isinstance(chomp[0], ast.SubNodeList):
+                # The chomp will be like this:
+                #     kw_expr_list, [COMMA]
+                if len(chomp) > 1:
+                    # Add the comma to the subnode list if it exists, otherwise the last comma will not be a part of
+                    # the ast, we need it for formatting.
+                    chomp[0].kid.append(chomp[1])
                 return self.nu(chomp[0])
             else:
-                first_expr = chomp[0]
-                chomp = chomp[2:]
+                # The chomp will be like this:
+                #     expression, COMMA, [subnode_list, [COMMA, [kw_expr_list, [COMMA]]]]
+                # Pop the first expression from chomp.
+                first_expr = chomp[0]  # Get the first expression.
+                chomp = chomp[2:]  # Get rid of expr and comma.
+
+            # The chomp will be like this:
+            #     [subnode_list, [COMMA, [kw_expr_list, [COMMA]]]]
             expr_list = []
             if len(chomp):
-                expr_list = chomp[0].kid
-                chomp = chomp[1:]
+                expr_list = chomp[0].kid  # Get the kids subnode list.
+                chomp = chomp[2:]  # Get rid of the subnode list and a comma if exists.
                 if len(chomp):
-                    chomp = chomp[1:]
+                    # The chomp will be like this: [kw_expr_list, [COMMA]]
                     expr_list = [*expr_list, *chomp[0].kid]
             expr_list = [first_expr, *expr_list]
             valid_kid = [i for i in expr_list if isinstance(i, (ast.Expr, ast.KWPair))]
@@ -2855,7 +2858,7 @@ class JacParser(Pass):
         def dict_val(self, kid: list[ast.AstNode]) -> ast.DictVal:
             """Grammar rule.
 
-            dict_val: LBRACE ((kv_pair COMMA)* kv_pair)? RBRACE
+            dict_val: LBRACE ((kv_pair COMMA)* kv_pair COMMA?)? RBRACE
             """
             ret = ast.DictVal(
                 kv_pairs=[],
@@ -2912,7 +2915,7 @@ class JacParser(Pass):
         def gen_compr(self, kid: list[ast.AstNode]) -> ast.GenCompr:
             """Grammar rule.
 
-            gen_compr: LSQUARE expression inner_compr+ RSQUARE
+            gen_compr: LPAREN expression inner_compr+ RPAREN
             """
             comprs = [i for i in kid if isinstance(i, ast.InnerCompr)]
             if isinstance(kid[1], ast.Expr):
@@ -2929,7 +2932,7 @@ class JacParser(Pass):
         def set_compr(self, kid: list[ast.AstNode]) -> ast.SetCompr:
             """Grammar rule.
 
-            set_compr: LSQUARE expression inner_compr+ RSQUARE
+            set_compr: LBRACE expression inner_compr+ RBRACE
             """
             comprs = [i for i in kid if isinstance(i, ast.InnerCompr)]
             if isinstance(kid[1], ast.Expr) and isinstance(kid[2], ast.InnerCompr):
@@ -2993,12 +2996,21 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.Expr | ast.KWPair]:
             """Grammar rule.
 
-            param_list: expr_list COMMA kw_expr_list
-                    | kw_expr_list
-                    | expr_list
+            param_list: expr_list    COMMA kw_expr_list COMMA?
+                      | kw_expr_list COMMA?
+                      | expr_list    COMMA?
             """
-            if len(kid) == 1:
+            ends_with_comma = (
+                len(kid) > 1
+                and isinstance(kid[-1], ast.Token)
+                and kid[-1].name == "COMMA"
+            )
+            if len(kid) == 1 or (len(kid) == 2 and ends_with_comma):
                 if isinstance(kid[0], ast.SubNodeList):
+                    if (
+                        ends_with_comma
+                    ):  # Append the trailing comma to the subnode list.
+                        kid[0].kid.append(kid[1])
                     return self.nu(kid[0])
                 else:
                     raise self.ice()
@@ -3146,7 +3158,7 @@ class JacParser(Pass):
         def type_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef:
             """Grammar rule.
 
-            type_ref: TYPE_OP name_ref
+            type_ref: TYPE_OP (named_ref | builtin_type)
             """
             if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.NameAtom):
                 return self.nu(

{jaclang-0.7.20 → jaclang-0.7.21}/jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -404,7 +404,9 @@ class JacFormatPass(Pass):
                     indented = True
                 for count, j in enumerate(i.kid):
                     if j.gen.jac == ",":
-                        if i.kid[count + 1].gen.jac.startswith("#"):
+                        if len(i.kid) > count + 1 and i.kid[
+                            count + 1
+                        ].gen.jac.startswith("#"):
                             self.indent_level -= 1
                             self.emit(node, f"{j.gen.jac} ")
                             self.indent_level += 1

{jaclang-0.7.20 → jaclang-0.7.21}/jaclang/runtimelib/architype.py

@@ -526,6 +526,14 @@ class WalkerAnchor(Anchor):
         if walker := self.architype:
             self.path = []
             self.next = [node]
+            if self.next:
+                current_node = self.next[-1].architype
+                for i in walker._jac_entry_funcs_:
+                    if not i.trigger:
+                        if i.func:
+                            i.func(walker, current_node)
+                        else:
+                            raise ValueError(f"No function {i.name} to call.")
             while len(self.next):
                 if current_node := self.next.pop(0).architype:
                     for i in current_node._jac_entry_funcs_:
@@ -538,16 +546,20 @@ class WalkerAnchor(Anchor):
                             return walker
                     for i in walker._jac_entry_funcs_:
                         if not i.trigger or isinstance(current_node, i.trigger):
-                            if i.func:
+                            if i.func and i.trigger:
                                 i.func(walker, current_node)
+                            elif not i.trigger:
+                                continue
                             else:
                                 raise ValueError(f"No function {i.name} to call.")
                         if self.disengaged:
                             return walker
                     for i in walker._jac_exit_funcs_:
                         if not i.trigger or isinstance(current_node, i.trigger):
-                            if i.func:
+                            if i.func and i.trigger:
                                 i.func(walker, current_node)
+                            elif not i.trigger:
+                                continue
                             else:
                                 raise ValueError(f"No function {i.name} to call.")
                         if self.disengaged:
@@ -560,6 +572,12 @@ class WalkerAnchor(Anchor):
                                 raise ValueError(f"No function {i.name} to call.")
                         if self.disengaged:
                             return walker
+            for i in walker._jac_exit_funcs_:
+                if not i.trigger:
+                    if i.func:
+                        i.func(walker, current_node)
+                    else:
+                        raise ValueError(f"No function {i.name} to call.")
             self.ignores = []
             return walker
         raise Exception(f"Invalid Reference {self.id}")

{jaclang-0.7.20 → jaclang-0.7.21}/jaclang/runtimelib/machine.py

@@ -11,7 +11,12 @@ from typing import Optional, Union
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.compile import compile_jac
 from jaclang.compiler.constant import Constants as Con
-from jaclang.runtimelib.architype import EdgeArchitype, NodeArchitype, WalkerArchitype
+from jaclang.runtimelib.architype import (
+    Architype,
+    EdgeArchitype,
+    NodeArchitype,
+    WalkerArchitype,
+)
 from jaclang.utils.log import logging
 
 
@@ -146,6 +151,47 @@ class JacMachine:
             logger.warning(f"Module {module_name} not found in loaded modules.")
         return ()
 
+    def spawn_node(
+        self,
+        node_name: str,
+        attributes: Optional[dict] = None,
+        module_name: str = "__main__",
+    ) -> NodeArchitype:
+        """Spawn a node instance of the given node_name with attributes."""
+        node_class = self.get_architype(module_name, node_name)
+        if isinstance(node_class, type) and issubclass(node_class, NodeArchitype):
+            if attributes is None:
+                attributes = {}
+            node_instance = node_class(**attributes)
+            return node_instance
+        else:
+            raise ValueError(f"Node {node_name} not found.")
+
+    def spawn_walker(
+        self,
+        walker_name: str,
+        attributes: Optional[dict] = None,
+        module_name: str = "__main__",
+    ) -> WalkerArchitype:
+        """Spawn a walker instance of the given walker_name."""
+        walker_class = self.get_architype(module_name, walker_name)
+        if isinstance(walker_class, type) and issubclass(walker_class, WalkerArchitype):
+            if attributes is None:
+                attributes = {}
+            walker_instance = walker_class(**attributes)
+            return walker_instance
+        else:
+            raise ValueError(f"Walker {walker_name} not found.")
+
+    def get_architype(
+        self, module_name: str, architype_name: str
+    ) -> Optional[Architype]:
+        """Retrieve an architype class from a module."""
+        module = self.loaded_modules.get(module_name)
+        if module:
+            return getattr(module, architype_name, None)
+        return None
+
     @staticmethod
     def get(base_path: str = "") -> "JacMachine":
         """Get current jac machine."""

jaclang-0.7.21/jaclang/tests/fixtures/dynamic_architype.jac

@@ -0,0 +1,34 @@
+import:py from jaclang.runtimelib.machine {JacMachine}
+import:jac from bar {Item}
+
+node test_node {
+    has value:int;
+}
+
+walker test_walker {
+    can visit_nodes with `root entry {
+        visit [-->];
+    }
+
+    can print_value with test_node | Item entry {
+        print("Value:", f'{here.value}');
+    }
+}
+
+walker child_walker :test_walker: {}
+
+with entry {
+    for value in range(1, 4) {
+        root ++> test_node(value=value);
+        root ++> Item(value=value);
+    }
+    node_obj = JacMachine.get().spawn_node(node_name='test_node', attributes={'value': 0}, module_name='__main__');
+    walker_obj = JacMachine.get().spawn_walker(walker_name='child_walker', module_name='__main__');
+    external_node = JacMachine.get().spawn_node(node_name='Item', attributes={'value': 0}, module_name='bar');
+    root ++> external_node;
+    root ++> node_obj;
+    print("Spawned Node:", node_obj);
+    print("Spawned Walker:", walker_obj);
+    print("Spawned External node:", external_node);
+    root spawn walker_obj;
+}

jaclang-0.7.21/jaclang/tests/fixtures/entry_exit.jac

@@ -0,0 +1,36 @@
+node test_node {
+    has value: int;
+}
+
+walker test_walker {
+    has visited_nodes: list = [];
+    has entry_count: int = 0;
+    has exit_count: int = 0;
+
+    can traverse with `root entry {
+        visit [-->](`?test_node);
+    }
+
+    can log_entry with entry {
+        print("Entering at the beginning of walker: ",here);
+        self.entry_count += 1;
+    }
+
+    can log_visit with test_node exit {
+        print("Visiting node : ", here);
+        self.visited_nodes.append(here);
+    }
+
+    can log_exit with exit {
+        print("Exiting at the end of walker: ",here);
+        self.exit_count += 1;
+    }
+}
+
+with entry {
+    for i in range(10) {
+        root ++> (next:=test_node(value=i));
+    }
+    wlk_obj = root spawn test_walker();
+    print(wlk_obj);
+}

jaclang-0.7.21/jaclang/tests/fixtures/trailing_comma.jac

@@ -0,0 +1,88 @@
+"""
+This test file is to ensure the valid syntax of jac lang.
+Add new jac syntax here to test if it compile without any issue.
+"""
+
+
+# Import statement without trailing comma.
+import:py from time { sleep, timezone, tzname }
+# Import statement with trailing comma.
+import:py from os { path, getenv, getpid,  }
+
+enum WithoutTrailComma {
+    FOO = "FOO",
+    BAR = "BAR"
+}
+
+enum WithTrailComma {
+    FOO = "FOO",
+    BAR = "BAR",
+}
+
+can without_trail_comma(a: int, b: int) {}
+
+can with_trail_comma(a: int, b: int, c: int, ) {}
+
+with entry {
+
+    dict_without_trail_comma = {"key": "value"};
+    dict_with_trail_comma = {"key": "val",};
+
+    list_without_trail_comma = ["foo", "bar"];
+    list_with_trail_comma = ["foo", "bar",];
+
+    set_without_trail_comma = {"foo", "bar"};
+    set_with_trail_comma = {"foo", "bar"};
+    obj foo11 {
+        has val: int,
+            val2: int = 9,
+            val3: int = 8,
+            val4: int = 8,
+            val5: int = 8;
+    }
+    empty_tuple = ();
+    single_tuple = ('single', );
+
+    tuple_without_trail_comma = ("foo", "bar");
+    tuple_with_trail_comma = ("foo", "bar", );
+
+    mixed_tuple = (1, 'two', 3.0, False);
+    mixed_tuple_with_trail_comma = (1, 'two', 3.0, False, );
+
+    nested_tuple = (1, (2, 3), 'four');
+    nested_tuple_with_trail_comma = (1, (2, 3), 'four', );
+
+    deeply_nested_tuple = (1, (2, (3, (4, 5))));
+    deeply_nested_tuple_with_trail_comma = (1, (2, (3, (4, 5))), );
+
+    tuple1 = ("foo", );
+    tuple1_2 = ("foo", "bar", "baz");
+    tuple_2_2 = ("foo", "bar", "baz", );
+
+    foo_instance1 = foo11(val=90);
+    foo_instance1_2 = foo11(val=90, );
+
+    foo_instance3 = foo11(2, 34, val3=90);
+    foo_instance3_2 = foo11(2, 34, val3=90, );
+
+    foo_instance4 = foo11(2, 34, val3=90, val4=90);
+    foo_instance4_2 = foo11(2, 34, val3=90, val4=90, );
+
+    func_tuple = (foo_instance1, foo_instance3_2, len(tuple1_2));
+    func_tuple_with_trail_comma = (foo_instance1, foo_instance3_2, len(tuple1_2), );
+
+    unpack_tuple = (1, 2, 3);
+    (a, b, c, ) = unpack_tuple;
+    values = (a, b, c);
+
+    (1, 2);
+    (1, 2, );
+    (1, 2, 3, 4);
+    (1, 2, 3, 4, );
+
+    val_f = (foo_instance3_2.val, foo_instance3_2.val2, foo_instance3_2.val3);
+    expression_tuple = (1 + 2, len("abc"), foo_instance1.val * 2);
+    tuple_with_list = (1, [2, 3], 4);
+    print("Code compiled and ran successfully!");
+
+}