@shd101wyy/yo 0.1.26 → 0.1.28

package/std/collections/deque.yo

@@ -10,92 +10,87 @@
 //! d.push_front(0);
 //! x := d.pop_front().unwrap();  // 0
 //! ```
-
-{ GlobalAllocator, AllocError } :: import "../allocator";
+{ GlobalAllocator, AllocError } :: import("../allocator");
 { malloc, realloc, free } :: GlobalAllocator;
-
 /// Circular buffer supporting efficient push/pop at both front and back.
 Deque :: (fn(comptime(T) : Type) -> comptime(Type))(
   object(
-    _buf      : ?*(T),
-    _head     : usize,
-    _tail     : usize,
-    _len      : usize,
+    _buf : ?*(T),
+    _head : usize,
+    _tail : usize,
+    _len : usize,
     _capacity : usize
   )
 );
-
-impl(forall(T : Type), Deque(T),
+impl(
+  forall(T : Type),
+  Deque(T),
   // Create an empty Deque.
   new : (fn() -> Self)(
-    Self(_buf: .None, _head: usize(0), _tail: usize(0), _len: usize(0), _capacity: usize(0))
+    Self(_buf :.None, _head : usize(0), _tail : usize(0), _len : usize(0), _capacity : usize(0))
   ),
-
   // Number of elements currently stored.
-  len : (fn(self: Self) -> usize)(
+  len : (fn(self : Self) -> usize)(
     self._len
   ),
-
   // True if the deque contains no elements.
-  is_empty : (fn(self: Self) -> bool)(
-    (self._len == usize(0))
+  is_empty : (fn(self : Self) -> bool)(
+    self._len == usize(0)
   ),
-
   // Ensure at least `min_cap` slots are available.
-  _grow : (fn(self: Self, min_cap: usize) -> unit)({
+  _grow : (fn(self : Self, min_cap : usize) -> unit)({
     new_cap := cond(
       (self._capacity == usize(0)) => usize(8),
       true => (self._capacity * usize(2))
     );
-    while (new_cap < min_cap), (new_cap = (new_cap * usize(2))), ();
+    while(new_cap < min_cap, new_cap = (new_cap * usize(2)), ());
     size := (new_cap * sizeof(T));
     new_buf := *(T)(malloc(size).unwrap());
     // Linearise existing elements into the new buffer
     i := usize(0);
-    while (i < self._len), (i = (i + usize(1))), {
+    while(i < self._len, i = (i + usize(1)), {
       idx := ((self._head + i) % self._capacity);
       buf := self._buf.unwrap();
       consume((new_buf &+ i).* = (buf &+ idx).*);
-    };
+    });
     // Drop old elements for RC types before freeing old buffer
     // (the copy above duped each element, so old slots still hold references)
     cond(
       Type.contains_rc_type(T) => {
         j := usize(0);
-        while (j < self._len), (j = (j + usize(1))), {
+        while(j < self._len, j = (j + usize(1)), {
           old_idx := ((self._head + j) % self._capacity);
           old_buf := self._buf.unwrap();
           unsafe.drop((old_buf &+ old_idx).*);
-        };
+        });
       },
       true => ()
     );
-    match(self._buf,
+    match(
+      self._buf,
       .Some(p) => free(.Some(*(void)(p))),
-      .None    => ()
+      .None => ()
     );
-    self._buf      = .Some(new_buf);
-    self._head     = usize(0);
-    self._tail     = self._len;
+    self._buf =.Some(new_buf);
+    self._head = usize(0);
+    self._tail = self._len;
     self._capacity = new_cap;
   }),
-
   // Push an element to the back.
-  push_back : (fn(self: Self, val: T) -> unit)({
+  push_back : (fn(self : Self, val : T) -> unit)({
     cond(
-      (self._len == self._capacity) => self._grow((self._len + usize(1))),
+      (self._len == self._capacity) => self._grow(self._len + usize(1)),
       true => ()
     );
     buf := self._buf.unwrap();
     consume((buf &+ self._tail).* = val);
     self._tail = ((self._tail + usize(1)) % self._capacity);
-    self._len  = (self._len + usize(1));
+    self._len = (self._len + usize(1));
   }),
-
   // Push an element to the front.
-  push_front : (fn(self: Self, val: T) -> unit)({
+  push_front : (fn(self : Self, val : T) -> unit)({
     cond(
-      (self._len == self._capacity) => self._grow((self._len + usize(1))),
+      (self._len == self._capacity) => self._grow(self._len + usize(1)),
       true => ()
     );
     self._head = cond(
@@ -106,27 +101,25 @@ impl(forall(T : Type), Deque(T),
     consume((buf &+ self._head).* = val);
     self._len = (self._len + usize(1));
   }),
-
   // Remove and return the front element.
-  pop_front : (fn(self: Self) -> ?T)(
+  pop_front : (fn(self : Self) -> ?(T))(
     cond(
-      (self._len == usize(0)) => .None,
+      (self._len == usize(0)) =>.None,
       true => {
         buf := self._buf.unwrap();
         element_ptr := (buf &+ self._head);
         val := element_ptr.*;
         unsafe.drop(element_ptr.*);
         self._head = ((self._head + usize(1)) % self._capacity);
-        self._len  = (self._len - usize(1));
+        self._len = (self._len - usize(1));
         .Some(val)
       }
     )
   ),
-
   // Remove and return the back element.
-  pop_back : (fn(self: Self) -> ?T)(
+  pop_back : (fn(self : Self) -> ?(T))(
     cond(
-      (self._len == usize(0)) => .None,
+      (self._len == usize(0)) =>.None,
       true => {
         self._tail = cond(
           (self._tail == usize(0)) => (self._capacity - usize(1)),
@@ -141,11 +134,10 @@ impl(forall(T : Type), Deque(T),
       }
     )
   ),
-
   // Get an element by logical index (0 = front).
-  get : (fn(self: Self, index: usize) -> ?T)(
+  get : (fn(self : Self, index : usize) -> ?(T))(
     cond(
-      (index >= self._len) => .None,
+      (index >= self._len) =>.None,
       true => {
         buf := self._buf.unwrap();
         idx := ((self._head + index) % self._capacity);
@@ -154,112 +146,124 @@ impl(forall(T : Type), Deque(T),
     )
   )
 );
-
-impl(forall(T : Type), Deque(T), Dispose(
-  dispose : (fn(self: Self) -> unit)({
-    match(self._buf,
-      .Some(p) => {
-        cond(
-          Type.contains_rc_type(T) => {
-            i := usize(0);
-            while (i < self._len), (i = (i + usize(1))), {
-              idx := ((self._head + i) % self._capacity);
-              unsafe.drop((p &+ idx).*);
-            };
-          },
-          true => ()
-        );
-        free(.Some(*(void)(p)));
-        self._buf = .None;
-      },
-      .None => ()
-    );
-  })
-));
-
+impl(
+  forall(T : Type),
+  Deque(T),
+  Dispose(
+    dispose : (fn(self : Self) -> unit)({
+      match(
+        self._buf,
+        .Some(p) => {
+          cond(
+            Type.contains_rc_type(T) => {
+              i := usize(0);
+              while(i < self._len, i = (i + usize(1)), {
+                idx := ((self._head + i) % self._capacity);
+                unsafe.drop((p &+ idx).*);
+              });
+            },
+            true => ()
+          );
+          free(.Some(*(void)(p)));
+          self._buf =.None;
+        },
+        .None => ()
+      );
+    })
+  )
+);
 /**
- * Value iterator for Deque - yields elements by value (T)
- * Traverses the circular buffer in logical order.
- */
+* Value iterator for Deque - yields elements by value (T)
+* Traverses the circular buffer in logical order.
+*/
 DequeIter :: (fn(comptime(T) : Type) -> comptime(Type))(
   struct(
-    _deque     : Deque(T),
-    _pos       : usize,
+    _deque : Deque(T),
+    _pos : usize,
     _remaining : usize
   )
 );
-
-impl(forall(T : Type), DequeIter(T), Iterator(
-  Item : T,
-  next : (fn(self : *(Self)) -> Option(T))(
-    cond(
-      (self._remaining == usize(0)) => .None,
-      true => {
-        idx := ((self._deque._head + self._pos) % self._deque._capacity);
-        buf := self._deque._buf.unwrap();
-        value := (buf &+ idx).*;
-        self._pos = (self._pos + usize(1));
-        self._remaining = (self._remaining - usize(1));
-        .Some(value)
-      }
+impl(
+  forall(T : Type),
+  DequeIter(T),
+  Iterator(
+    Item : T,
+    next : (fn(self : *(Self)) -> Option(T))(
+      cond(
+        (self._remaining == usize(0)) =>.None,
+        true => {
+          idx := ((self._deque._head + self._pos) % self._deque._capacity);
+          buf := self._deque._buf.unwrap();
+          value := (buf &+ idx).*;
+          self._pos = (self._pos + usize(1));
+          self._remaining = (self._remaining - usize(1));
+          .Some(value)
+        }
+      )
     )
   )
-));
-
-impl(forall(T : Type), Deque(T),
+);
+impl(
+  forall(T : Type),
+  Deque(T),
   into_iter : (fn(self : Self) -> DequeIter(T))(
-    DequeIter(T)(_deque: self, _pos: usize(0), _remaining: self._len)
+    DequeIter(T)(_deque : self, _pos : usize(0), _remaining : self._len)
   )
 );
-
 /**
- * Pointer iterator for Deque - yields pointers to elements (*(T))
- * Yields pointers into the circular buffer. Pointers are valid as long as
- * the deque is not modified during iteration.
- */
+* Pointer iterator for Deque - yields pointers to elements (*(T))
+* Yields pointers into the circular buffer. Pointers are valid as long as
+* the deque is not modified during iteration.
+*/
 DequeIterPtr :: (fn(comptime(T) : Type) -> comptime(Type))(
   struct(
-    _deque     : Deque(T),
-    _pos       : usize,
+    _deque : Deque(T),
+    _pos : usize,
     _remaining : usize
   )
 );
-
-impl(forall(T : Type), DequeIterPtr(T), Iterator(
-  Item : *(T),
-  next : (fn(self : *(Self)) -> Option(*(T)))(
-    cond(
-      (self._remaining == usize(0)) => .None,
-      true => {
-        idx := ((self._deque._head + self._pos) % self._deque._capacity);
-        buf := self._deque._buf.unwrap();
-        element_ptr := (buf &+ idx);
-        self._pos = (self._pos + usize(1));
-        self._remaining = (self._remaining - usize(1));
-        .Some(element_ptr)
-      }
+impl(
+  forall(T : Type),
+  DequeIterPtr(T),
+  Iterator(
+    Item : *(T),
+    next : (fn(self : *(Self)) -> Option(*(T)))(
+      cond(
+        (self._remaining == usize(0)) =>.None,
+        true => {
+          idx := ((self._deque._head + self._pos) % self._deque._capacity);
+          buf := self._deque._buf.unwrap();
+          element_ptr := (buf &+ idx);
+          self._pos = (self._pos + usize(1));
+          self._remaining = (self._remaining - usize(1));
+          .Some(element_ptr)
+        }
+      )
     )
   )
-));
-
-impl(forall(T : Type), Deque(T),
+);
+impl(
+  forall(T : Type),
+  Deque(T),
   iter : (fn(self : *(Self)) -> DequeIterPtr(T))(
-    DequeIterPtr(T)(_deque: self.*, _pos: usize(0), _remaining: self.*._len)
+    DequeIterPtr(T)(_deque : self.*, _pos : usize(0), _remaining : self.*._len)
   )
 );
-
-impl(forall(T : Type), Deque(T), Index(usize)(
-  Output : T,
-  index : (fn(self: *(Self), idx: usize) -> *(Self.Output))({
-    assert((idx < self.*._len), "Deque: index out of bounds");
-    buf := self.*._buf.unwrap();
-    physical_idx := ((self.*._head + idx) % self.*._capacity);
-    (buf &+ physical_idx)
-  })
-));
-
-export
+impl(
+  forall(T : Type),
+  Deque(T),
+  Index(usize)(
+    Output : T,
+    index : (fn(self : *(Self), idx : usize) -> *(Self.Output))({
+      assert(idx < self.*._len, "Deque: index out of bounds");
+      buf := self.*._buf.unwrap();
+      physical_idx := ((self.*._head + idx) % self.*._capacity);
+      buf &+ physical_idx
+    })
+  )
+);
+export(
   Deque,
   DequeIter,
   DequeIterPtr
-;
+);