jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/compiler/passes/tool/tests/fixtures/corelib_fmt.jac

@@ -1,9 +1,9 @@
 """Jac's Key Elemental Abstractions"""
 
-import:py from datetime, datetime;
-import:py from uuid, UUID, uuid4;
-import:py from jaclang.compiler.constant, EdgeDir;
-import:py from jaclang.plugin, Architype, ArchitypeProtocol, DSFunc, AbsRootHook, hookimpl;
+import from datetime { datetime }
+import from uuid { UUID, uuid4 }
+import from jaclang.compiler.constant { EdgeDir }
+import from jaclang.plugin { Archetype, ArchetypeProtocol, DSFunc, AbsRootHook, hookimpl }
 
 enum AccessMode;
 
@@ -11,27 +11,27 @@ obj Memory {
     has index: dict[UUID, Element] = {},
         save_queue: list[Element] = [];
     #* Main Accessors *#
-    can get_obj(caller_id: UUID, item_id: UUID, override: bool=False) -> Element;
-    can has_obj(item_id: UUID) -> bool;
-    can save_obj(caller_id: UUID, item: Element);
-    can del_obj(caller_id: UUID, item: Element);
+    def get_obj(caller_id: UUID, item_id: UUID, override: bool=False) -> Element;
+    def has_obj(item_id: UUID) -> bool;
+    def save_obj(caller_id: UUID, item: Element);
+    def del_obj(caller_id: UUID, item: Element);
     #* Utility Functions *#
-    can get_object_distribution -> dict;
-    can get_mem_size -> float;
+    def get_object_distribution -> dict;
+    def get_mem_size -> float;
 }
 
 obj ExecutionContext {
     has master: Master = :> uuid4,
         memory: Memory = Memory();
 
-    can reset;
-    can get_root() -> Architype;
+    def reset;
+    def get_root() -> Archetype;
 }
 
 "Global Execution Context, should be monkey patched by the user."
 glob exec_ctx = ExecutionContext();
 
-obj Anchor :ArchitypeProtocol: {
+obj Anchor(ArchetypeProtocol) {
     has ob: object,
         ds_entry_funcs: list[DSFunc],
         ds_exit_funcs: list[DSFunc],
@@ -44,62 +44,62 @@ obj Anchor :ArchitypeProtocol: {
         owner_id: UUID = exec_ctx.master,
         mem: Memory = exec_ctx.memory;
 
-    static can on_entry(cls: type, triggers: list[type]);
-    static can on_exit(cls: type, triggers: list[type]);
-    can make_public_ro;
-    can make_public_rw;
-    can make_private;
-    can is_public_ro -> bool;
-    can is_public_rw -> bool;
-    can is_private -> bool;
-    can is_readable(caller_id: UUID) -> bool;
-    can is_writable(caller_id: UUID) -> bool;
-    can give_access(caller_id: UUID, read_write: bool=False);
-    can revoke_access(caller_id: UUID);
-}
-
-obj NodeAnchor :Anchor: {
+    static def on_entry(cls: type, triggers: list[type]);
+    static def on_exit(cls: type, triggers: list[type]);
+    def make_public_ro;
+    def make_public_rw;
+    def make_private;
+    def is_public_ro -> bool;
+    def is_public_rw -> bool;
+    def is_private -> bool;
+    def is_readable(caller_id: UUID) -> bool;
+    def is_writable(caller_id: UUID) -> bool;
+    def give_access(caller_id: UUID, read_write: bool=False);
+    def revoke_access(caller_id: UUID);
+}
+
+obj NodeAnchor(Anchor) {
     has edges: dict[EdgeDir, list[Edge]] = {EdgeDir.IN: [], EdgeDir.OUT: []};
 
-    can connect_node(nd: Node, edg: Edge) -> Node;
-    can edges_to_nodes(dir: EdgeDir) -> list[Node];
-    can __call__(walk: Walker);
+    def connect_node(nd: Node, edg: Edge) -> Node;
+    def edges_to_nodes(dir: EdgeDir) -> list[Node];
+    def __call__(walk: Walker);
 }
 
-obj EdgeAnchor :Anchor: {
+obj EdgeAnchor(Anchor) {
     has source: Node = None,
         target: Node = None,
         dir: EdgeDir = None;
 
-    can apply_dir(dir: EdgeDir) -> Edge;
-    can attach(src: Node, trg: Node) -> Edge;
-    can __call__(walk: Walker);
+    def apply_dir(dir: EdgeDir) -> Edge;
+    def attach(src: Node, trg: Node) -> Edge;
+    def __call__(walk: Walker);
 }
 
-obj WalkerAnchor :Anchor: {
+obj WalkerAnchor(Anchor) {
     has path: list[Node] = [],
         next: list[Node] = [],
         ignores: list[Node] = [],
         disengaged: bool = False;
 
-    can visit_node(nds: list[Node] | list[Edge] | Node | Edge);
-    can ignore_node(nds: list[Node] | list[Edge] | Node | Edge);
-    can disengage_now;
-    can __call__(nd: Node);
+    def visit_node(nds: list[Node] | list[Edge] | Node | Edge);
+    def ignore_node(nds: list[Node] | list[Edge] | Node | Edge);
+    def disengage_now;
+    def __call__(nd: Node);
 }
 
-obj Root :AbsRootHook: {
+obj Root(AbsRootHook) {
     has __jac__: NodeAnchor | None = None;
 
-    can postinit {
+    def postinit {
         self.__jac__ = NodeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
     }
 }
 
-obj GenericEdge :ArchitypeProtocol: {
+obj GenericEdge(ArchetypeProtocol) {
     has __jac__: EdgeAnchor | None = None;
 
-    can postinit {
+    def postinit {
         self.__jac__ = EdgeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
     }
 }
@@ -108,39 +108,38 @@ obj Master {
     has __jac__: Anchor | None = None;
     has root_node: Root = Root(Root);
 
-    can postinit {
+    def postinit {
         self.__jac__ = Anchor(self);
     }
 }
 
 obj JacPlugin {
     @hookimpl
-    static can bind_architype(arch: AT, arch_type: str, on_entry: list[str], on_exit: list[str]) -> bool;
+    static def bind_archetype(arch: AT, arch_type: str, on_entry: list[str], on_exit: list[str]) -> bool;
     @hookimpl
-    static can get_root() -> Architype;
+    static def get_root() -> Archetype;
     @hookimpl
-    static can build_edge(edge_spec: tuple[int, Optional[tuple], Optional[tuple]]) -> Architype;
+    static def build_edge(edge_spec: tuple[int, Optional[tuple], Optional[tuple]]) -> Archetype;
     @hookimpl
-    static can connect(left: T, right: T, edge_spec: tuple[int, Optional[type], Optional[tuple]]) -> Architype;
+    static def connect(left: T, right: T, edge_spec: tuple[int, Optional[type], Optional[tuple]]) -> Archetype;
     @hookimpl
-    static can visit_node(walker_obj: Any, expr: Any) -> bool;
+    static def visit_node(walker_obj: Any, expr: Any) -> bool;
 }
 
-:obj:Memory:can:get_obj
+impl Memory.get_obj
 (caller_id: UUID, item_id: UUID, override: bool=False) -> Element {
     ret = item_id |> self.index.get;
-    if override
-        or (ret is not None and caller_id |> ret.__is_readable) {
+    if override or (ret is not None and caller_id |> ret.__is_readable) {
         return ret;
     }
 }
 
-:obj:Memory:can:has_obj
+impl Memory.has_obj
 (item_id: UUID) -> bool {
     return item_id in self.index;
 }
 
-:obj:Memory:can:save_obj
+impl Memory.save_obj
 (caller_id: UUID, item: Element) {
     if caller_id |> item.is_writable {
         self.index[item.id] = item;
@@ -154,7 +153,7 @@ obj JacPlugin {
     }
 }
 
-:obj:Memory:can:del_obj
+impl Memory.del_obj
 (caller_id: UUID, item: Element) {
     if caller_id |> item.is_writable {
         self.index.pop(item.id);
@@ -164,7 +163,7 @@ obj JacPlugin {
     }
 }
 
-:obj:Memory:can:get_object_distribution -> dict {
+impl Memory.get_object_distribution -> dict {
     dist = {};
     for i in |> self.index.keys {
         t = self.index[i] |> type;
@@ -177,53 +176,53 @@ obj JacPlugin {
     return dist;
 }
 
-:obj:Memory:can:get_mem_size -> float {
+impl Memory.get_mem_size -> float {
     return (self.index |> sys.getsizeof) / 1024.0;
 }
 
-:obj:ExecutionContext:c:get_root() {
+impl ExecutionContext.get_root() {
     if self.master :> type == UUID {
         self.master = Master();
     }
     return self.master.root_node;
 }
 
-:obj:ExecutionContext:c:reset {
+impl ExecutionContext.reset {
     self.init();
 }
 
 """Implementation for Jac's Element Abstractions"""
-:enum:AccessMode {
+impl AccessMode {
     READ_ONLY,
     READ_WRITE,
     PRIVATE
 }
 
-:obj:Anchor:can:make_public_ro {
+impl Anchor.make_public_ro {
     self.__jinfo.access_mode = AccessMode.READ_ONLY;
 }
 
-:obj:Anchor:can:make_public_rw {
+impl Anchor.make_public_rw {
     self.__jinfo.access_mode = AccessMode.READ_WRITE;
 }
 
-:obj:Anchor:can:make_private {
+impl Anchor.make_private {
     self.__jinfo.access_mode = AccessMode.PRIVATE;
 }
 
-:obj:Anchor:can:is_public_ro -> bool {
+impl Anchor.is_public_ro -> bool {
     return self.__jinfo.access_mode == AccessMode.READ_ONLY;
 }
 
-:obj:Anchor:can:is_public_rw -> bool {
+impl Anchor.is_public_rw -> bool {
     return self.__jinfo.access_mode == AccessMode.READ_WRITE;
 }
 
-:obj:Anchor:can:is_private -> bool {
+impl Anchor.is_private -> bool {
     return self.__jinfo.access_mode == AccessMode.PRIVATE;
 }
 
-:obj:Anchor:can:is_readable
+impl Anchor.is_readable
 (caller_id: UUID) -> bool {
     return (caller_id == self.owner_id
         or |> self.is_public_read
@@ -231,14 +230,12 @@ obj JacPlugin {
         or caller_id in self.rw_access);
 }
 
-:obj:Anchor:can:is_writable
+impl Anchor.is_writable
 (caller_id: UUID) -> bool {
-    return (caller_id == self.owner_id
-        or |> self.is_public_write
-        or caller_id in self.rw_access);
+    return (caller_id == self.owner_id or |> self.is_public_write or caller_id in self.rw_access);
 }
 
-:obj:Anchor:can:give_access
+impl Anchor.give_access
 (caller_id: UUID, read_write: bool=False) {
     if read_write {
         caller_id |> self.rw_access.add;
@@ -247,19 +244,19 @@ obj JacPlugin {
     }
 }
 
-:obj:Anchor:can:revoke_access
+impl Anchor.revoke_access
 (caller_id: UUID) {
     caller_id |> self.ro_access.discard;
     caller_id |> self.rw_access.discard;
 }
 
-:obj:Anchor:can:on_entry
+impl Anchor.on_entry
 (cls: type, triggers: list) {
-    can decorator(func: callable) -> callable {
+    def decorator(func: callable) -> callable {
         cls.ds_entry_funcs.append(
             {'types': triggers, 'func': func}
         );
-        can wrapper(*args: list, **kwargs: dict) -> callable {
+        def wrapper(*args: list, **kwargs: dict) -> callable {
             return func(*args, **kwargs);
         }
         return wrapper;
@@ -267,13 +264,13 @@ obj JacPlugin {
     return decorator;
 }
 
-:obj:Anchor:can:on_exit
+impl Anchor.on_exit
 (cls: type, triggers: list) {
-    can decorator(func: callable) -> callable {
+    def decorator(func: callable) -> callable {
         cls.ds_exit_funcs.append(
             {'types': triggers, 'func': func}
         );
-        can wrapper(*args: list, **kwargs: dict) -> callable {
+        def wrapper(*args: list, **kwargs: dict) -> callable {
             return func(*args, **kwargs);
         }
         return wrapper;
@@ -281,13 +278,13 @@ obj JacPlugin {
     return decorator;
 }
 
-:obj:NodeAnchor:can:connect_node
+impl NodeAnchor.connect_node
 (nd: NodeInterface, edg: EdgeInterface) -> Node {
     edg.attach(self, nd);
     return self;
 }
 
-:obj:NodeAnchor:can:edges_to_nodes
+impl NodeAnchor.edges_to_nodes
 (dir: EdgeDir) -> list[Node] {
     ret_nodes = [];
     if dir in [EdgeDir.OUT, EdgeDir.ANY] {
@@ -302,13 +299,13 @@ obj JacPlugin {
     return ret_nodes;
 }
 
-:obj:EdgeAnchor:can:apply_dir
+impl EdgeAnchor.apply_dir
 (dir: EdgeDir) -> Edge {
     self.dir = dir;
     return self;
 }
 
-:obj:EdgeAnchor:can:attach
+impl EdgeAnchor.attach
 (src: NodeInterface, trg: NodeInterface) -> Edge {
     if self.dir == EdgeDir.IN {
         self.source = trg;
@@ -324,7 +321,7 @@ obj JacPlugin {
     return self;
 }
 
-:obj:WalkerAnchor:can:visit_node
+impl WalkerAnchor.visit_node
 (nds: list[Node] | list[Edge] | Node | Edge) {
     if isinstance(nds, list) {
         for i in nds {
@@ -338,7 +335,7 @@ obj JacPlugin {
     return len(nds) if isinstance(nds, list) else 1;
 }
 
-:obj:WalkerAnchor:can:ignore_node
+impl WalkerAnchor.ignore_node
 (nds: list[Node] | list[Edge] | Node | Edge) {
     if isinstance(nds, list) {
         for i in nds {
@@ -349,12 +346,12 @@ obj JacPlugin {
     }
 }
 
-:obj:WalkerAnchor:can:disengage_now {
+impl WalkerAnchor.disengage_now {
     self.next = [];
     self.disengaged = True;
 }
 
-:obj:NodeAnchor:can:__call__
+impl NodeAnchor.__call__
 (walk: object) {
     if not isinstance(walk.__jac__, WalkerAnchor) {
         raise TypeError("Argument must be a Walker instance");
@@ -362,7 +359,7 @@ obj JacPlugin {
     walk(self);
 }
 
-:obj:EdgeAnchor:can:__call__
+impl EdgeAnchor.__call__
 (walk: EdgeInterface) {
     if not isinstance(walk.__jac__, WalkerAnchor) {
         raise TypeError("Argument must be a Walker instance");
@@ -370,7 +367,7 @@ obj JacPlugin {
     walk(self.__jac__.target);
 }
 
-:obj:WalkerAnchor:can:__call__
+impl WalkerAnchor.__call__
 (nd: NodeInterface) {
     self.path = [];
     self.next = [nd];
@@ -414,7 +411,7 @@ obj JacPlugin {
     self.ignores = [];
 }
 
-:obj:JacPlugin:can:bind_architype
+impl JacPlugin.bind_archetype
 (arch: AT, arch_type: str, on_entry: list[DSFunc], on_exit: list[DSFunc]) -> bool {
     match arch_type {
         case 'obj':
@@ -447,12 +444,12 @@ obj JacPlugin {
     return True;
 }
 
-:obj:JacPlugin:can:get_root() -> None {
+impl JacPlugin.get_root() -> None {
     return exec_ctx.get_root();
 }
 
-:obj:JacPlugin:can:build_edge
-(edge_spec: tuple[int, Optional[type], Optional[tuple]]) -> Architype {
+impl JacPlugin.build_edge
+(edge_spec: tuple[int, Optional[type], Optional[tuple]]) -> Archetype {
     if (not edge_spec[1]) {
         edg_type = GenericEdge;
     } else {
@@ -463,13 +460,13 @@ obj JacPlugin {
     return edg;
 }
 
-:obj:JacPlugin:can:connect
-(left: T, right: T, edge_spec: tuple[int, Optional[type], Optional[tuple]]) -> Architype {
+impl JacPlugin.connect
+(left: T, right: T, edge_spec: tuple[int, Optional[type], Optional[tuple]]) -> Archetype {
     edg = JacPlugin.build_edge(edge_spec);
     left.connect_node(right.__jac__, edg.__jac__);
 }
 
-:obj:JacPlugin:can:visit_node
+impl JacPlugin.visit_node
 (walker_obj: Any, expr: Any) -> bool {
     return walker_obj.__jac__.visit_node(expr);
 }

jaclang/compiler/passes/tool/tests/fixtures/doc_string.jac

@@ -2,14 +2,14 @@ class foo {
     """
     doc string
     """
-    can print_here() {
+    def print_here() {
         print("i'm here");
     }
 
     """this is a
     multiline docstring
     to test"""
-    can also_print() {
+    def also_print() {
         print("I'm in also");
     }
 }

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/access_mod_check.jac

@@ -1,5 +1,5 @@
-can:priv hash(func: Any) {
-    can inner(a: Any) {
+def:priv hash(func: Any) {
+    def inner(a: Any) {
         print(("#" * 20));
         func(a);
         print(("#" * 20));
@@ -7,8 +7,8 @@ can:priv hash(func: Any) {
     return inner;
 }
 
-can:protect exclaim(func: Any) {
-    can inner(b: Any) {
+def:protect exclaim(func: Any) {
+    def inner(b: Any) {
         print(("!" * 20));
         func(b);
         print(("!" * 20));
@@ -18,7 +18,7 @@ can:protect exclaim(func: Any) {
 
 @hash
 @exclaim
-can greeter(name: Any) {
+def greeter(name: Any) {
     print("Hello, " + name + "!");
 }
 

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/archetype_test.jac

@@ -0,0 +1,13 @@
+class Animal {}
+
+obj Domesticated {}
+
+@print_base_classes
+node Pet(Animal, Domesticated) {}
+
+walker Person(Animal) {}
+
+walker Feeder(Person) {}
+
+@print_base_classes
+walker Zoologist(Feeder) {}

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/decorator_stack.jac

@@ -1,5 +1,5 @@
-can star(func: Any) {
-    can inner(x: Any) {
+def star(func: Any) {
+    def inner(x: Any) {
         print(("*" * 30));
         func(x);
         print(("*" * 30));
@@ -7,8 +7,8 @@ can star(func: Any) {
     return inner;
 }
 
-can percent(func: Any) {
-    can inner(y: Any) {
+def percent(func: Any) {
+    def inner(y: Any) {
         print(("%" * 30));
         func(y);
         print(("%" * 30));
@@ -16,8 +16,8 @@ can percent(func: Any) {
     return inner;
 }
 
-can percent2(func: Any) {
-    can inner(y: Any) {
+def percent2(func: Any) {
+    def inner(y: Any) {
         print(("-" * 30));
         func(y);
         print(("+" * 30));
@@ -28,7 +28,7 @@ can percent2(func: Any) {
 @star
 @percent
 @percent2
-can printer(msg: Any) {
+def printer(msg: Any) {
     print(msg);
 }
 

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/line_spacing.jac

@@ -1,4 +1,4 @@
-import:py math;
+import math;
 
 glob RAD = 5;
 
@@ -7,8 +7,8 @@ glob DIA = 10;
 # this comment is for walker
 
 walker decorator_walk {
-    can hash(func: Any) {
-        can inner(a: Any) {
+    def hash(func: Any) {
+        def inner(a: Any) {
             print(("#" * 20));
             func(a);
             print(("#" * 20));
@@ -16,8 +16,8 @@ walker decorator_walk {
         return inner;
     }
 
-    can exclaim(func: Any) {
-        can inner(b: Any) {
+    def exclaim(func: Any) {
+        def inner(b: Any) {
             print(("!" * 20));
             func(b);
             print(("!" * 20));
@@ -25,8 +25,8 @@ walker decorator_walk {
         return inner;
     }
 
-    can tilde(func: Any) {
-        can inner(c: Any) {
+    def tilde(func: Any) {
+        def inner(c: Any) {
             print(("~" * 20));
             func(c);
             print(("~" * 20));
@@ -34,7 +34,7 @@ walker decorator_walk {
         return inner;
     }
 
-    can greeter(name: Any) {
+    def greeter(name: Any) {
         print("Hello, " + name + "!");
     }
 

jaclang/compiler/passes/tool/tests/fixtures/multi_def_err.dot

@@ -4,7 +4,7 @@ digraph graph1 {0 [label="Module"];
 0  -> 3;
 0  -> 4;
 1 [label=<String<BR/> name=DOC_STRING<BR/> value=&quot;&quot;&quot;Test for base classes.&quot;&quot;&quot;> shape="box"];
-2 [label="Architype" shape="box" style="filled" fillcolor="red"];
+2 [label="Archetype" shape="box" style="filled" fillcolor="red"];
 2  -> 5;
 2  -> 6;
 2  -> 7;
@@ -15,7 +15,7 @@ digraph graph1 {0 [label="Module"];
 7  -> 9;
 8 [label=<Token<BR/> name=LBRACE<BR/> value={> shape="box"];
 9 [label=<Token<BR/> name=RBRACE<BR/> value=}> shape="box"];
-3 [label="Architype" shape="box" style="filled" fillcolor="red"];
+3 [label="Archetype" shape="box" style="filled" fillcolor="red"];
 3  -> 10;
 3  -> 11;
 3  -> 12;
@@ -26,7 +26,7 @@ digraph graph1 {0 [label="Module"];
 12  -> 14;
 13 [label=<Token<BR/> name=LBRACE<BR/> value={> shape="box"];
 14 [label=<Token<BR/> name=RBRACE<BR/> value=}> shape="box"];
-4 [label="Architype" shape="box" style="filled" fillcolor="red"];
+4 [label="Archetype" shape="box" style="filled" fillcolor="red"];
 4  -> 15;
 4  -> 16;
 4  -> 17;

jaclang/compiler/passes/tool/tests/fixtures/multi_def_err.txt

@@ -1,18 +1,18 @@
 1:1 - 7:17        Module
 1:1 - 1:29      +-- String - """Test for base classes."""
-3:1 - 3:17      +-- Architype - MyObject
+3:1 - 3:17      +-- Archetype - MyObject
 3:1 - 3:4       |   +-- Token - obj
 3:5 - 3:13      |   +-- Name - MyObject
 3:14 - 3:17     |   +-- SubNodeList
 3:14 - 3:15     |       +-- Token - {
 3:16 - 3:17     |       +-- Token - }
-5:1 - 5:22      +-- Architype - AnotherObject
+5:1 - 5:22      +-- Archetype - AnotherObject
 5:1 - 5:4       |   +-- Token - obj
 5:5 - 5:18      |   +-- Name - AnotherObject
 5:19 - 5:22     |   +-- SubNodeList
 5:19 - 5:20     |       +-- Token - {
 5:21 - 5:22     |       +-- Token - }
-7:1 - 7:17      +-- Architype - MyObject
+7:1 - 7:17      +-- Archetype - MyObject
 7:1 - 7:4           +-- Token - obj
 7:5 - 7:13          +-- Name - MyObject
 7:14 - 7:17         +-- SubNodeList

jaclang/compiler/passes/tool/tests/fixtures/myca_formatted_code/ability_impl_long_comprehension.jac

@@ -8,7 +8,7 @@ walker update_graph {
     can go_to_user with `root entry;
 }
 
-:walker:update_graph:can:go_to_user {
+impl update_graph.go_to_user {
     visit [-->(`?user_root)](?jid == self.user_jid);
     next = [-->];
     visit [i for i in next if isinstance(i, day) and i.date == self.date];

jaclang/compiler/passes/tool/tests/fixtures/myca_formatted_code/call_with_many_parameters.jac

@@ -3,10 +3,10 @@ node user_root {}
 walker create_user {
     has user_info: dict = {};
 
-    can spawn_user_root;
+    def spawn_user_root;
 }
 
-:walker:create_user:can:spawn_user_root {
+impl create_user.spawn_user_root {
     if self.user_info == {} {
         self.user_info = {
             "jid": "xxxx",