jaclang 0.7.28__tar.gz → 0.7.30__tar.gz

{jaclang-0.7.28 → jaclang-0.7.30}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.3
 Name: jaclang
-Version: 0.7.28
+Version: 0.7.30
 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
 Keywords: jac,jaclang,jaseci,python,programming-language,machine-learning,artificial-intelligence
 Author: Jason Mars
@@ -19,6 +18,7 @@ Provides-Extra: all
 Provides-Extra: llm
 Provides-Extra: streamlit
 Project-URL: Documentation, https://jac-lang.org
+Project-URL: Homepage, https://jaseci.org
 Project-URL: Repository, https://github.com/Jaseci-Labs/jaclang
 Description-Content-Type: text/markdown
 

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/compiler/__init__.py

@@ -55,7 +55,7 @@ TOKEN_MAP.update(
         "CARROW_L": "<++", "CARROW_R": "++>", "GLOBAL_OP": ":global:",
         "NONLOCAL_OP": ":nonlocal:", "WALKER_OP": ":walker:", "NODE_OP": ":node:",
         "EDGE_OP": ":edge:", "CLASS_OP": ":class:", "OBJECT_OP": ":obj:",
-        "TYPE_OP": "`", "ABILITY_OP": ":can:", "ELVIS_OP": "?:", "NULL_OK": "?",
+        "TYPE_OP": "`", "ABILITY_OP": ":can:", "NULL_OK": "?",
         "KW_OR": "|", "ARROW_BI": "<-->", "ARROW_L": "<--",
         "ARROW_R": "-->", "ARROW_L_P1": "<-:", "ARROW_R_P2": ":->",
         "ARROW_L_P2": ":-", "ARROW_R_P1": "-:", "CARROW_BI": "<++>",

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/compiler/absyntree.py

@@ -1013,8 +1013,9 @@ class ModulePath(AstSymbolNode):
         target = self.dot_path_str
         if target_item:
             target += f".{target_item}"
-        base_path = os.path.dirname(self.loc.mod_path)
-        base_path = base_path if base_path else os.getcwd()
+        base_path = (
+            os.getenv("JACPATH") or os.path.dirname(self.loc.mod_path) or os.getcwd()
+        )
         parts = target.split(".")
         traversal_levels = self.level - 1 if self.level > 0 else 0
         actual_parts = parts[traversal_levels:]
@@ -1026,6 +1027,15 @@ class ModulePath(AstSymbolNode):
             if os.path.exists(relative_path + ".jac")
             else relative_path
         )
+        jacpath = os.getenv("JACPATH")
+        if not os.path.exists(relative_path) and jacpath:
+            name_to_find = actual_parts[-1] + ".jac"
+
+            # Walk through the single path in JACPATH
+            for root, _, files in os.walk(jacpath):
+                if name_to_find in files:
+                    relative_path = os.path.join(root, name_to_find)
+                    break
         return relative_path
 
     def normalize(self, deep: bool = False) -> bool:

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/compiler/compile.py

@@ -31,7 +31,7 @@ def jac_file_to_pass(
     schedule: list[Type[Pass]] = pass_schedule,
 ) -> Pass:
     """Convert a Jac file to an AST."""
-    with open(file_path) as file:
+    with open(file_path, "r", encoding="utf-8") as file:
         return jac_str_to_pass(
             jac_str=file.read(),
             file_path=file_path,

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/compiler/constant.py

@@ -315,7 +315,6 @@ class Tokens(str, Enum):
     ABILITY_OP = "ABILITY_OP"
     A_PIPE_FWD = "A_PIPE_FWD"
     A_PIPE_BKWD = "A_PIPE_BKWD"
-    ELVIS_OP = "ELVIS_OP"
     RETURN_HINT = "RETURN_HINT"
     NULL_OK = "NULL_OK"
     DECOR_OP = "DECOR_OP"

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/compiler/jac.lark

@@ -298,10 +298,7 @@ lambda_expr: KW_WITH func_decl_params? (RETURN_HINT expression)? KW_CAN expressi
 pipe: (pipe PIPE_FWD)? pipe_back
 
 // Pipe back expressions
-pipe_back: (pipe_back PIPE_BKWD)? elvis_check
-
-// Elvis expressions
-elvis_check: (elvis_check ELVIS_OP)? bitwise_or
+pipe_back: (pipe_back PIPE_BKWD)? bitwise_or
 
 // Bitwise expressions
 bitwise_or: (bitwise_or BW_OR)? bitwise_xor
@@ -599,7 +596,6 @@ PIPE_BKWD: /<\|/
 DOT_FWD: /\.>/
 DOT_BKWD: /<\./
 RETURN_HINT: /->/
-ELVIS_OP: /\?:/
 NULL_OK: /\?/
 MATMUL_EQ: /@=/
 DECOR_OP: /@/

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/compiler/parser.py

@@ -2037,16 +2037,8 @@ class JacParser(Pass):
         def pipe_back(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            pipe_back: elvis_check PIPE_BKWD pipe_back
-                     | elvis_check
-            """
-            return self.binary_expr_unwind(kid)
-
-        def elvis_check(self, kid: list[ast.AstNode]) -> ast.Expr:
-            """Grammar rule.
-
-            elvis_check: bitwise_or ELVIS_OP elvis_check
-                       | bitwise_or
+            pipe_back: bitwise_or PIPE_BKWD pipe_back
+                     | bitwise_or
             """
             return self.binary_expr_unwind(kid)
 

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/compiler/passes/main/import_pass.py

@@ -186,7 +186,7 @@ class JacImportPass(Pass):
             self.warnings_had += mod_pass.warnings_had
             mod = mod_pass.ir
         except Exception as e:
-            logger.info(e)
+            logger.error(e)
             mod = None
         if isinstance(mod, ast.Module):
             self.import_table[target] = mod
@@ -472,7 +472,7 @@ class PyImportPass(JacImportPass):
             if mod:
                 mod.name = imported_mod_name if imported_mod_name else mod.name
                 if mod.name == "__init__":
-                    mod_name = mod.loc.mod_path.split("/")[-2]
+                    mod_name = mod.loc.mod_path.split(os.sep)[-2]
                     self.__debug_print(
                         f"\tRaised the __init__ file and rename the mod to be {mod_name}"
                     )

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -2482,25 +2482,6 @@ class PyastGenPass(Pass):
             return func_node.gen.py_ast
         elif node.op.name == Tok.PIPE_FWD and isinstance(node.right, ast.TupleVal):
             self.error("Invalid pipe target.")
-        elif node.op.name == Tok.ELVIS_OP:
-            self.needs_jac_feature()
-            return [
-                self.sync(
-                    ast3.Call(
-                        func=self.sync(
-                            ast3.Attribute(
-                                value=self.sync(
-                                    ast3.Name(id=Con.JAC_FEATURE.value, ctx=ast3.Load())
-                                ),
-                                attr="elvis",
-                                ctx=ast3.Load(),
-                            )
-                        ),
-                        args=[node.left.gen.py_ast[0], node.right.gen.py_ast[0]],
-                        keywords=[],
-                    )
-                )
-            ]
         else:
             self.error(
                 f"Binary operator {node.op.value} not supported in bootstrap Jac"

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/compiler/passes/main/tests/test_import_pass.py

@@ -83,7 +83,10 @@ class ImportPassPassTests(TestCase):
         for i in p:
             self.assertIn(i, build.ir.py_info.py_raise_map)
             self.assertRegex(
-                re.sub(r".*fixtures/", "", build.ir.py_info.py_raise_map[i]), p[i]
+                re.sub(r".*fixtures/", "", build.ir.py_info.py_raise_map[i]).replace(
+                    "\\", "/"
+                ),
+                p[i],
             )
 
     def test_py_raised_mods(self) -> None:

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -973,7 +973,6 @@ class JacFormatPass(Pass):
                     Tok.PIPE_FWD,
                     Tok.KW_SPAWN,
                     Tok.A_PIPE_FWD,
-                    Tok.ELVIS_OP,
                 ]
                 or (
                     node.op.name == Tok.PIPE_FWD

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/compiler/tests/test_importer.py

@@ -33,7 +33,7 @@ class TestLoader(TestCase):
         )
         self.assertIn(
             "/tests/fixtures/hello_world.jac",
-            str(JacMachine.get().loaded_modules),
+            str(JacMachine.get().loaded_modules).replace("\\\\", "/"),
         )
         JacMachine.detach()
 
@@ -62,3 +62,47 @@ class TestLoader(TestCase):
             "{SomeObj(a=10): 'check'} [MyObj(apple=5, banana=7), MyObj(apple=5, banana=7)]",
             stdout_value,
         )
+
+    def test_import_with_jacpath(self) -> None:
+        """Test module import using JACPATH."""
+        # Set up a temporary JACPATH environment variable
+        import os
+        import tempfile
+
+        jacpath_dir = tempfile.TemporaryDirectory()
+        os.environ["JACPATH"] = jacpath_dir.name
+
+        # Create a mock Jac file in the JACPATH directory
+        module_name = "test_module"
+        jac_file_path = os.path.join(jacpath_dir.name, f"{module_name}.jac")
+        with open(jac_file_path, "w") as f:
+            f.write(
+                """
+                with entry {
+                    "Hello from JACPATH!" :> print;
+                }
+                """
+            )
+
+        # Capture the output
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        try:
+            JacMachine(self.fixture_abs_path(__file__)).attach_program(
+                JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
+            )
+            jac_import(module_name, base_path=__file__)
+            cli.run(jac_file_path)
+
+            # Reset stdout and get the output
+            sys.stdout = sys.__stdout__
+            stdout_value = captured_output.getvalue()
+
+            self.assertIn("Hello from JACPATH!", stdout_value)
+
+        finally:
+            captured_output.close()
+            JacMachine.detach()
+            os.environ.pop("JACPATH", None)
+            jacpath_dir.cleanup()

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/plugin/default.py

@@ -43,8 +43,11 @@ from jaclang.runtimelib.constructs import (
 from jaclang.runtimelib.importer import ImportPathSpec, JacImporter, PythonImporter
 from jaclang.runtimelib.machine import JacMachine, JacProgram
 from jaclang.runtimelib.memory import Shelf, ShelfStorage
-from jaclang.runtimelib.utils import collect_node_connections, traverse_graph
-
+from jaclang.runtimelib.utils import (
+    all_issubclass,
+    collect_node_connections,
+    traverse_graph,
+)
 
 import pluggy
 
@@ -176,14 +179,12 @@ class JacAccessValidationImpl:
             if to_root.access.all > access_level:
                 access_level = to_root.access.all
 
-            level = to_root.access.roots.check(str(jroot.id))
-            if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
+            if (level := to_root.access.roots.check(str(jroot.id))) is not None:
                 access_level = level
 
         # if target anchor have set allowed roots
         # if current root is allowed to target anchor
-        level = to_access.roots.check(str(jroot.id))
-        if level > AccessLevel.NO_ACCESS and access_level == AccessLevel.NO_ACCESS:
+        if (level := to_access.roots.check(str(jroot.id))) is not None:
             access_level = level
 
         return access_level
@@ -399,64 +400,85 @@ class JacWalkerImpl:
 
         walker.path = []
         walker.next = [node]
-        if walker.next:
-            current_node = walker.next[-1].architype
-            for i in warch._jac_entry_funcs_:
-                trigger = i.get_funcparam_annotations(i.func)
-                if not trigger:
-                    if i.func:
-                        i.func(warch, current_node)
-                    else:
-                        raise ValueError(f"No function {i.name} to call.")
+        current_node = node.architype
+
+        # walker entry
+        for i in warch._jac_entry_funcs_:
+            if i.func and not i.trigger:
+                i.func(warch, current_node)
+            if walker.disengaged:
+                return warch
+
         while len(walker.next):
             if current_node := walker.next.pop(0).architype:
+                # walker entry with
+                for i in warch._jac_entry_funcs_:
+                    if (
+                        i.func
+                        and i.trigger
+                        and all_issubclass(i.trigger, NodeArchitype)
+                        and isinstance(current_node, i.trigger)
+                    ):
+                        i.func(warch, current_node)
+                    if walker.disengaged:
+                        return warch
+
+                # node entry
                 for i in current_node._jac_entry_funcs_:
-                    trigger = i.get_funcparam_annotations(i.func)
-                    if not trigger or isinstance(warch, trigger):
-                        if i.func:
-                            i.func(current_node, warch)
-                        else:
-                            raise ValueError(f"No function {i.name} to call.")
+                    if i.func and not i.trigger:
+                        i.func(current_node, warch)
                     if walker.disengaged:
                         return warch
-                for i in warch._jac_entry_funcs_:
-                    trigger = i.get_funcparam_annotations(i.func)
-                    if not trigger or isinstance(current_node, trigger):
-                        if i.func and trigger:
-                            i.func(warch, current_node)
-                        elif not trigger:
-                            continue
-                        else:
-                            raise ValueError(f"No function {i.name} to call.")
+
+                # node entry with
+                for i in current_node._jac_entry_funcs_:
+                    if (
+                        i.func
+                        and i.trigger
+                        and all_issubclass(i.trigger, WalkerArchitype)
+                        and isinstance(warch, i.trigger)
+                    ):
+                        i.func(current_node, warch)
                     if walker.disengaged:
                         return warch
-                for i in warch._jac_exit_funcs_:
-                    trigger = i.get_funcparam_annotations(i.func)
-                    if not trigger or isinstance(current_node, trigger):
-                        if i.func and trigger:
-                            i.func(warch, current_node)
-                        elif not trigger:
-                            continue
-                        else:
-                            raise ValueError(f"No function {i.name} to call.")
+
+                # node exit with
+                for i in current_node._jac_exit_funcs_:
+                    if (
+                        i.func
+                        and i.trigger
+                        and all_issubclass(i.trigger, WalkerArchitype)
+                        and isinstance(warch, i.trigger)
+                    ):
+                        i.func(current_node, warch)
                     if walker.disengaged:
                         return warch
+
+                # node exit
                 for i in current_node._jac_exit_funcs_:
-                    trigger = i.get_funcparam_annotations(i.func)
-                    if not trigger or isinstance(warch, trigger):
-                        if i.func:
-                            i.func(current_node, warch)
-                        else:
-                            raise ValueError(f"No function {i.name} to call.")
+                    if i.func and not i.trigger:
+                        i.func(current_node, warch)
                     if walker.disengaged:
                         return warch
+
+                # walker exit with
+                for i in warch._jac_exit_funcs_:
+                    if (
+                        i.func
+                        and i.trigger
+                        and all_issubclass(i.trigger, NodeArchitype)
+                        and isinstance(current_node, i.trigger)
+                    ):
+                        i.func(warch, current_node)
+                    if walker.disengaged:
+                        return warch
+        # walker exit
         for i in warch._jac_exit_funcs_:
-            trigger = i.get_funcparam_annotations(i.func)
-            if not trigger:
-                if i.func:
-                    i.func(warch, current_node)
-                else:
-                    raise ValueError(f"No function {i.name} to call.")
+            if i.func and not i.trigger:
+                i.func(warch, current_node)
+            if walker.disengaged:
+                return warch
+
         walker.ignores = []
         return warch
 
@@ -896,12 +918,6 @@ class JacFeatureImpl(
 
         return ret_count
 
-    @staticmethod
-    @hookimpl
-    def elvis(op1: Optional[T], op2: T) -> T:
-        """Jac's elvis operator feature."""
-        return ret if (ret := op1) is not None else op2
-
     @staticmethod
     @hookimpl
     def has_instance_default(gen_func: Callable[[], T]) -> T:
@@ -1008,7 +1024,7 @@ class JacFeatureImpl(
                         dir in [EdgeDir.OUT, EdgeDir.ANY]
                         and node == source
                         and target.architype in right
-                        and Jac.check_write_access(target)
+                        and Jac.check_connect_access(target)
                     ):
                         Jac.destroy(anchor) if anchor.persistent else Jac.detach(anchor)
                         disconnect_occurred = True
@@ -1016,7 +1032,7 @@ class JacFeatureImpl(
                         dir in [EdgeDir.IN, EdgeDir.ANY]
                         and node == target
                         and source.architype in right
-                        and Jac.check_write_access(source)
+                        and Jac.check_connect_access(source)
                     ):
                         Jac.destroy(anchor) if anchor.persistent else Jac.detach(anchor)
                         disconnect_occurred = True

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/plugin/feature.py

@@ -377,11 +377,6 @@ class JacFeature(
             verbose=verbose,
         )
 
-    @staticmethod
-    def elvis(op1: Optional[T], op2: T) -> T:
-        """Jac's elvis operator feature."""
-        return plugin_manager.hook.elvis(op1=op1, op2=op2)
-
     @staticmethod
     def has_instance_default(gen_func: Callable[[], T]) -> T:
         """Jac's has container default feature."""

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/plugin/spec.py

@@ -355,12 +355,6 @@ class JacFeatureSpec(
         """Run the test suite in the specified .jac file."""
         raise NotImplementedError
 
-    @staticmethod
-    @hookspec(firstresult=True)
-    def elvis(op1: Optional[T], op2: T) -> T:
-        """Jac's elvis operator feature."""
-        raise NotImplementedError
-
     @staticmethod
     @hookspec(firstresult=True)
     def has_instance_default(gen_func: Callable[[], T]) -> T:

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/runtimelib/architype.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import inspect
 from dataclasses import asdict, dataclass, field, fields, is_dataclass
 from enum import IntEnum
+from functools import cached_property
 from logging import getLogger
 from pickle import dumps
 from types import UnionType
@@ -43,9 +44,9 @@ class Access:
 
     anchors: dict[str, AccessLevel] = field(default_factory=dict)
 
-    def check(self, anchor: str) -> AccessLevel:
+    def check(self, anchor: str) -> AccessLevel | None:
         """Validate access."""
-        return self.anchors.get(anchor, AccessLevel.NO_ACCESS)
+        return self.anchors.get(anchor)
 
 
 @dataclass
@@ -220,9 +221,9 @@ class WalkerAnchor(Anchor):
     """Walker Anchor."""
 
     architype: WalkerArchitype
-    path: list[Anchor] = field(default_factory=list)
-    next: list[Anchor] = field(default_factory=list)
-    ignores: list[Anchor] = field(default_factory=list)
+    path: list[NodeAnchor] = field(default_factory=list)
+    next: list[NodeAnchor] = field(default_factory=list)
+    ignores: list[NodeAnchor] = field(default_factory=list)
     disengaged: bool = False
 
 
@@ -311,17 +312,20 @@ class DSFunc:
     name: str
     func: Callable[[Any, Any], Any] | None = None
 
+    @cached_property
+    def trigger(self) -> type | UnionType | tuple[type | UnionType, ...] | None:
+        """Get function parameter annotations."""
+        t = (
+            (
+                inspect.signature(self.func, eval_str=True)
+                .parameters["_jac_here_"]
+                .annotation
+            )
+            if self.func
+            else None
+        )
+        return None if t is inspect._empty else t
+
     def resolve(self, cls: type) -> None:
         """Resolve the function."""
         self.func = getattr(cls, self.name)
-
-    def get_funcparam_annotations(
-        self, func: Callable[[Any, Any], Any] | None
-    ) -> type | UnionType | tuple[type | UnionType, ...] | None:
-        """Get function parameter annotations."""
-        if not func:
-            return None
-        annotation = (
-            inspect.signature(func, eval_str=True).parameters["_jac_here_"].annotation
-        )
-        return annotation if annotation != inspect._empty else None

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/runtimelib/importer.py

@@ -158,9 +158,6 @@ class ImportReturn:
             return getattr(new_module, name, new_module)
         except ImportError as e:
             logger.error(dump_traceback(e))
-            # logger.error(
-            #     f"Failed to load {name} from {jac_file_path} in {module.__name__}: {str(e)}"
-            # )
             return None
 
 
@@ -319,6 +316,32 @@ class JacImporter(Importer):
         """Run the import process for Jac modules."""
         unique_loaded_items: list[types.ModuleType] = []
         module = None
+        # Gather all possible search paths
+        jacpaths = os.environ.get("JACPATH", "")
+        search_paths = [spec.caller_dir]
+        if jacpaths:
+            for p in jacpaths.split(os.pathsep):
+                p = p.strip()
+                if p and p not in search_paths:
+                    search_paths.append(p)
+
+            # Attempt to locate the module file or directory
+            found_path = None
+            target_path_components = spec.target.split(".")
+            for search_path in search_paths:
+                candidate = os.path.join(search_path, "/".join(target_path_components))
+                # Check if the candidate is a directory or a .jac file
+                if (os.path.isdir(candidate)) or (os.path.isfile(candidate + ".jac")):
+                    found_path = candidate
+                    break
+
+            # If a suitable path was found, update spec.full_target; otherwise, raise an error
+            if found_path:
+                spec.full_target = os.path.abspath(found_path)
+            else:
+                raise ImportError(
+                    f"Unable to locate module '{spec.target}' in {search_paths}"
+                )
         if os.path.isfile(spec.full_target + ".jac"):
             module_name = self.get_sys_mod_name(spec.full_target + ".jac")
             module_name = spec.override_name if spec.override_name else module_name

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/runtimelib/machine.py

@@ -38,6 +38,7 @@ class JacMachine:
         self.loaded_modules: dict[str, types.ModuleType] = {}
         if not base_path:
             base_path = os.getcwd()
+        # Ensure the base_path is a list rather than a string
         self.base_path = base_path
         self.base_path_dir = (
             os.path.dirname(base_path)
@@ -306,12 +307,11 @@ class JacProgram:
                 return marshal.load(f)
 
         result = compile_jac(full_target, cache_result=cachable)
-        if result.errors_had or not result.ir.gen.py_bytecode:
+        if result.errors_had:
             for alrt in result.errors_had:
                 # We're not logging here, it already gets logged as the errors were added to the errors_had list.
                 # Regardless of the logging, this needs to be sent to the end user, so we'll printing it to stderr.
                 logger.error(alrt.pretty_print())
-            return None
         if result.ir.gen.py_bytecode is not None:
             return marshal.loads(result.ir.gen.py_bytecode)
         else:

{jaclang-0.7.28 → jaclang-0.7.30}/jaclang/runtimelib/utils.py

@@ -231,3 +231,18 @@ def is_instance(
             return isinstance(obj, target)
         case _:
             return False
+
+
+def all_issubclass(
+    classes: type | UnionType | tuple[type | UnionType, ...], target: type
+) -> bool:
+    """Check if all classes is subclass of target type."""
+    match classes:
+        case type():
+            return issubclass(classes, target)
+        case UnionType():
+            return all((all_issubclass(cls, target) for cls in classes.__args__))
+        case tuple():
+            return all((all_issubclass(cls, target) for cls in classes))
+        case _:
+            return False

jaclang-0.7.30/jaclang/tests/fixtures/visit_sequence.jac

@@ -0,0 +1,50 @@
+node Node {
+    has val: str;
+
+    can entry1 with entry {
+        print(f"{self.val}-2");
+    }
+
+    can entry2 with Walker entry {
+        print(f"{self.val}-3");
+    }
+
+    can exit1 with Walker exit {
+        print(f"{self.val}-4");
+    }
+
+    can exit2 with exit {
+        print(f"{self.val}-5");
+    }
+}
+
+walker Walker {
+    can entry1 with entry {
+        print("walker entry");
+    }
+
+    can entry2 with `root entry {
+        print("walker enter to root");
+        visit [-->];
+    }
+
+    can entry3 with Node entry {
+        print(f"{here.val}-1");
+    }
+
+    can exit1 with Node exit {
+        print(f"{here.val}-6");
+    }
+
+    can exit2 with exit {
+        print("walker exit");
+    }
+}
+
+with entry{
+    root ++> Node(val = "a");
+    root ++> Node(val = "b");
+    root ++> Node(val = "c");
+
+    Walker() spawn root;
+}