@shd101wyy/yo 0.0.2

package/std/collections/linked_list.yo

@@ -0,0 +1,439 @@
+/**
+ * LinkedList - A doubly-linked list implementation for Yo language
+ * 
+ * Features:
+ * - O(1) push/pop from front and back
+ * - O(1) insertion/removal at known positions (with node reference)
+ * - RAII for automatic cleanup
+ * - True linked list using object indirection
+ * 
+ * Memory layout:
+ * - Each node is an object (reference-counted)
+ * - Nodes contain: value, optional next node, optional prev node
+ */
+
+/**
+ * LinkedList error types
+ */
+LinkedListError :: enum(
+  IndexOutOfBounds(index: usize, length: usize),
+  EmptyList
+);
+
+/**
+ * Node - Internal structure for linked list nodes
+ * Since Node is an object (reference-counted), no Box needed
+ */
+Node :: (fn(compt(T): Type) -> compt(Type))
+  object(
+    value : T,
+    next : Option(Self),
+    prev : Option(Self)
+  )
+;
+
+/**
+ * LinkedList - Doubly-linked list with O(1) operations at both ends
+ */
+LinkedList :: (fn(compt(T): Type) -> compt(Type))
+  object(
+    head : Option(Node(T)),
+    tail : Option(Node(T)),
+    length : usize,
+
+    /**
+     * Create a new empty LinkedList
+     */
+    new :: (fn() -> Self)(
+      Self(
+        head: .None,
+        tail: .None,
+        length: usize(0)
+      )
+    ),
+
+    /**
+     * 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))
+    ),
+
+    /**
+     * 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));
+      }
+    ),
+
+    /**
+     * 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,
+            .None => {
+              self.head = .None;
+              self.tail = .None;
+            },
+            .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,
+        .Some(old_tail) => {
+          value := old_tail.value;
+          new_tail_opt := old_tail.prev;
+          
+          match(new_tail_opt,
+            .None => {
+              self.head = .None;
+              self.tail = .None;
+            },
+            .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 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))(
+      cond(
+        (index >= self.length) => .None,
+        true => {
+          current_opt := self.head;
+          i := usize(0);
+          
+          while(i < index, i = (i + usize(1)), {
+            match(current_opt,
+              .None => {
+                return .None;
+              },
+              .Some(current) => {
+                current_opt = current.next;
+                ()
+              }
+            );
+          });
+          
+          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))(
+      cond(
+        (index > self.length) => .Err(.IndexOutOfBounds(index: index, length: self.length)),
+        (index == usize(0)) => {
+          self.push_front(value);
+          .Ok(())
+        },
+        (index == self.length) => {
+          self.push_back(value);
+          .Ok(())
+        },
+        true => {
+          current_opt := self.head;
+          i := usize(0);
+          
+          while(i < index, i = (i + usize(1)), {
+            match(current_opt,
+              .None => {
+                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)),
+            .Some(current) => {
+              prev_opt := current.prev;
+              
+              new_node := Node(T)(
+                value: value,
+                next: .Some(current),
+                prev: prev_opt
+              );
+              
+              current.prev = .Some(new_node);
+              
+              match(prev_opt,
+                .None => {
+                  self.head = .Some(new_node);
+                },
+                .Some(prev_node) => {
+                  prev_node.next = .Some(new_node);
+                }
+              );
+              
+              self.length = (self.length + usize(1));
+              .Ok(())
+            }
+          )
+        }
+      )
+    ),
+
+    /**
+     * 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 == usize(0)) =>
+          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)
+          ),
+        true => {
+          current_opt := self.head;
+          i := usize(0);
+          
+          while(i < index, i = (i + usize(1)), {
+            match(current_opt,
+              .None => {
+                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)),
+            .Some(node_to_remove) => {
+              value := node_to_remove.value;
+              prev_opt := node_to_remove.prev;
+              next_opt := node_to_remove.next;
+              
+              match(prev_opt,
+                .Some(prev_node) => {
+                  prev_node.next = next_opt;
+                },
+                .None => {
+                  self.head = next_opt;
+                }
+              );
+              
+              match(next_opt,
+                .Some(next_node) => {
+                  next_node.prev = prev_opt;
+                },
+                .None => {
+                  self.tail = prev_opt;
+                }
+              );
+              
+              self.length = (self.length - usize(1));
+              .Ok(value)
+            }
+          )
+        }
+      )
+    ),
+
+    /**
+     * 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
+     */
+    has :: (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;
+      }
+    ),
+
+    /**
+     * RAII destructor - automatically called when LinkedList goes out of scope
+     */
+    dispose :: (fn(self: Self) -> unit)(
+      self.clear()
+    )
+  );
+
+export
+  LinkedList,
+  LinkedListError
+;

package/std/gc.yo

@@ -0,0 +1,10 @@
+extern "Yo",
+  __yo_gc_collect : (fn() -> unit),
+  __yo_gc_tracked_count : (fn() -> u64)
+;
+
+collect :: __yo_gc_collect;
+tracked_count :: __yo_gc_tracked_count;
+
+export collect;
+export tracked_count;

package/std/index.yo

@@ -0,0 +1,12 @@
+// modules
+_allocator :: import "./allocator.yo";
+_monad :: import "./monad.yo";
+_concurrency :: import "./concurrency.yo";
+_time :: import "./time.yo";
+
+export
+  ...(_allocator),
+  ...(_monad),
+  ...(_concurrency),
+  ...(_time)
+;

package/std/io/file.yo

@@ -0,0 +1,191 @@
+{ ArrayList } :: import "../collections/array_list.yo";
+{ String } :: import "../string/string.yo";
+
+// File I/O constants (from fcntl.h)
+extern "C",
+  O_RDONLY : i32,
+  O_WRONLY : i32,
+  O_RDWR : i32,
+  O_CREAT : i32,
+  O_TRUNC : i32,
+  O_APPEND : i32
+;
+
+// Extern type for I/O Future - maps to yo_io_future_t in C
+// This is the concrete type for futures returned by __yo_async_read_start and __yo_async_write_start
+extern "Yo",
+  yo_io_future_t : Type
+;
+
+// I/O Future types - opaque handles to C future structs
+// These are returned by __yo_async_read_start and __yo_async_write_start
+// They are awaitable futures implemented in C
+// Concrete(yo_io_future_t) explicitly sets resolvedConcreteType for codegen
+IOReadFuture :: Impl(Concrete(yo_io_future_t), Future(i32));
+IOWriteFuture :: Impl(Concrete(yo_io_future_t), Future(i32));
+
+// C runtime functions (generated by codegen in runtime.ts)
+extern "Yo",
+  __yo_file_open : (fn(path: *(u8), flags: i32, mode: i32) -> i32),
+  __yo_file_close : (fn(fd: i32) -> unit),
+  __yo_file_size : (fn(fd: i32) -> i64),
+  // Async I/O operations - these return IOReadFuture/IOWriteFuture
+  __yo_async_read_start : (fn(fd: i32, buffer: *(u8), size: u32, offset: u64) -> IOReadFuture),
+  __yo_async_write_start : (fn(fd: i32, buffer: *(u8), size: u32, offset: u64) -> IOWriteFuture)
+;
+
+// I/O Error type
+IOError :: enum(
+  NotFound,
+  PermissionDenied,
+  IsADirectory,
+  NoSpaceLeft,
+  InvalidUtf8,
+  Other(code: i32),
+
+  from_errno :: (fn(errno: i32) -> Self)(
+    cond(
+      (errno == 2) => .NotFound,                // ENOENT
+      (errno == 13) => .PermissionDenied,       // EACCES
+      (errno == 21) => .IsADirectory,           // EISDIR
+      (errno == 28) => .NoSpaceLeft,            // ENOSPC
+      true => .Other(errno)
+    )
+  ),
+
+  to_string :: (fn(self: Self) -> String)({
+    str := match(self,
+      .NotFound => String.from_cstr("File not found").unwrap(),
+      .PermissionDenied => String.from_cstr("Permission denied").unwrap(),
+      .IsADirectory => String.from_cstr("Is a directory").unwrap(),
+      .NoSpaceLeft => String.from_cstr("No space left on device").unwrap(),
+      .InvalidUtf8 => String.from_cstr("Invalid UTF-8 encoding").unwrap(),
+      .Other(code) =>
+        // TODO: Format "I/O error: {code}" once we have string formatting
+        String.from_cstr("I/O error").unwrap()
+    );
+    return str;
+  })
+);
+
+// File handle (reference-counted object)
+File :: object(
+  _fd : i32,
+
+  // Open file (synchronous - fast syscall)
+  open :: (fn(path: *(u8), flags: i32) -> Result(Self, IOError))({
+    fd := __yo_file_open(path, flags, i32(0o644));
+    cond(
+      (fd >= i32(0)) => .Ok(Self(_fd: fd)),
+      true => .Err(IOError.from_errno((i32(0) - fd))) 
+    )
+  }),
+
+  // Get file descriptor (for internal use)
+  fd :: (fn(self: Self) -> i32)(
+    self._fd
+  ),
+
+  // Get file size (synchronous)
+  size :: (fn(self: Self) -> Result(i64, IOError))({
+    result := __yo_file_size(self._fd);
+    cond(
+      (result >= i64(0)) => .Ok(result),
+      true => .Err(IOError.from_errno((i32(0) - (i32(result)))))
+    )
+  }),
+
+  // Close file (synchronous)
+  // Note: Called automatically by drop when File goes out of scope
+  close :: (fn(self: Self) -> unit)({
+    __yo_file_close(self._fd);
+  }),
+
+  // Read entire file asynchronously (returns bytes as ArrayList)
+  read_bytes_async :: (fn(self: Self) -> Impl Future(Result(ArrayList(u8), IOError)))(async {
+    // Get file size first
+    size_result := self.size();
+    size := match(size_result,
+      .Ok(s) => s,
+      .Err(e) => return Result(ArrayList(u8), IOError).Err(e)
+    );
+
+    // Allocate buffer
+    buffer := ArrayList(u8).with_capacity(usize(size));
+    
+    // Get pointer to buffer
+    buffer_ptr := match(buffer.ptr(),
+      .Some(ptr) => ptr,
+      .None => return Result(ArrayList(u8), IOError).Err(.Other(i32(-12)))  // ENOMEM
+    );
+    
+    // Start async read (reads entire file from offset 0)
+    io_future := __yo_async_read_start(self._fd, buffer_ptr, u32(size), u64(0));
+    
+    // Await the I/O completion
+    bytes_read := await io_future;
+    
+    // Check result
+    cond(
+      (bytes_read < i32(0)) => .Err(IOError.from_errno((i32(0) - bytes_read))),
+      true => {
+        // Set the buffer length to bytes actually read
+        buffer.set_len(usize(bytes_read));
+        return .Ok(buffer);
+      }
+    )
+  }),
+
+  // Read entire file as UTF-8 string asynchronously
+  read_string_async :: (fn(self: Self) -> Impl Future(Result(String, IOError)))(async {
+    // Read bytes first
+    bytes_result := await self.read_bytes_async();
+    
+    match(bytes_result,
+      .Ok(bytes) => {
+        // Convert to string - validates UTF-8
+        string_result := String.from_bytes(bytes);
+        .Ok(string_result)
+      },
+      .Err(e) => .Err(e)
+    )
+  }),
+
+  // Write bytes to file asynchronously
+  write_bytes_async :: (fn(self: Self, data: ArrayList(u8)) -> Impl Future(Result(unit, IOError)))(async {
+    // Get pointer to buffer
+    buffer_ptr := match(data.ptr(),
+      .Some(ptr) => ptr,
+      .None => return Result(unit, IOError).Err(.Other(i32(-22)))  // EINVAL - empty buffer
+    );
+    
+    // Start async write (writes to offset 0)
+    io_future := __yo_async_write_start(self._fd, buffer_ptr, u32(data.len()), u64(0));
+    
+    // Await the I/O completion
+    bytes_written := await io_future;
+    
+    // Check result
+    cond(
+      (bytes_written < i32(0)) => .Err(IOError.from_errno((i32(0) - bytes_written))),
+      (bytes_written != i32(data.len())) => .Err(.Other(i32(-5))),  // EIO
+      true => .Ok(())
+    )
+  }),
+
+  // Write string to file asynchronously
+  write_string_async :: (fn(self: Self, s: String) -> Impl Future(Result(unit, IOError)))(async {
+    // Convert string to bytes
+    bytes := s.as_bytes();
+    
+    // Write bytes
+    result := await self.write_bytes_async(bytes);
+    return result;
+  })
+);
+
+export 
+  IOError,
+  File,
+  O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_APPEND
+;

package/std/io/index.yo

@@ -0,0 +1,5 @@
+_file :: import "./file.yo";
+
+export
+  ...(_file)
+;

package/std/libc/assert.yo

@@ -0,0 +1,39 @@
+// C11 assert.h - Assertion debugging facility
+// Provides runtime assertion checking for debugging
+
+c_include "<assert.h>",
+  // The actual assertion function called by the assert macro
+  // This is typically called __assert_fail or similar in libc implementations
+  __assert_fail :
+    fn(assertion : *(char), file : *(char), line : uint, function : *(char)) -> unit,
+  
+  // Alternative assertion function (some implementations)
+  __assert :
+    fn(assertion : *(char), file : *(char), line : int) -> unit,
+
+  // C11 static_assert is handled by the compiler, not runtime
+  // But some implementations provide a function version for diagnostics
+  _Static_assert_fail :
+    fn(message : *(char)) -> unit
+;
+
+// Note: In C, assert is typically implemented as a macro:
+// #ifdef NDEBUG
+// #define assert(expr) ((void)0)
+// #else
+// #define assert(expr) \
+//   ((expr) ? (void)0 : __assert_fail(#expr, __FILE__, __LINE__, __func__))
+// #endif
+//
+// Since Yo doesn't have preprocessor macros, users would need to:
+// 1. Call __assert_fail directly when assertions fail
+// 2. Use conditional compilation at the language level
+// 3. Or implement assertion logic in their application code
+
+// Export assert functionality
+export 
+  // Low-level assertion functions from C runtime
+  __assert_fail,
+  __assert,
+  _Static_assert_fail
+;