@shd101wyy/yo 0.1.26 → 0.1.27

package/std/collections/ordered_map.yo

@@ -32,44 +32,41 @@
 //!   );
 //! };
 //! ```
-
-open import "./array_list";
-open import "./hash_map";
-
+open(import("./array_list"));
+open(import("./hash_map"));
 /// Ordered map preserving insertion order of keys.
 /// Keys must implement `Eq` and `Hash`.
-OrderedMap :: (fn(
-  comptime(K) : Type,
-  comptime(V) : Type,
-  where(K <: (Eq(K), Hash))
-) -> comptime(Type))
+OrderedMap :: (
+  fn(
+    comptime(K) : Type,
+    comptime(V) : Type,
+    where(K <: (Eq(K), Hash))
+  ) -> comptime(Type)
+)(
   object(
     _map : HashMap(K, V),
     _order : ArrayList(K)
   )
-;
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), OrderedMap(K, V),
+);
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  OrderedMap(K, V),
   /// Create an empty `OrderedMap`.
   new : (fn() -> Self)(
     Self(
-      _map: HashMap(K, V).new(),
-      _order: ArrayList(K).new()
+      _map : HashMap(K, V).new(),
+      _order : ArrayList(K).new()
     )
   ),
-
   /// Number of entries.
   len : (fn(self : Self) -> usize)(self._map.len()),
-
   /// Whether the map is empty.
   is_empty : (fn(self : Self) -> bool)(self._map.is_empty()),
-
   /// Returns `true` if `key` is present.
   contains_key : (fn(self : Self, key : K) -> bool)(self._map.contains_key(key)),
-
   /// Returns the value for `key`, or `.None`.
   get : (fn(self : Self, key : K) -> Option(V))(self._map.get(key)),
-
   /// Insert or update `key -> value`.
   ///
   /// - For a new key, appends `key` to the insertion order.
@@ -81,164 +78,195 @@ impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), OrderedMap(K, V),
     is_new := !(self._map.contains_key(key));
     result := self._map.set(key, value);
     cond(
-      is_new => match(result,
-        .Ok(_) => { self._order.push(key); },
+      is_new => match(
+        result,
+        .Ok(_) => {
+          self._order.push(key);
+        },
         .Err(_) => ()
       ),
       true => ()
     );
-    return result;
+    return(result);
   }),
-
   /// Remove `key`. Returns the removed value or `.None`.
   /// O(n) — rebuilds the key order list to drop the removed key.
   remove : (fn(self : Self, key : K) -> Option(V))({
     removed := self._map.remove(key);
-    match(removed,
+    match(
+      removed,
       .Some(_) => {
         new_order := ArrayList(K).new();
         i := usize(0);
         n := self._order.len();
-        while (i < n), (i = (i + usize(1))), {
-          match(self._order.get(i),
+        while(i < n, i = (i + usize(1)), {
+          match(
+            self._order.get(i),
             .Some(k) => {
               cond(
                 (k == key) => (),
-                true => { new_order.push(k); }
+                true => {
+                  new_order.push(k);
+                }
               );
             },
             .None => ()
           );
-        };
+        });
         self._order = new_order;
       },
       .None => ()
     );
-    return removed;
+    return(removed);
   }),
-
   /// Remove all entries.
   clear : (fn(self : Self) -> unit)({
     self._map.clear();
     self._order = ArrayList(K).new();
   })
 );
-
 /// Iterator over the keys of an `OrderedMap` in insertion order.
-OrderedMapKeys :: (fn(
-  comptime(K) : Type,
-  comptime(V) : Type,
-  where(K <: (Eq(K), Hash))
-) -> comptime(Type))
+OrderedMapKeys :: (
+  fn(
+    comptime(K) : Type,
+    comptime(V) : Type,
+    where(K <: (Eq(K), Hash))
+  ) -> comptime(Type)
+)(
   object(
     _map : OrderedMap(K, V),
     _index : usize
   )
-;
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), OrderedMapKeys(K, V),
+);
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  OrderedMapKeys(K, V),
   next : (fn(self : *(Self)) -> Option(K))({
     cond(
-      (self._index >= self._map._order.len()) => { return .None; },
+      (self._index >= self._map._order.len()) => {
+        return(.None);
+      },
       true => ()
     );
     k := self._map._order.get(self._index);
     self._index = (self._index + usize(1));
-    return k;
+    return(k);
   })
 );
-
 /// Iterator over the values of an `OrderedMap` in insertion order.
-OrderedMapValues :: (fn(
-  comptime(K) : Type,
-  comptime(V) : Type,
-  where(K <: (Eq(K), Hash))
-) -> comptime(Type))
+OrderedMapValues :: (
+  fn(
+    comptime(K) : Type,
+    comptime(V) : Type,
+    where(K <: (Eq(K), Hash))
+  ) -> comptime(Type)
+)(
   object(
     _map : OrderedMap(K, V),
     _index : usize
   )
-;
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), OrderedMapValues(K, V),
+);
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  OrderedMapValues(K, V),
   next : (fn(self : *(Self)) -> Option(V))({
     cond(
-      (self._index >= self._map._order.len()) => { return .None; },
+      (self._index >= self._map._order.len()) => {
+        return(.None);
+      },
       true => ()
     );
-    match(self._map._order.get(self._index),
+    match(
+      self._map._order.get(self._index),
       .Some(k) => {
         self._index = (self._index + usize(1));
-        return self._map._map.get(k);
+        return(self._map._map.get(k));
       },
-      .None => { return .None; }
+      .None => {
+        return(.None);
+      }
     );
   })
 );
-
 /// Key-value pair yielded by `OrderedMapIter`.
-OrderedMapEntry :: (fn(
-  comptime(K) : Type,
-  comptime(V) : Type
-) -> comptime(Type))
+OrderedMapEntry :: (
+  fn(
+    comptime(K) : Type,
+    comptime(V) : Type
+  ) -> comptime(Type)
+)(
   struct(
     key : K,
     value : V
   )
-;
-
+);
 /// Iterator over `(key, value)` pairs of an `OrderedMap` in insertion order.
-OrderedMapIter :: (fn(
-  comptime(K) : Type,
-  comptime(V) : Type,
-  where(K <: (Eq(K), Hash))
-) -> comptime(Type))
+OrderedMapIter :: (
+  fn(
+    comptime(K) : Type,
+    comptime(V) : Type,
+    where(K <: (Eq(K), Hash))
+  ) -> comptime(Type)
+)(
   object(
     _map : OrderedMap(K, V),
     _index : usize
   )
-;
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), OrderedMapIter(K, V),
+);
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  OrderedMapIter(K, V),
   next : (fn(self : *(Self)) -> Option(OrderedMapEntry(K, V)))({
     cond(
-      (self._index >= self._map._order.len()) => { return .None; },
+      (self._index >= self._map._order.len()) => {
+        return(.None);
+      },
       true => ()
     );
-    match(self._map._order.get(self._index),
+    match(
+      self._map._order.get(self._index),
       .Some(k) => {
         self._index = (self._index + usize(1));
-        match(self._map._map.get(k),
-          .Some(v) => { return .Some(OrderedMapEntry(K, V)(key: k, value: v)); },
-          .None => { return .None; }
+        match(
+          self._map._map.get(k),
+          .Some(v) => {
+            return(.Some(OrderedMapEntry(K, V)(key : k, value : v)));
+          },
+          .None => {
+            return(.None);
+          }
         );
       },
-      .None => { return .None; }
+      .None => {
+        return(.None);
+      }
     );
   })
 );
-
-impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), OrderedMap(K, V),
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  OrderedMap(K, V),
   /// Iterator over keys in insertion order.
   keys : (fn(self : Self) -> OrderedMapKeys(K, V))(
-    OrderedMapKeys(K, V)(_map: self, _index: usize(0))
+    OrderedMapKeys(K, V)(_map : self, _index : usize(0))
   ),
-
   /// Iterator over values in insertion order.
   values : (fn(self : Self) -> OrderedMapValues(K, V))(
-    OrderedMapValues(K, V)(_map: self, _index: usize(0))
+    OrderedMapValues(K, V)(_map : self, _index : usize(0))
   ),
-
   /// Iterator over `(key, value)` pairs in insertion order.
   iter : (fn(self : Self) -> OrderedMapIter(K, V))(
-    OrderedMapIter(K, V)(_map: self, _index: usize(0))
+    OrderedMapIter(K, V)(_map : self, _index : usize(0))
   )
 );
-
-export
+export(
   OrderedMap,
   OrderedMapEntry,
   OrderedMapKeys,
   OrderedMapValues,
   OrderedMapIter
-;
+);

package/std/collections/priority_queue.yo

@@ -11,9 +11,7 @@
 //! pq.push(3);
 //! x := pq.pop().unwrap();  // 1
 //! ```
-
-{ ArrayList } :: import "./array_list";
-
+{ ArrayList } :: import("./array_list");
 /// Min-heap backed by an ArrayList.
 /// Elements are ordered ascending (smallest first). Negate keys for max-heap behavior.
 PriorityQueue :: (fn(comptime(T) : Type) -> comptime(Type))(
@@ -21,39 +19,36 @@ PriorityQueue :: (fn(comptime(T) : Type) -> comptime(Type))(
     _data : ArrayList(T)
   )
 );
-
-impl(forall(T : Type), PriorityQueue(T),
+impl(
+  forall(T : Type),
+  PriorityQueue(T),
   // Create an empty priority queue.
   new : (fn() -> Self)(
-    Self(_data: ArrayList(T).new())
+    Self(_data : ArrayList(T).new())
   ),
-
   // Number of elements.
-  len : (fn(self: Self) -> usize)(
+  len : (fn(self : Self) -> usize)(
     self._data.len()
   ),
-
   // True if empty.
-  is_empty : (fn(self: Self) -> bool)(
-    (self._data.len() == usize(0))
+  is_empty : (fn(self : Self) -> bool)(
+    self._data.len() == usize(0)
   ),
-
   // Inspect the smallest element without removing it.
-  peek : (fn(self: Self) -> Option(T))(
+  peek : (fn(self : Self) -> Option(T))(
     cond(
-      (self._data.len() == usize(0)) => .None,
+      (self._data.len() == usize(0)) =>.None,
       true => self._data.get(usize(0))
     )
   ),
-
   // Insert a new element.
-  push : (fn(self: Self, val: T, where(T <: Ord(T))) -> unit)({
+  push : (fn(self : Self, val : T, where(T <: Ord(T))) -> unit)({
     self._data.push(val);
     // Sift up
     i := (self._data.len() - usize(1));
-    while (i > usize(0)), {
+    while(i > usize(0), {
       parent := ((i - usize(1)) / usize(2));
-      child_val  := self._data.get(i).unwrap();
+      child_val := self._data.get(i).unwrap();
       parent_val := self._data.get(parent).unwrap();
       cond(
         (child_val < parent_val) => {
@@ -65,23 +60,22 @@ impl(forall(T : Type), PriorityQueue(T),
           break;
         }
       );
-    };
+    });
   }),
-
   // Remove and return the smallest element.
-  pop : (fn(self: Self, where(T <: Ord(T))) -> Option(T))({
+  pop : (fn(self : Self, where(T <: Ord(T))) -> Option(T))({
     n := self._data.len();
     cond(
-      (n == usize(0)) => .None,
+      (n == usize(0)) =>.None,
       true => {
-        top  := self._data.get(usize(0)).unwrap();
-        last := self._data.get((n - usize(1))).unwrap();
+        top := self._data.get(usize(0)).unwrap();
+        last := self._data.get(n - usize(1)).unwrap();
         &(self._data(usize(0))).* = last;
         self._data.pop();
         // Sift down
         i := usize(0);
-        while runtime(true), {
-          left  := ((i * usize(2)) + usize(1));
+        while(runtime(true), {
+          left := ((i * usize(2)) + usize(1));
           right := ((i * usize(2)) + usize(2));
           smallest := i;
           new_n := self._data.len();
@@ -109,80 +103,86 @@ impl(forall(T : Type), PriorityQueue(T),
               i = smallest;
             }
           );
-        };
+        });
         .Some(top)
       }
     )
   })
 );
-
 /**
- * Value iterator for PriorityQueue - yields elements in heap (arbitrary) order
- * Note: This iterates in internal storage order, NOT sorted order.
- */
+* Value iterator for PriorityQueue - yields elements in heap (arbitrary) order
+* Note: This iterates in internal storage order, NOT sorted order.
+*/
 PriorityQueueIter :: (fn(comptime(T) : Type) -> comptime(Type))(
   struct(
-    _data  : ArrayList(T),
+    _data : ArrayList(T),
     _index : usize
   )
 );
-
-impl(forall(T : Type), PriorityQueueIter(T), Iterator(
-  Item : T,
-  next : (fn(self : *(Self)) -> Option(T))(
-    cond(
-      (self._index >= self._data.len()) => .None,
-      true => {
-        value := self._data.get(self._index).unwrap();
-        self._index = (self._index + usize(1));
-        .Some(value)
-      }
+impl(
+  forall(T : Type),
+  PriorityQueueIter(T),
+  Iterator(
+    Item : T,
+    next : (fn(self : *(Self)) -> Option(T))(
+      cond(
+        (self._index >= self._data.len()) =>.None,
+        true => {
+          value := self._data.get(self._index).unwrap();
+          self._index = (self._index + usize(1));
+          .Some(value)
+        }
+      )
     )
   )
-));
-
-impl(forall(T : Type), PriorityQueue(T),
+);
+impl(
+  forall(T : Type),
+  PriorityQueue(T),
   into_iter : (fn(self : Self) -> PriorityQueueIter(T))(
-    PriorityQueueIter(T)(_data: self._data, _index: usize(0))
+    PriorityQueueIter(T)(_data : self._data, _index : usize(0))
   )
 );
-
 /**
- * Pointer iterator for PriorityQueue - yields pointers to elements in heap order
- */
+* Pointer iterator for PriorityQueue - yields pointers to elements in heap order
+*/
 PriorityQueueIterPtr :: (fn(comptime(T) : Type) -> comptime(Type))(
   struct(
-    _data  : ArrayList(T),
+    _data : ArrayList(T),
     _index : usize
   )
 );
-
-impl(forall(T : Type), PriorityQueueIterPtr(T), Iterator(
-  Item : *(T),
-  next : (fn(self : *(Self)) -> Option(*(T)))(
-    cond(
-      (self._index >= self._data.len()) => .None,
-      true =>
-        match(self._data._ptr,
-          .Some(ptr) => {
-            element_ptr := (ptr &+ self._index);
-            self._index = (self._index + usize(1));
-            .Some(element_ptr)
-          },
-          .None => .None
-        )
+impl(
+  forall(T : Type),
+  PriorityQueueIterPtr(T),
+  Iterator(
+    Item : *(T),
+    next : (fn(self : *(Self)) -> Option(*(T)))(
+      cond(
+        (self._index >= self._data.len()) =>.None,
+        true =>
+          match(
+            self._data._ptr,
+            .Some(ptr) => {
+              element_ptr := (ptr &+ self._index);
+              self._index = (self._index + usize(1));
+              .Some(element_ptr)
+            },
+            .None =>.None
+          )
+      )
     )
   )
-));
-
-impl(forall(T : Type), PriorityQueue(T),
+);
+impl(
+  forall(T : Type),
+  PriorityQueue(T),
   iter : (fn(self : *(Self)) -> PriorityQueueIterPtr(T))(
-    PriorityQueueIterPtr(T)(_data: self.*._data, _index: usize(0))
+    PriorityQueueIterPtr(T)(_data : self.*._data, _index : usize(0))
   )
 );
-
-export
+export(
   PriorityQueue,
   PriorityQueueIter,
   PriorityQueueIterPtr
-;
+);