@shd101wyy/yo 0.1.25 → 0.1.27

package/std/collections/linked_list.yo

@@ -1,200 +1,185 @@
 //! Doubly-linked list with O(1) push/pop at both ends.
-
 /// Error variants for LinkedList operations.
 LinkedListError :: enum(
   /// Index is out of bounds for the current length.
-  IndexOutOfBounds(index: usize, length: usize),
+  IndexOutOfBounds(index : usize, length : usize),
   /// Attempted to access an element from an empty list.
   EmptyList
 );
-
 /// Internal node for the linked list. Reference-counted via `object`.
-Node :: (fn(comptime(T): Type) -> comptime(Type))
+Node :: (fn(comptime(T) : Type) -> comptime(Type))(
   object(
     value : T,
     next : Option(Self),
     prev : Option(Self)
   )
-;
-
+);
 /// Doubly-linked list with O(1) push/pop at both ends.
-LinkedList :: (fn(comptime(T): Type) -> comptime(Type))
+LinkedList :: (fn(comptime(T) : Type) -> comptime(Type))(
   object(
     head : Option(Node(T)),
     tail : Option(Node(T)),
     length : usize
   )
-;
-
-impl(forall(T : Type), LinkedList(T),
+);
+impl(
+  forall(T : Type),
+  LinkedList(T),
   /**
-    * Create a new empty LinkedList
-    */
+  * Create a new empty LinkedList
+  */
   new : (fn() -> Self)(
     Self(
-      head: .None,
-      tail: .None,
-      length: usize(0)
+      head :.None,
+      tail :.None,
+      length : usize(0)
     )
   ),
-
   /**
-    * Get the number of elements in the list
-    */
-  len : (fn(self: Self) -> usize)(
+  * Get the number of elements in the list
+  */
+  len : (fn(self : Self) -> usize)(
     self.length
   ),
-
   /**
-    * Check if the list is empty
-    */
-  is_empty : (fn(self: Self) -> bool)(
-    (self.length == usize(0))
+  * Check if the list is empty
+  */
+  is_empty : (fn(self : Self) -> bool)(
+    self.length == usize(0)
   ),
-
   /**
-    * Push an element to the front of the list
-    * O(1) time complexity
-    */
-  push_front : (fn(self: Self, value: T) -> unit)(
-    {
-      new_node := Node(T)(
-        value: value,
-        next: self.head,
-        prev: .None
-      );
-      
-      match(self.head,
-        .None => {
-          self.tail = .Some(new_node);
-        },
-        .Some(old_head) => {
-          old_head.prev = .Some(new_node);
-        }
-      );
-      
-      self.head = .Some(new_node);
-      self.length = (self.length + usize(1));
-    }
-  ),
-
+  * Push an element to the front of the list
+  * O(1) time complexity
+  */
+  push_front : (fn(self : Self, value : T) -> unit)({
+    new_node := Node(T)(
+      value : value,
+      next : self.head,
+      prev :.None
+    );
+    match(
+      self.head,
+      .None => {
+        self.tail =.Some(new_node);
+      },
+      .Some(old_head) => {
+        old_head.prev =.Some(new_node);
+      }
+    );
+    self.head =.Some(new_node);
+    self.length = (self.length + usize(1));
+  }),
   /**
-    * Push an element to the back of the list
-    * O(1) time complexity
-    */
-  push_back : (fn(self: Self, value: T) -> unit)(
-    {
-      new_node := Node(T)(
-        value: value,
-        next: .None,
-        prev: self.tail
-      );
-      
-      match(self.tail,
-        .None => {
-          self.head = .Some(new_node);
-        },
-        .Some(old_tail) => {
-          old_tail.next = .Some(new_node);
-        }
-      );
-      
-      self.tail = .Some(new_node);
-      self.length = (self.length + usize(1));
-    }
-  ),
-
+  * Push an element to the back of the list
+  * O(1) time complexity
+  */
+  push_back : (fn(self : Self, value : T) -> unit)({
+    new_node := Node(T)(
+      value : value,
+      next :.None,
+      prev : self.tail
+    );
+    match(
+      self.tail,
+      .None => {
+        self.head =.Some(new_node);
+      },
+      .Some(old_tail) => {
+        old_tail.next =.Some(new_node);
+      }
+    );
+    self.tail =.Some(new_node);
+    self.length = (self.length + usize(1));
+  }),
   /**
-    * Remove and return the element from the front
-    * O(1) time complexity
-    */
-  pop_front : (fn(self: Self) -> Option(T))(
-    match(self.head,
-      .None => .None,
+  * Remove and return the element from the front
+  * O(1) time complexity
+  */
+  pop_front : (fn(self : Self) -> Option(T))(
+    match(
+      self.head,
+      .None =>.None,
       .Some(old_head) => {
         value := old_head.value;
         new_head_opt := old_head.next;
-        
-        match(new_head_opt,
+        match(
+          new_head_opt,
           .None => {
-            self.head = .None;
-            self.tail = .None;
+            self.head =.None;
+            self.tail =.None;
           },
           .Some(new_head) => {
-            new_head.prev = .None;
-            self.head = .Some(new_head);
+            new_head.prev =.None;
+            self.head =.Some(new_head);
           }
         );
-        
         self.length = (self.length - usize(1));
         .Some(value)
       }
     )
   ),
-
   /**
-    * Remove and return the element from the back
-    * O(1) time complexity
-    */
-  pop_back : (fn(self: Self) -> Option(T))(
-    match(self.tail,
-      .None => .None,
+  * Remove and return the element from the back
+  * O(1) time complexity
+  */
+  pop_back : (fn(self : Self) -> Option(T))(
+    match(
+      self.tail,
+      .None =>.None,
       .Some(old_tail) => {
         value := old_tail.value;
         new_tail_opt := old_tail.prev;
-        
-        match(new_tail_opt,
+        match(
+          new_tail_opt,
           .None => {
-            self.head = .None;
-            self.tail = .None;
+            self.head =.None;
+            self.tail =.None;
           },
           .Some(new_tail) => {
-            new_tail.next = .None;
-            self.tail = .Some(new_tail);
+            new_tail.next =.None;
+            self.tail =.Some(new_tail);
           }
         );
-        
         self.length = (self.length - usize(1));
         .Some(value)
       }
     )
   ),
-
   /**
-    * Get reference to the front element without removing it
-    */
-  front : (fn(self: Self) -> Option(T))(
-    match(self.head,
-      .None => .None,
-      .Some(head_node) => .Some(head_node.value)
+  * Get reference to the front element without removing it
+  */
+  front : (fn(self : Self) -> Option(T))(
+    match(
+      self.head,
+      .None =>.None,
+      .Some(head_node) =>.Some(head_node.value)
     )
   ),
-
   /**
-    * Get reference to the back element without removing it
-    */
-  back : (fn(self: Self) -> Option(T))(
-    match(self.tail,
-      .None => .None,
-      .Some(tail_node) => .Some(tail_node.value)
+  * Get reference to the back element without removing it
+  */
+  back : (fn(self : Self) -> Option(T))(
+    match(
+      self.tail,
+      .None =>.None,
+      .Some(tail_node) =>.Some(tail_node.value)
     )
   ),
-
   /**
-    * Get element at a specific index
-    * O(n) time complexity
-    */
-  get : (fn(self: Self, index: usize) -> Option(T))(
+  * Get element at a specific index
+  * O(n) time complexity
+  */
+  get : (fn(self : Self, index : usize) -> Option(T))(
     cond(
-      (index >= self.length) => .None,
+      (index >= self.length) =>.None,
       true => {
         current_opt := self.head;
         i := usize(0);
-        
         while(i < index, i = (i + usize(1)), {
-          match(current_opt,
+          match(
+            current_opt,
             .None => {
-              return .None;
+              return(.None);
             },
             .Some(current) => {
               current_opt = current.next;
@@ -202,22 +187,21 @@ impl(forall(T : Type), LinkedList(T),
             }
           );
         });
-        
-        match(current_opt,
-          .None => .None,
-          .Some(node) => .Some(node.value)
+        match(
+          current_opt,
+          .None =>.None,
+          .Some(node) =>.Some(node.value)
         )
       }
     )
   ),
-
   /**
-    * Insert element at a specific index
-    * O(n) time complexity
-    */
-  insert : (fn(self: Self, index: usize, value: T) -> Result(unit, LinkedListError))(
+  * Insert element at a specific index
+  * O(n) time complexity
+  */
+  insert : (fn(self : Self, index : usize, value : T) -> Result(unit, LinkedListError))(
     cond(
-      (index > self.length) => .Err(.IndexOutOfBounds(index: index, length: self.length)),
+      (index > self.length) =>.Err(.IndexOutOfBounds(index : index, length : self.length)),
       (index == usize(0)) => {
         self.push_front(value);
         .Ok(())
@@ -229,40 +213,37 @@ impl(forall(T : Type), LinkedList(T),
       true => {
         current_opt := self.head;
         i := usize(0);
-        
         while(i < index, i = (i + usize(1)), {
-          match(current_opt,
+          match(
+            current_opt,
             .None => {
-              return .Err(.IndexOutOfBounds(index: index, length: self.length));
+              return(.Err(.IndexOutOfBounds(index : index, length : self.length)));
             },
             .Some(current) => {
               current_opt = current.next;
             }
           );
         });
-        
-        match(current_opt,
-          .None => .Err(.IndexOutOfBounds(index: index, length: self.length)),
+        match(
+          current_opt,
+          .None =>.Err(.IndexOutOfBounds(index : index, length : self.length)),
           .Some(current) => {
             prev_opt := current.prev;
-            
             new_node := Node(T)(
-              value: value,
-              next: .Some(current),
-              prev: prev_opt
+              value : value,
+              next :.Some(current),
+              prev : prev_opt
             );
-            
-            current.prev = .Some(new_node);
-            
-            match(prev_opt,
+            current.prev =.Some(new_node);
+            match(
+              prev_opt,
               .None => {
-                self.head = .Some(new_node);
+                self.head =.Some(new_node);
               },
               .Some(prev_node) => {
-                prev_node.next = .Some(new_node);
+                prev_node.next =.Some(new_node);
               }
             );
-            
             self.length = (self.length + usize(1));
             .Ok(())
           }
@@ -270,47 +251,48 @@ impl(forall(T : Type), LinkedList(T),
       }
     )
   ),
-
   /**
-    * Remove element at a specific index
-    * O(n) time complexity
-    */
-  remove : (fn(self: Self, index: usize) -> Result(T, LinkedListError))(
+  * Remove element at a specific index
+  * O(n) time complexity
+  */
+  remove : (fn(self : Self, index : usize) -> Result(T, LinkedListError))(
     cond(
-      (index >= self.length) => .Err(.IndexOutOfBounds(index: index, length: self.length)),
+      (index >= self.length) =>.Err(.IndexOutOfBounds(index : index, length : self.length)),
       (index == usize(0)) =>
-        match(self.pop_front(),
-          .Some(value) => .Ok(value),
-          .None => .Err(.EmptyList)
+        match(
+          self.pop_front(),
+          .Some(value) =>.Ok(value),
+          .None =>.Err(.EmptyList)
         ),
       (index == (self.length - usize(1))) =>
-        match(self.pop_back(),
-          .Some(value) => .Ok(value),
-          .None => .Err(.EmptyList)
+        match(
+          self.pop_back(),
+          .Some(value) =>.Ok(value),
+          .None =>.Err(.EmptyList)
         ),
       true => {
         current_opt := self.head;
         i := usize(0);
-        
         while(i < index, i = (i + usize(1)), {
-          match(current_opt,
+          match(
+            current_opt,
             .None => {
-              return .Err(.IndexOutOfBounds(index: index, length: self.length));
+              return(.Err(.IndexOutOfBounds(index : index, length : self.length)));
             },
             .Some(current) => {
               current_opt = current.next;
             }
           );
         });
-        
-        match(current_opt,
-          .None => .Err(.IndexOutOfBounds(index: index, length: self.length)),
+        match(
+          current_opt,
+          .None =>.Err(.IndexOutOfBounds(index : index, length : self.length)),
           .Some(node_to_remove) => {
             value := node_to_remove.value;
             prev_opt := node_to_remove.prev;
             next_opt := node_to_remove.next;
-            
-            match(prev_opt,
+            match(
+              prev_opt,
               .Some(prev_node) => {
                 prev_node.next = next_opt;
               },
@@ -318,8 +300,8 @@ impl(forall(T : Type), LinkedList(T),
                 self.head = next_opt;
               }
             );
-            
-            match(next_opt,
+            match(
+              next_opt,
               .Some(next_node) => {
                 next_node.prev = prev_opt;
               },
@@ -327,7 +309,6 @@ impl(forall(T : Type), LinkedList(T),
                 self.tail = prev_opt;
               }
             );
-            
             self.length = (self.length - usize(1));
             .Ok(value)
           }
@@ -335,154 +316,155 @@ impl(forall(T : Type), LinkedList(T),
       }
     )
   ),
-
   /**
-    * Clear all elements from the list
-    */
-  clear : (fn(self: Self) -> unit)(
-    {
-      while((self.length > usize(0)), {
-        _ := self.pop_front();
-      });
-    }
-  ),
-
+  * Clear all elements from the list
+  */
+  clear : (fn(self : Self) -> unit)({
+    while(self.length > usize(0), {
+      _ := self.pop_front();
+    });
+  }),
   /**
-    * Check if the list contains a value
-    * O(n) time complexity
-    */
-  contains : (fn(
-    self: Self, 
-    value: T,
-    where(T <: Eq(T))
-  ) -> bool)(
-    {
-      current_opt := self.head;
-      i := usize(0);
-      
-      while(i < self.length, i = (i + usize(1)), {
-        match(current_opt,
-          .None => {
-            return false;
-          },
-          .Some(current) => {
-            cond(
-              (current.value == value) => {
-                return true;
-              },
-              true => {
-                current_opt = current.next;
-              }
-            );
-          }
-        );
-      });
-      
-      false
-    }
-  ),
-
+  * Check if the list contains a value
+  * O(n) time complexity
+  */
+  contains : (
+    fn(
+      self : Self,
+      value : T,
+      where(T <: Eq(T))
+    ) -> bool
+  )({
+    current_opt := self.head;
+    i := usize(0);
+    while(i < self.length, i = (i + usize(1)), {
+      match(
+        current_opt,
+        .None => {
+          return(false);
+        },
+        .Some(current) => {
+          cond(
+            (current.value == value) => {
+              return(true);
+            },
+            true => {
+              current_opt = current.next;
+            }
+          );
+        }
+      );
+    });
+    false
+  }),
   /**
-    * Reverse the list in place
-    * O(n) time complexity
-    */
-  reverse : (fn(self: Self) -> unit)(
-    {
-      current_opt := self.head;
-      i := usize(0);
-      
-      while(i < self.length, i = (i + usize(1)), {
-        match(current_opt,
-          .None => {
-            return;
-          },
-          .Some(current) => {
-            temp := current.next;
-            current.next = current.prev;
-            current.prev = temp;
-            current_opt = temp;
-          }
-        );
-      });
-      
-      temp_head := self.head;
-      self.head = self.tail;
-      self.tail = temp_head;
-    }
-  )
+  * Reverse the list in place
+  * O(n) time complexity
+  */
+  reverse : (fn(self : Self) -> unit)({
+    current_opt := self.head;
+    i := usize(0);
+    while(i < self.length, i = (i + usize(1)), {
+      match(
+        current_opt,
+        .None => {
+          return;
+        },
+        .Some(current) => {
+          temp := current.next;
+          current.next = current.prev;
+          current.prev = temp;
+          current_opt = temp;
+        }
+      );
+    });
+    temp_head := self.head;
+    self.head = self.tail;
+    self.tail = temp_head;
+  })
 );
-
-impl(forall(T : Type), LinkedList(T), Dispose(
-  /**
+impl(
+  forall(T : Type),
+  LinkedList(T),
+  Dispose(
+    /**
     * RAII destructor - automatically called when LinkedList goes out of scope
     */
-  dispose : (fn(self: Self) -> unit)(
-    self.clear()
+    dispose : (fn(self : Self) -> unit)(
+      self.clear()
+    )
   )
-));
-
+);
 /**
- * Value iterator for LinkedList - yields elements by value (T)
- * Traverses the linked list following node.next pointers.
- */
+* Value iterator for LinkedList - yields elements by value (T)
+* Traverses the linked list following node.next pointers.
+*/
 LinkedListIter :: (fn(comptime(T) : Type) -> comptime(Type))(
   struct(
     _current : Option(Node(T))
   )
 );
-
-impl(forall(T : Type), LinkedListIter(T), Iterator(
-  Item : T,
-  next : (fn(self : *(Self)) -> Option(T))(
-    match(self._current,
-      .None => .None,
-      .Some(node) => {
-        self._current = node.next;
-        .Some(node.value)
-      }
+impl(
+  forall(T : Type),
+  LinkedListIter(T),
+  Iterator(
+    Item : T,
+    next : (fn(self : *(Self)) -> Option(T))(
+      match(
+        self._current,
+        .None =>.None,
+        .Some(node) => {
+          self._current = node.next;
+          .Some(node.value)
+        }
+      )
     )
   )
-));
-
-impl(forall(T : Type), LinkedList(T),
+);
+impl(
+  forall(T : Type),
+  LinkedList(T),
   into_iter : (fn(self : Self) -> LinkedListIter(T))(
-    LinkedListIter(T)(_current: self.head)
+    LinkedListIter(T)(_current : self.head)
   )
 );
-
 /**
- * Pointer iterator for LinkedList - yields pointers to elements (*(T))
- * Yields &(node.value) for each node. Pointers are valid as long as
- * the list is not modified during iteration.
- */
+* Pointer iterator for LinkedList - yields pointers to elements (*(T))
+* Yields &(node.value) for each node. Pointers are valid as long as
+* the list is not modified during iteration.
+*/
 LinkedListIterPtr :: (fn(comptime(T) : Type) -> comptime(Type))(
   struct(
     _current : Option(Node(T))
   )
 );
-
-impl(forall(T : Type), LinkedListIterPtr(T), Iterator(
-  Item : *(T),
-  next : (fn(self : *(Self)) -> Option(*(T)))(
-    match(self._current,
-      .None => .None,
-      .Some(node) => {
-        self._current = node.next;
-        .Some(&(node.value))
-      }
+impl(
+  forall(T : Type),
+  LinkedListIterPtr(T),
+  Iterator(
+    Item : *(T),
+    next : (fn(self : *(Self)) -> Option(*(T)))(
+      match(
+        self._current,
+        .None =>.None,
+        .Some(node) => {
+          self._current = node.next;
+          .Some(&(node.value))
+        }
+      )
     )
   )
-));
-
-impl(forall(T : Type), LinkedList(T),
+);
+impl(
+  forall(T : Type),
+  LinkedList(T),
   iter : (fn(self : *(Self)) -> LinkedListIterPtr(T))(
-    LinkedListIterPtr(T)(_current: self.*.head)
+    LinkedListIterPtr(T)(_current : self.*.head)
   )
 );
-
-export
+export(
   LinkedList,
   LinkedListError,
   LinkedListIter,
   LinkedListIterPtr
-;
+);