@shd101wyy/yo 0.0.2

package/std/allocators/c_allocator.yo

@@ -0,0 +1,118 @@
+open import "../allocator.yo";
+open import "../libc/stdlib.yo";
+
+/*
+CAllocator :: struct(
+  CustomAllocator :: (CustomAllocator(
+    alloc : ((self, T, count) -> {
+      // Check for overflow
+      if size_would_overflow(T, count), {
+        return .Error(.InvalidSize);
+      };
+      
+      size := (usize(count * sizeof(T)));
+      some_ptr := malloc(size);
+      match some_ptr,
+        .Some(ptr) => {
+          // Cast the void pointer to the correct type
+          typed_ptr := ptr.cast(*(T));
+          .Ok(.Some(typed_ptr))
+        },
+        .None => .Error(.OutOfMemory)
+    }),
+
+    alloc_zeroed : ((self, T, count) -> {
+      // Check for overflow
+      if size_would_overflow(T, count), {
+        return .Error(.InvalidSize);
+      };
+      
+      some_ptr := calloc(count, usize(sizeof(T)));
+      match some_ptr,
+        .Some(ptr) => {
+          typed_ptr := ptr.cast(*(T));
+          .Ok(.Some(typed_ptr))
+        },
+        .None => .Error(.OutOfMemory)
+    }),
+
+    alloc_aligned : ((self, T, count, alignment) -> {
+      // Check for overflow
+      if size_would_overflow(T, count), {
+        return .Error(.InvalidSize);
+      };
+      
+      // Check if alignment is valid (power of 2)
+      if (
+          (alignment == usize(0)) ||
+          ((alignment & (alignment - usize(1))) != usize(0))
+      ), {
+        return .Error(.InvalidAlignment);
+      };
+      
+      // Check if alignment is at least as large as the type's natural alignment
+      natural_alignment := alignof(T);
+      if (alignment < natural_alignment), {
+        return .Error(.InvalidAlignment);
+      };
+      
+      // For now, fall back to regular malloc (would need aligned_alloc in real implementation)
+      size := (usize(count * sizeof(T)));
+      some_ptr := malloc(size);
+      match some_ptr,
+        .Some(ptr) => {
+          typed_ptr := ptr.cast(*(T));
+          .Ok(.Some(typed_ptr))
+        },
+        .None => .Error(.OutOfMemory)
+    }),
+
+    realloc : ((forall(T), self, some_old_ptr, new_count) -> {
+      // Check for overflow
+      if (size_would_overflow(T, new_count)), {
+        return .Error(.InvalidSize);
+      };
+      
+      // Handle null pointer case
+      match some_old_ptr,
+        .None => {
+          // Realloc with null pointer behaves like malloc
+          size := (new_usize(count * sizeof(T)));
+          some_ptr := malloc(size);
+          match some_ptr,
+            .Some(ptr) => {
+              typed_ptr := ptr.cast(*(T));
+              .Ok(.Some(typed_ptr))
+            },
+            .None => .Error(.OutOfMemory)
+        },
+        .Some(old_ptr) => {
+          raw_old := old_ptr.cast(*(void));
+
+          // Handle zero size case
+          if (new_count == usize(0)), {
+            free(.Some(raw_old));
+            return .Ok(.None);
+          };
+          
+          new_size := (new_usize(count * sizeof(T)));
+          some_new_ptr := realloc(.Some(raw_old), new_size);
+          match some_new_ptr,
+            .Some(new_ptr) => {
+              typed_ptr := new_ptr.cast(*(T));
+              .Ok(.Some(typed_ptr))
+            },
+            .None => .Error(.OutOfMemory)
+        }
+    }),
+
+    dealloc : ((forall(T), self, ptr) -> {
+      raw_ptr := ptr.cast(*(void));
+      free(.Some(raw_ptr));
+      .Ok(())
+    })
+  ))
+);
+
+export CAllocator;
+*/

package/std/async.yo

@@ -0,0 +1,13 @@
+// Async yield - suspends current task and allows other tasks to run
+// Implemented as an immediately-completing async block that forces a suspension point
+yield :: (fn() -> Impl(Future(unit)))
+  async {
+    // Empty async block that just completes immediately
+    // The act of awaiting this will cause the current task to suspend and re-enqueue
+    return ();
+  }
+;
+
+export
+  yield
+;

package/std/collections/array_list.yo

@@ -0,0 +1,415 @@
+/**
+ * ArrayList - A dynamic array implementation for Yo language
+ * 
+ * Similar to Rust's Vec<T> and Zig's ArrayList, this ArrayList provides:
+ * - Dynamic resizing
+ * - ~~Memory management via custom allocator~~
+ * - Type safety
+ * - RAII for automatic cleanup
+ */
+{ GlobalAllocator, AllocError } :: import "../allocator.yo";
+{ malloc, calloc, realloc, free, aligned_alloc } :: GlobalAllocator;
+
+/**
+ * ArrayList error types
+ */
+ArrayListError :: enum(
+  AllocError(error : AllocError),
+  IndexOutOfBounds(index: usize, length: usize),
+  EmptyList
+);
+
+/**
+ * ArrayList type - a growable array
+ * 
+ * Memory layout:
+ * - ptr: pointer to the heap-allocated buffer
+ * - _length: current number of elements
+ * - _capacity: total capacity of the buffer
+ */
+ArrayList :: (fn(compt(T): Type) -> compt(Type))
+  object(
+    _ptr : ?*(T),
+    _length : usize,
+    _capacity : usize,
+
+    len :: (fn(self: Self) -> usize)({
+      return self._length;
+    }),
+
+    capacity :: (fn(self: Self) -> usize)({
+      return self._capacity;
+    }),
+
+    /**
+     * Get a pointer to the underlying data buffer
+     * Returns .None if the list is empty or has no allocated buffer
+     */
+    ptr :: (fn(self: Self) -> ?*(T))(
+      self._ptr
+    ),
+
+    /**     * Get a slice view of the ArrayList
+     * Returns a fat pointer [T] with data pointer and length
+     * This allows passing ArrayList to functions expecting slices
+     */
+    // as_slice :: (fn(self: Self) -> [T])({
+    //   ptr := match(self._ptr,
+    //     .Some(p) => p,
+    //     .None => (*(T))(*(void)(usize(0)))  // NULL for empty list
+    //   );
+    //   return [T](ptr, self._length);
+    // }),
+
+    /**     * Directly set the length of the ArrayList
+     * UNSAFE: This does not initialize new elements or free removed elements
+     * Only use when you've manually populated the buffer (e.g., via direct memory writes)
+     */
+    set_len :: (fn(self: Self, new_len: usize) -> unit)({
+      cond(
+        (new_len <= self._capacity) => {
+          self._length = new_len;
+        },
+        true => panic("set_len: new length exceeds capacity")
+      );
+    }),
+
+    /**
+     * Create a new empty ArrayList
+     */
+    new :: (fn() -> Self)(
+      Self(
+        _ptr: .None,
+        _length: usize(0),
+        _capacity: usize(0)
+      )),
+
+    /**
+     * Create an ArrayList with a specific initial capacity
+     */
+    with_capacity :: (fn(capacity: usize) -> Self)(
+      cond(
+        (capacity == usize(0)) => 
+          Self.new(),
+        true => {
+          ptr_result := malloc(sizeof(T) * capacity);
+          match(ptr_result,
+            .Some(ptr) =>
+              Self(
+                _ptr: .Some((*(T))(ptr)),
+                _length: usize(0),
+                _capacity: capacity
+              ),
+            .None => panic("malloc returned None")
+          )
+        }
+      )
+    ),
+
+    /**
+     * Add an element to the end of the ArrayList
+     */
+    push :: (fn(self: Self, value: T) -> Result(unit, ArrayListError))(
+      // Check if we need to grow
+      cond(
+        (self._length >= self._capacity) => {
+          // Need to grow - calculate new capacity
+          new_capacity := cond
+            (self._capacity == usize(0)) => usize(4),
+            true => (self._capacity * usize(2));
+          
+          // Allocate or reallocate
+          new_some_ptr := match self._ptr,
+            .None => GlobalAllocator.malloc(sizeof(T) * new_capacity),
+            .Some(old_ptr) => GlobalAllocator.realloc(
+              .Some((*(void))(old_ptr)), 
+              sizeof(T) * new_capacity
+            );
+          
+          match(new_some_ptr,
+            .Some(new_ptr) => {
+              typed_ptr := (*(T))(new_ptr);
+              self._ptr = .Some(typed_ptr);
+              self._capacity = new_capacity;
+              // Now add the element at position length
+              target_ptr := (typed_ptr &+ self._length);
+              consume(target_ptr.* = value);
+              self._length = (self._length + usize(1));
+              .Ok(())
+            },
+            .None => .Err(.AllocError(.OutOfMemory))
+          )
+        },
+        true =>
+          // Have capacity - just add the element
+          match(self._ptr,
+            .Some(ptr) => {
+              target_ptr := (ptr &+ self._length);
+              consume(target_ptr.* = value);
+              self._length = (self._length + usize(1));
+              .Ok(())
+            },
+            .None => panic("ArrayList has capacity but no ptr")
+          )
+      )
+    ),
+
+    /**
+     * Remove and return the last element
+     */
+    pop :: (fn(self: Self) -> Option(T))(
+      cond(
+        (self._length == usize(0)) => .None,
+        true => {
+          self._length = (self._length - usize(1));
+          match(self._ptr,
+            .None => .None,
+            .Some(ptr) => {
+              last_element_ptr := (ptr &+ self._length);
+              last_element := last_element_ptr.*;
+              .Some(last_element)
+            }
+          )
+        }
+      )
+    ),
+
+    /**
+     * Get an element by index (bounds checked)
+     */
+    get :: (fn(self: Self, index: usize) -> Option(T))(
+      cond(
+        (index >= self._length) => .None,
+        true =>
+          match(self._ptr,
+            .None => .None,
+            .Some(ptr) => .Some((ptr &+ index).*)
+          )
+      )
+    ),
+
+    /**
+     * Set an element at a specific index (bounds checked)
+     * Returns Ok(()) on success, or Error with bounds information
+     */
+    set :: (fn(self: Self, index: usize, value: T) -> Result(unit, ArrayListError))(
+      cond(
+        (index >= self._length) => 
+          .Err(.IndexOutOfBounds(index: index, length: self._length)),
+        true =>
+          match(self._ptr,
+            .None => panic("ArrayList has length but no ptr"),
+            .Some(ptr) => {
+              target_ptr := (ptr &+ index);
+              target_ptr.* = value;
+              .Ok(())
+            }
+          )
+      )
+    ),
+
+    /**
+     * Shrink the capacity to match the current length
+     * This reduces memory usage but may cause reallocation on next push
+     */
+    shrink_to_fit :: ((fn(self: Self) -> Result(unit, ArrayListError))
+      // If length equals capacity or both are zero, nothing to do
+      cond(
+        ((self._length == self._capacity) || (self._capacity == usize(0))) => .Ok(()),
+        true =>
+          // If length is zero, free the buffer
+          cond(
+            (self._length == usize(0)) => {
+              match(self._ptr,
+                .Some(ptr) => {
+                  GlobalAllocator.free(.Some(*(void)(ptr)));
+                  self._ptr = .None;
+                  self._capacity = usize(0);
+                },
+                .None => ());
+              .Ok(())
+            },
+            true =>
+              // Otherwise, reallocate to exact size
+              match(self._ptr,
+                .None => panic("ArrayList has capacity but no ptr"),
+                .Some(old_ptr) => {
+                  new_some_ptr := GlobalAllocator.realloc(
+                    .Some(*(void)(old_ptr)),
+                    sizeof(T) * self._length
+                  );
+                  match(new_some_ptr,
+                    .Some(new_ptr) => {
+                      self._ptr = .Some(*(T)(new_ptr));
+                      self._capacity = self._length;
+                      .Ok(())
+                    },
+                    .None => .Err(.AllocError(.OutOfMemory))
+                  )
+                }
+              )
+          )
+      )
+    ),
+
+    _free_elements :: ((fn(self : Self) -> unit)
+      cond(
+        Type.contains_gc_type(T) => {
+          i := usize(0);
+          base_ptr := self._ptr.unwrap();
+          while(i < self._length, i = (i + usize(1)), {
+            element_ptr := (base_ptr &+ i);
+            element := element_ptr.*;
+            // element will be automatically dropped here
+          });
+        },
+        true => ()
+      )
+    ),
+
+    /**
+     * Remove elements from the ArrayList starting at index, removing count elements
+     * Returns the number of elements actually removed
+     */
+    remove :: (fn(self: Self, start: usize, count: usize) -> Result(usize, ArrayListError))(
+      // Check if start index is valid
+      cond(
+        (start >= self._length) => 
+          .Err(.IndexOutOfBounds(index: start, length: self._length)),
+        true => {
+          // Calculate actual number of elements to remove
+          // (can't remove more than what's available)
+          available := (self._length - start);
+          actual_count := cond(
+            (count > available) => available,
+            true => count
+          );
+          
+          // If removing 0 elements, just return success
+          cond(
+            (actual_count == usize(0)) => .Ok(usize(0)),
+            true =>
+              match(self._ptr,
+                .None => panic("ArrayList has length but no ptr"),
+                .Some(ptr) => {
+                  // Free elements that will be removed if they contain ARC types
+                  cond(
+                    Type.contains_gc_type(T) => {
+                      i := usize(0);
+                      while(i < actual_count, i = (i + usize(1)), {
+                        element_ptr := (ptr &+ (start + i));
+                        element := element_ptr.*;
+                        // element will be automatically dropped here
+                      });
+                    },
+                    true => ()
+                  );
+                  
+                  // Shift remaining elements left to fill the gap
+                  // We need to move elements from [start + actual_count, length) to [start, ...)
+                  elements_after := ((self._length - start) - actual_count);
+                  cond(
+                    (elements_after > usize(0)) => {
+                      src_ptr := (ptr &+ (start + actual_count));
+                      dst_ptr := (ptr &+ start);
+                      // Move memory
+                      i := usize(0);
+                      while(i < elements_after, i = (i + usize(1)), {
+                        src := (src_ptr &+ i);
+                        dst := (dst_ptr &+ i);
+                        dst.* = src.*;
+                      });
+                    },
+                    true => ()
+                  );
+                  
+                  // Update length
+                  self._length = (self._length - actual_count);
+                  .Ok(actual_count)
+                }
+              )
+          )
+        }
+      )
+    ),
+
+    /**
+     * Create a new ArrayList containing a slice of elements from start to end (exclusive)
+     * Similar to array slicing in many languages: array[start:end]
+     * Returns a new ArrayList with copied elements
+     */
+    slice :: (fn(self: Self, start: usize, end: usize) -> Result(Self, ArrayListError))(
+      // Validate indices
+      cond(
+        (start > self._length) =>
+          .Err(.IndexOutOfBounds(index: start, length: self._length)),
+        (end > self._length) =>
+          .Err(.IndexOutOfBounds(index: end, length: self._length)),
+        (start > end) =>
+          .Err(.IndexOutOfBounds(index: start, length: end)),
+        true => {
+          slice_length := (end - start);
+          
+          // If slice is empty, return empty ArrayList
+          cond(
+            (slice_length == usize(0)) =>
+              .Ok(Self.new()),
+            true =>
+              match(self._ptr,
+                .None => panic("ArrayList has length but no ptr"),
+                .Some(src_ptr) => {
+                  // Create new ArrayList with exact capacity
+                  new_list := Self.with_capacity(slice_length);
+                  
+                  match(new_list._ptr,
+                    .None => .Err(.AllocError(.OutOfMemory)),
+                    .Some(dst_ptr) => {
+                      // Copy elements
+                      i := usize(0);
+                      while(i < slice_length, i = (i + usize(1)), {
+                        src := (src_ptr &+ (start + i));
+                        dst := (dst_ptr &+ i);
+                        dst.* = src.*;
+                      });
+                      
+                      // Set the length of the new list
+                      new_list._length = slice_length;
+                      .Ok(new_list)
+                    }
+                  )
+                }
+              )
+          )
+        }
+      )
+    ),
+
+    /**
+     * Clear all elements but keep capacity
+     */
+    clear :: (fn(self: Self) -> unit)({
+      self._free_elements();
+      self._length = usize(0);
+    }),
+
+    /**
+     * RAII destructor - automatically called when ArrayList goes out of scope
+     * For `object`, this is called when the reference count drops to zero
+     */
+    dispose :: (fn(self: Self) -> unit)({
+      match(self._ptr,
+        .Some(ptr) => {
+          self._free_elements();
+          self._length = usize(0);
+          GlobalAllocator.free(.Some(*(void)(ptr)));
+          self._ptr = .None;
+        },
+        .None => ()
+      );
+    })
+  );
+
+export
+  ArrayList,
+  ArrayListError
+;