@shd101wyy/yo 0.1.25 → 0.1.27

package/std/fs/walker.yo

@@ -21,134 +21,119 @@
 //!   };
 //! });
 //! ```
-
-{ ArrayList } :: import "../collections/array_list";
-open import "../string";
-{ Path } :: import "../path";
-{ IOError } :: import "../sys/errors";
-{ Error, AnyError, Exception } :: import "../error";
-{ FileType } :: import "./dir";
-{ DirEntry } :: import "./dir";
-_dir :: import "./dir";
-
+{ ArrayList } :: import("../collections/array_list");
+open(import("../string"));
+{ Path } :: import("../path");
+{ IOError } :: import("../sys/errors");
+{ Error, AnyError, Exception } :: import("../error");
+{ FileType } :: import("./dir");
+{ DirEntry } :: import("./dir");
+_dir :: import("./dir");
 /// Entry returned by the directory walker.
 WalkEntry :: struct(
-  path      : Path,
-  name      : String,
-  depth     : u32,
+  path : Path,
+  name : String,
+  depth : u32,
   file_type : FileType
 );
-
-export WalkEntry;
-
+export(WalkEntry);
 /// Options controlling directory walk behavior.
 WalkOptions :: struct(
-  max_depth     : ?(u32),
+  max_depth : ?(u32),
   follow_symlinks : bool,
-  include_dirs  : bool
+  include_dirs : bool
 );
-
-impl(WalkOptions,
+impl(
+  WalkOptions,
   defaults : (fn() -> Self)(
     Self(
-      max_depth: .None,
-      follow_symlinks: false,
-      include_dirs: true
+      max_depth :.None,
+      follow_symlinks : false,
+      include_dirs : true
     )
   )
 );
-
-export WalkOptions;
-
+export(WalkOptions);
 // ============================================================================
 // Internal path join helper
 // ============================================================================
-
-_join_path :: (fn(base: String, name: String) -> String)(
+_join_path :: (fn(base : String, name : String) -> String)(
   cond(
     base.ends_with(String.from("/")) => `${base}${name}`,
     true => `${base}/${name}`
   )
 );
-
 // ============================================================================
 // Walk functions
 // ============================================================================
-
 // Walk a directory tree with custom options.
-walk_with :: (fn(root: Path, options: WalkOptions, using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))({
+walk_with :: (fn(root : Path, options : WalkOptions, using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))({
   root_s := root.to_string();
   io.async((using(io, exn)) => {
     results := ArrayList(WalkEntry).new();
     // Stack of (path, depth) pairs to process
-    stack := ArrayList(struct(path: String, depth: u32)).new();
-    stack.push({ path: root_s, depth: u32(0) });
-
-    while runtime((stack.len() > usize(0))), {
+    stack := ArrayList(struct(path : String, depth : u32)).new();
+    stack.push({ path : root_s, depth : u32(0) });
+    while(runtime(stack.len() > usize(0)), {
       item := stack.pop().unwrap();
       cur_path := item.path;
       cur_depth := item.depth;
-
       // Check max depth
-      should_continue := match(options.max_depth,
+      should_continue := match(
+        options.max_depth,
         .Some(max) => (cur_depth <= max),
         .None => true
       );
-
       cond(
         should_continue => {
           entries := io.await(_dir.read_dir(Path.new(cur_path)));
           i := usize(0);
-          while runtime((i < entries.len())), {
+          while(runtime(i < entries.len()), {
             entry := entries.get(i).unwrap();
             entry_path := _join_path(cur_path, entry.name);
-            match(entry.file_type,
+            match(
+              entry.file_type,
               .Directory => {
                 cond(
                   options.include_dirs => {
-                    results.push(WalkEntry(
-                      path: Path.new(entry_path),
-                      name: entry.name,
-                      depth: cur_depth,
-                      file_type: .Directory
-                    ));
+                    results.push(
+                      WalkEntry(
+                        path : Path.new(entry_path),
+                        name : entry.name,
+                        depth : cur_depth,
+                        file_type :.Directory
+                      )
+                    );
                   },
                   true => ()
                 );
                 // Push subdirectory for processing
-                stack.push({ path: entry_path, depth: (cur_depth + u32(1)) });
+                stack.push({ path : entry_path, depth : (cur_depth + u32(1)) });
               },
               _ => {
-                results.push(WalkEntry(
-                  path: Path.new(entry_path),
-                  name: entry.name,
-                  depth: cur_depth,
-                  file_type: entry.file_type
-                ));
+                results.push(
+                  WalkEntry(
+                    path : Path.new(entry_path),
+                    name : entry.name,
+                    depth : cur_depth,
+                    file_type : entry.file_type
+                  )
+                );
               }
             );
             i = (i + usize(1));
-          };
+          });
         },
         true => ()
       );
-    };
-
+    });
     results
   })
 });
-
-walk_with_cstr :: (fn(root: *(u8), options: WalkOptions, using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))(
+walk_with_cstr :: (fn(root : *(u8), options : WalkOptions, using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))(
   walk_with(Path.from_cstr(root), options)
 );
-
 /// Walk a directory tree with default options.
-walk :: (fn(root: Path, using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))
-  walk_with(root, WalkOptions.defaults())
-;
-
-walk_cstr :: (fn(root: *(u8), using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))
-  walk(Path.from_cstr(root))
-;
-
-export walk, walk_cstr, walk_with, walk_with_cstr;
+walk :: (fn(root : Path, using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))(walk_with(root, WalkOptions.defaults()));
+walk_cstr :: (fn(root : *(u8), using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))(walk(Path.from_cstr(root)));
+export(walk, walk_cstr, walk_with, walk_with_cstr);

package/std/gc.yo

@@ -1,15 +1,12 @@
 //! Garbage collection interface for cycle collection.
-
-extern "Yo",
+extern(
+  "Yo",
   __yo_gc_collect : (fn() -> unit),
   __yo_gc_tracked_count : (fn() -> u64)
-;
-
+);
 /// Trigger the cycle collector to reclaim reference cycles.
 collect :: __yo_gc_collect;
-
 /// Get the number of objects currently tracked by the cycle collector.
 tracked_count :: __yo_gc_tracked_count;
-
-export collect;
-export tracked_count;
+export(collect);
+export(tracked_count);

package/std/glob.yo

@@ -1,33 +1,28 @@
 //! Glob pattern matching for file paths.
-
-open import "./string";
-{ ArrayList } :: import "./collections/array_list";
-
+open(import("./string"));
+{ ArrayList } :: import("./collections/array_list");
 // Recursive byte-level glob pattern matching
-_glob_match_impl :: (fn(pb: ArrayList(u8), pi: usize, tb: ArrayList(u8), ti: usize) -> bool)({
+_glob_match_impl :: (fn(pb : ArrayList(u8), pi : usize, tb : ArrayList(u8), ti : usize) -> bool)({
   // Base: both pattern and text consumed
   cond(
     ((pi == pb.len()) && (ti == tb.len())) => {
-      return true;
+      return(true);
     },
     true => ()
   );
-
   // Pattern consumed but text remains
   cond(
     (pi == pb.len()) => {
-      return false;
+      return(false);
     },
     true => ()
   );
-
   p := pb.get(pi).unwrap();
-
   // Handle * and **
   cond(
     (p == u8(42)) => {
       is_dbl := cond(
-        ((pi + usize(1)) < pb.len()) => (pb.get((pi + usize(1))).unwrap() == u8(42)),
+        ((pi + usize(1)) < pb.len()) => (pb.get(pi + usize(1)).unwrap() == u8(42)),
         true => false
       );
       cond(
@@ -49,17 +44,17 @@ _glob_match_impl :: (fn(pb: ArrayList(u8), pi: usize, tb: ArrayList(u8), ti: usi
           // Try ** matching nothing
           cond(
             recur(pb, npi, tb, ti) => {
-              return true;
+              return(true);
             },
             true => ()
           );
           // Try ** consuming one char
           cond(
             (ti < tb.len()) => {
-              return recur(pb, pi, tb, (ti + usize(1)));
+              return(recur(pb, pi, tb, ti + usize(1)));
             },
             true => {
-              return false;
+              return(false);
             }
           );
         },
@@ -67,8 +62,8 @@ _glob_match_impl :: (fn(pb: ArrayList(u8), pi: usize, tb: ArrayList(u8), ti: usi
           // Single * matches any except /
           // Try * matching nothing
           cond(
-            recur(pb, (pi + usize(1)), tb, ti) => {
-              return true;
+            recur(pb, pi + usize(1), tb, ti) => {
+              return(true);
             },
             true => ()
           );
@@ -78,15 +73,15 @@ _glob_match_impl :: (fn(pb: ArrayList(u8), pi: usize, tb: ArrayList(u8), ti: usi
               tc := tb.get(ti).unwrap();
               cond(
                 (tc != u8(47)) => {
-                  return recur(pb, pi, tb, (ti + usize(1)));
+                  return(recur(pb, pi, tb, ti + usize(1)));
                 },
                 true => {
-                  return false;
+                  return(false);
                 }
               );
             },
             true => {
-              return false;
+              return(false);
             }
           );
         }
@@ -94,32 +89,28 @@ _glob_match_impl :: (fn(pb: ArrayList(u8), pi: usize, tb: ArrayList(u8), ti: usi
     },
     true => ()
   );
-
   // Text consumed but non-star pattern remains
   cond(
     (ti == tb.len()) => {
-      return false;
+      return(false);
     },
     true => ()
   );
-
   t := tb.get(ti).unwrap();
-
   // Handle ?
   cond(
     (p == u8(63)) => {
       cond(
         (t != u8(47)) => {
-          return recur(pb, (pi + usize(1)), tb, (ti + usize(1)));
+          return(recur(pb, pi + usize(1), tb, ti + usize(1)));
         },
         true => {
-          return false;
+          return(false);
         }
       );
     },
     true => ()
   );
-
   // Handle [...]
   cond(
     (p == u8(91)) => {
@@ -142,7 +133,7 @@ _glob_match_impl :: (fn(pb: ArrayList(u8), pi: usize, tb: ArrayList(u8), ti: usi
       // Scan characters in class until ]
       found := false;
       cdone := false;
-      while (((ci < pb.len()) && (!(cdone)))), (ci = (ci + usize(1))), {
+      while((ci < pb.len()) && (!(cdone)), ci = (ci + usize(1)), {
         ch := pb.get(ci).unwrap();
         cond(
           (ch == u8(93)) => {
@@ -157,11 +148,11 @@ _glob_match_impl :: (fn(pb: ArrayList(u8), pi: usize, tb: ArrayList(u8), ti: usi
             );
           }
         );
-      };
+      });
       // Malformed pattern (no closing ])
       cond(
         (!(cdone)) => {
-          return false;
+          return(false);
         },
         true => ()
       );
@@ -171,39 +162,35 @@ _glob_match_impl :: (fn(pb: ArrayList(u8), pi: usize, tb: ArrayList(u8), ti: usi
       );
       cond(
         matched => {
-          return recur(pb, ci, tb, (ti + usize(1)));
+          return(recur(pb, ci, tb, ti + usize(1)));
         },
         true => {
-          return false;
+          return(false);
         }
       );
     },
     true => ()
   );
-
   // Literal byte match
   cond(
-    (p == t) => recur(pb, (pi + usize(1)), tb, (ti + usize(1))),
+    (p == t) => recur(pb, pi + usize(1), tb, ti + usize(1)),
     true => false
   )
 });
-
-glob_match :: (fn(pattern: String, text: String) -> bool)(
+glob_match :: (fn(pattern : String, text : String) -> bool)(
   _glob_match_impl(pattern.as_bytes(), usize(0), text.as_bytes(), usize(0))
 );
-
 /// Compiled glob pattern that can be matched against strings.
 GlobPattern :: object(
   _pattern : String
 );
-
-impl(GlobPattern,
-  new : (fn(pattern: String) -> Self)(
-    Self(_pattern: pattern)
+impl(
+  GlobPattern,
+  new : (fn(pattern : String) -> Self)(
+    Self(_pattern : pattern)
   ),
-  matches : (fn(self: Self, text: String) -> bool)(
+  matches : (fn(self : Self, text : String) -> bool)(
     _glob_match_impl(self._pattern.as_bytes(), usize(0), text.as_bytes(), usize(0))
   )
 );
-
-export glob_match, GlobPattern;
+export(glob_match, GlobPattern);