@shd101wyy/yo 0.0.2

package/std/string/index.yo

@@ -0,0 +1,8 @@
+// other data types
+_rune :: import "./rune.yo";
+_string :: import "./string.yo";
+
+export
+  ...(_rune),
+  ...(_string)
+;

package/std/string/rune.yo

@@ -0,0 +1,82 @@
+rune :: newtype(
+  c : u32,
+
+  from_u32 :: ((fn(value: u32) -> Option(Self))
+    cond(
+      ((value <= u32(0x10FFFF)) && (((value < 0xD800) || (value > 0xDFFF)))) => .Some(Self(c: value)),
+      true => .None
+    )
+  ),
+
+  to_u32 :: ((fn(self: Self) -> u32)
+    self.c
+  ),
+
+  is_ascii :: ((fn(self: Self) -> bool)
+    (self.c <= 0x7F)
+  ),
+
+  is_whitespace :: ((fn(self: Self) -> bool)
+    (((self.c == 0x20) || (self.c == 0x09)) || ((self.c == 0x0A) || (self.c == 0x0D)))
+  ),
+
+  is_digit :: ((fn(self: Self) -> bool)
+    ((self.c >= 0x30) && (self.c <= 0x39))
+  ),
+
+  is_alphabetic :: ((fn(self: Self) -> bool)
+    (((self.c >= 0x41) && (self.c <= 0x5A)) || ((self.c >= 0x61) && (self.c <= 0x7A)))
+  ),
+
+  is_uppercase :: ((fn(self: Self) -> bool)
+    ((self.c >= 0x41) && (self.c <= 0x5A))
+  ),
+
+  is_lowercase :: ((fn(self: Self) -> bool)
+    ((self.c >= 0x61) && (self.c <= 0x7A))
+  ),
+
+  to_lowercase :: ((fn(self: Self) -> Self)
+    cond(
+      self.is_uppercase() => Self(c: (self.c + 32)),
+      true => self
+    )
+  ),
+
+  to_uppercase :: ((fn(self: Self) -> Self)
+    cond(
+      self.is_lowercase() => Self(c: (self.c - 32)),
+      true => self
+    )
+  ),
+
+  // Some constants
+  NUL        :: Self(c: 0x00),
+  TAB        :: Self(c: 0x09),
+  NEWLINE    :: Self(c: 0x0A),
+  SPACE      :: Self(c: 0x20),
+  ZERO       :: Self(c: 0x30),
+  NINE       :: Self(c: 0x39),
+  UPPERCASE_A :: Self(c: 0x41),
+  UPPERCASE_Z :: Self(c: 0x5A),
+  LOWERCASE_A :: Self(c: 0x61),
+  LOWERCASE_Z :: Self(c: 0x7A)
+);
+
+impl(rune, Eq(rune)(
+  (==) : ((a, b) -> (a.c == b.c)),
+  (!=) : ((a, b) -> (a.c != b.c))
+));
+
+impl(rune, Ord(rune)(
+  (<) : ((a, b) -> (a.c < b.c)),
+  (<=) : ((a, b) -> (a.c <= b.c)),
+  (>) : ((a, b) -> (a.c > b.c)),
+  (>=) : ((a, b) -> (a.c >= b.c))
+));
+
+impl(rune, Send());
+
+export
+  rune
+;

package/std/string/string.yo

@@ -0,0 +1,288 @@
+{ ArrayList } :: import "../collections/array_list.yo";
+{ rune } :: import "./rune.yo";
+
+StringError :: enum(
+  InvalidUtf8,
+  IndexOutOfBounds(index: usize, length: usize)
+);
+
+/**
+ * String - Immutable UTF-8 encoded string
+ * 
+ * Similar to JavaScript String, Python str, and Rust String.
+ * Strings are immutable - all operations return new strings.
+ * 
+ * Internal storage uses ArrayList(u8) for UTF-8 bytes.
+ */
+String :: object(
+  _bytes: ArrayList(u8),
+
+  /**
+   * Create a new empty string
+   */
+  new :: (fn() -> Self)(
+    Self(_bytes: ArrayList(u8).new())
+  ),
+
+  /**
+   * Create a string from raw bytes (assumes valid UTF-8)
+   * No validation is performed - the caller must ensure bytes are valid UTF-8
+   */
+  from_bytes :: (fn(bytes: ArrayList(u8)) -> Self)(
+    Self(_bytes: bytes)
+  ),
+
+  /**
+   * Create a string from a slice of bytes [u8]
+   * The slice is a fat pointer containing data pointer and length
+   * Example: String.from(slice) where slice is [u8]
+   */
+  from :: (fn(slice: [u8]) -> Self)({
+    // Create a new ArrayList and copy bytes from the slice
+    bytes := ArrayList(u8).with_capacity(slice.len());
+    
+    i := usize(0);
+    while ((i < slice.len())),
+          (i = (i + usize(1))),
+    {
+      byte := slice(i);
+      bytes.push(byte);
+    };
+    
+    return Self(_bytes: bytes);
+  }),
+
+  /**
+   * Create a string from a C null-terminated string *(u8)
+   * Copies bytes until it finds a null byte (0)
+   * Example: String.from_cstr(c_string_ptr)
+   * 
+   * Note: We manually search for the null terminator by iterating
+   */
+  from_cstr :: (fn(cstr: *(u8)) -> Result(Self, StringError))({
+    // Create a new ArrayList to store the bytes
+    bytes := ArrayList(u8).new();
+    
+    // Iterate through the C string until we find the null terminator
+    i := usize(0);
+    // FIXME: This is causing infinite loop during compile-time evaluation.
+    //        We need to check if the loop body has runtime expr, then we shouldn't consider it as infinite loop.
+    while {f := true; f}, (i = (i + usize(1))), {
+      // Access byte at index i using pointer arithmetic/
+      byte_ptr := (cstr &+ i);
+      byte := byte_ptr.*;
+      
+      // Stop when we find the null terminator
+      cond(
+        (byte == u8(0)) => break,
+        true => bytes.push(byte)
+      );
+    };
+      
+    return .Ok(Self(_bytes: bytes));
+  }),
+
+  /**
+   * Get the length of the string in Unicode characters (runes)
+   * For "你好世界", this returns 4
+   */
+  len :: (fn(self: Self) -> usize)({
+    count := usize(0);
+    byte_index := usize(0);
+    total_bytes := self._bytes.len();
+    
+    while ((byte_index < total_bytes)),
+          (byte_index = (byte_index + usize(1))),
+    {
+      byte_opt := self._bytes.get(byte_index);
+      match(byte_opt,
+        .Some(byte) => {
+          // Count UTF-8 character start bytes (not continuation bytes)
+          // Continuation bytes have pattern 10xxxxxx (0x80-0xBF)
+          cond(
+            ((byte < u8(0x80)) || (byte >= u8(0xC0))) => {
+              count = (count + usize(1));
+            },
+            true => ()
+          );
+        },
+        .None => ()
+      );
+    };
+    
+    return count;
+  }),
+
+  /**
+   * Check if the string is empty
+   */
+  is_empty :: ((fn(self: Self) -> bool)
+    (self._bytes.len() == usize(0))
+  ),
+
+  /**
+   * Get a reference to the internal byte array
+   */
+  as_bytes :: (fn(self: Self) -> ArrayList(u8))(
+    self._bytes
+  ),
+  // as_bytes :: (fn(self: Self) -> ArrayList(u8))({
+  //   return self._bytes;
+  // }),
+
+  /**
+   * Decode a UTF-8 encoded rune starting at the given byte index
+   * Internal helper method
+   */
+  _decode_rune_at :: (fn(self: Self, byte_index: usize) -> Option(rune))({
+    first_byte_opt := self._bytes.get(byte_index);
+    match(first_byte_opt,
+      .Some(first_byte) => {
+        // Determine how many bytes this UTF-8 character uses
+        (res : Option(rune)) = cond(
+          // 1-byte character: 0xxxxxxx (ASCII)
+          (first_byte < u8(0x80)) => {
+            codepoint := u32(first_byte);
+            rune.from_u32(codepoint)
+          },
+          // 2-byte character: 110xxxxx 10xxxxxx
+          ((first_byte >= u8(0xC0)) && (first_byte < u8(0xE0))) => {
+            second_opt := self._bytes.get((byte_index + usize(1)));
+            match(second_opt,
+              .Some(second) => {
+                codepoint := (((u32(first_byte) & u32(0x1F)) << u32(6)) | (u32(second) & u32(0x3F)));
+                rune.from_u32(codepoint)
+              },
+              .None => .None
+            )
+          },
+          // 3-byte character: 1110xxxx 10xxxxxx 10xxxxxx
+          ((first_byte >= u8(0xE0)) && (first_byte < u8(0xF0))) => {
+            second_opt := self._bytes.get((byte_index + usize(1)));
+            third_opt := self._bytes.get((byte_index + usize(2)));
+            match(second_opt,
+              .Some(second) =>
+                match(third_opt,
+                  .Some(third) => {
+                    codepoint := ((((u32(first_byte) & u32(0x0F)) << u32(12)) | ((u32(second) & u32(0x3F)) << u32(6))) | (u32(third) & u32(0x3F)));
+                    rune.from_u32(codepoint)
+                  },
+                  .None => .None
+                ),
+              .None => .None
+            )
+          },
+          // 4-byte character: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+          ((first_byte >= u8(0xF0)) && (first_byte < u8(0xF8))) => {
+            second_opt := self._bytes.get((byte_index + usize(1)));
+            third_opt := self._bytes.get((byte_index + usize(2)));
+            fourth_opt := self._bytes.get((byte_index + usize(3)));
+            match(second_opt,
+              .Some(second) =>
+                match(third_opt,
+                  .Some(third) =>
+                    match(fourth_opt,
+                      .Some(fourth) => {
+                        codepoint := (((((u32(first_byte) & u32(0x07)) << u32(18)) | ((u32(second) & u32(0x3F)) << u32(12))) | ((u32(third) & u32(0x3F)) << u32(6))) | (u32(fourth) & u32(0x3F)));
+                        rune.from_u32(codepoint)
+                      },
+                      .None => .None
+                    ),
+                  .None => .None
+                ),
+              .None => .None
+            )
+          },
+          // Invalid UTF-8 start byte
+          true => .None
+        );
+        return res;
+      },
+      .None => .None
+    )
+  }),
+
+  /**
+   * Get the rune at the specified character index (0-based)
+   * Returns None if index is out of bounds
+   * For "你好世界", at(0) returns '你', at(1) returns '好', etc.
+   */
+  at :: (fn(self: Self, index: usize) -> Option(rune))({
+    char_count := usize(0);
+    byte_index := usize(0);
+    total_bytes := self._bytes.len();
+    
+    // Find the byte position of the character at the given index
+    while ((byte_index < total_bytes)),
+          (byte_index = (byte_index + usize(1))),
+    {
+      byte_opt := self._bytes.get(byte_index);
+      match(byte_opt,
+        .Some(byte) => {
+          // Check if this is a UTF-8 character start byte
+          is_start := ((byte < u8(0x80)) || (byte >= u8(0xC0)));
+          cond(
+            is_start => {
+              // Found a character start byte
+              cond(
+                (char_count == index) => {
+                  // This is the character we want, decode it
+                  return self._decode_rune_at(byte_index);
+                },
+                true => {
+                  // Not the right character yet, keep counting
+                  char_count = (char_count + usize(1));
+                }
+              );
+            },
+            true => ()
+          );
+        },
+        .None => ()
+      );
+    };
+    
+    // Index out of bounds
+    return .None;
+  }),
+
+  /**
+   * Concatenate two strings (like JavaScript +)
+   */
+  concat :: (fn(self: Self, other: Self) -> Self)({
+    self_len := self._bytes.len();
+    other_len := other._bytes.len();
+    new_bytes := ArrayList(u8).with_capacity((self_len + other_len));
+    
+    // Copy bytes from self
+    i := usize(0);
+    while ((i < self_len)),
+          (i = (i + usize(1))),
+    {
+      byte_opt := self._bytes.get(i);
+      match(byte_opt,
+        .Some(byte) => { new_bytes.push(byte); },
+        .None => { panic("String.concat: failed to get byte from self"); }
+      );
+    };
+    
+    // Copy bytes from other
+    j := usize(0);
+    while ((j < other_len)),
+          (j = (j + usize(1))),
+    {
+      byte_opt := other._bytes.get(j);
+      match(byte_opt,
+        .Some(byte) => { new_bytes.push(byte); },
+        .None => { panic("String.concat: failed to get byte from other"); }
+      );
+    };
+    
+    return Self(_bytes: new_bytes);
+  })
+);
+
+export
+  String,
+  StringError
+;

package/std/sync.yo

@@ -0,0 +1,95 @@
+extern "Yo",
+  YO_THREAD_SYNC_TYPE : Type,
+  YO_COND_TYPE : Type,
+  yo_mutex_create : (fn() -> YO_THREAD_SYNC_TYPE),
+  yo_cond_create : (fn() -> YO_COND_TYPE),
+  yo_mutex_lock : (fn(mutex : *(YO_THREAD_SYNC_TYPE)) -> unit),
+  yo_mutex_unlock : (fn(mutex : *(YO_THREAD_SYNC_TYPE)) -> unit),
+  yo_mutex_destroy : (fn(mutex : *(YO_THREAD_SYNC_TYPE)) -> unit),
+  yo_cond_wait : (fn(cv : *(YO_COND_TYPE), mutex : *(YO_THREAD_SYNC_TYPE)) -> unit),
+  yo_cond_signal : (fn(cv : *(YO_COND_TYPE)) -> unit),
+  yo_cond_broadcast : (fn(cv : *(YO_COND_TYPE)) -> unit),
+  yo_cond_destroy : (fn(cv : *(YO_COND_TYPE)) -> unit)
+;
+
+mutex_t :: newtype(
+  mutex : YO_THREAD_SYNC_TYPE,
+
+  new :: ((fn() -> Self) {
+    return Self(yo_mutex_create());
+  }),
+  lock :: ((fn(self : *(Self))-> unit) {
+    return yo_mutex_lock(&(self.mutex));
+  }),
+  unlock :: ((fn(self : *(Self)) -> unit) {
+    return yo_mutex_unlock(&(self.mutex));
+  }),
+  destroy :: ((fn(self : *(Self)) -> unit) {
+    return yo_mutex_destroy(&(self.mutex));
+  })
+);
+
+// GC managed
+Mutex :: object(
+  mutex : YO_THREAD_SYNC_TYPE,
+
+  new :: ((fn() -> Self) {
+    return Self(yo_mutex_create());
+  }),
+  lock :: ((fn(self : Self)-> unit) {
+    return yo_mutex_lock(&(self.mutex));
+  }),
+  unlock :: ((fn(self : Self) -> unit) {
+    return yo_mutex_unlock(&(self.mutex));
+  }),
+  dispose :: ((fn(self : Self) -> unit) {
+    return yo_mutex_destroy(&(self.mutex));
+  })
+);
+
+cond_t :: newtype(
+  cv : YO_COND_TYPE,
+
+  new :: ((fn() -> Self) {
+    return Self(yo_cond_create());
+  }),
+  wait :: ((fn(self : *(Self), mutex : *(mutex_t)) -> unit) {
+    return yo_cond_wait(&(self.cv), &(mutex.mutex));
+  }),
+  signal :: ((fn(self : *(Self)) -> unit) {
+    return yo_cond_signal(&(self.cv));
+  }),
+  broadcast :: ((fn(self : *(Self)) -> unit) {
+    return yo_cond_broadcast(&(self.cv));
+  }),
+  destroy :: ((fn(self : *(Self)) -> unit) {
+    return yo_cond_destroy(&(self.cv));
+  })
+);
+
+Cond :: object(
+  cv : YO_COND_TYPE,
+
+  new :: ((fn() -> Self) {
+    return Self(yo_cond_create());
+  }),
+  wait :: ((fn(self : Self, mutex : Mutex) -> unit) {
+    return yo_cond_wait(&(self.cv), &(mutex.mutex));
+  }),
+  signal :: ((fn(self : Self) -> unit) {
+    return yo_cond_signal(&(self.cv));
+  }),
+  broadcast :: ((fn(self : Self) -> unit) {
+    return yo_cond_broadcast(&(self.cv));
+  }),
+  dispose :: ((fn(self : Self) -> unit) {
+    return yo_cond_destroy(&(self.cv));
+  })
+);
+
+export
+  mutex_t,
+  Mutex,
+  cond_t,
+  Cond
+;

package/std/thread.yo

@@ -0,0 +1,36 @@
+extern "Yo",
+  // Thread utilities
+  __yo_thread_get_hardware_threads: (fn() -> usize),
+  __yo_get_thread_id : (fn() -> usize),
+  __yo_get_cpu_id : (fn() -> i32)
+;
+
+// Low-level runtime types and functions for Thread
+extern "Yo",
+  __yo_thread_t : Type,
+  __yo_thread_spawn : (fn(cb : Impl(Fn() -> unit, Send)) -> __yo_thread_t),
+  __yo_thread_join : (fn(t : __yo_thread_t) -> unit)
+;
+
+// High-level Thread wrapper - a simple struct (stack allocated)
+Thread :: struct(
+  handle : __yo_thread_t,
+  
+  // Spawn a new OS thread running the given closure
+  spawn :: (fn(cb : Impl(Fn() -> unit, Send)) -> Self)({
+    raw := __yo_thread_spawn(cb);
+    Self(raw)
+  }),
+  
+  // Wait for the thread to complete (blocking)
+  join :: (fn(self : *(Self)) -> unit)(
+    __yo_thread_join(self.handle)
+  )
+);
+
+export
+  get_hardware_threads : __yo_thread_get_hardware_threads,
+  get_thread_id : __yo_get_thread_id,
+  get_cpu_id : __yo_get_cpu_id,
+  Thread
+;

package/std/time.yo

@@ -0,0 +1,13 @@
+extern "Yo",
+  __yo_ms_sleep: (fn(ms: usize) -> unit)
+;
+
+Time :: impl {
+  sleep :: __yo_ms_sleep;
+
+  export sleep;
+};
+
+export
+  Time
+;

package/std/worker.yo

@@ -0,0 +1,36 @@
+// Worker - Thread Pool with Thread Affinity
+// ==========================================
+// Worker spawns tasks on a thread pool. Each task has thread affinity:
+// tasks are distributed round-robin to worker threads and stay on their
+// assigned thread (no work stealing).
+//
+// Thread-per-core: By default, one worker thread per CPU core.
+// Thread affinity: Each task runs on a specific worker thread.
+// Thread-local GC: Each worker thread has its own GC heap.
+
+extern "Yo",
+  __yo_worker_spawn : (fn(cb : Impl(Fn() -> unit, Send)) -> unit),
+  __yo_worker_get_num_threads : (fn() -> usize),
+  __yo_worker_set_num_threads : (fn(num: usize) -> unit)
+;
+
+// Spawn a task on the thread pool.
+// Returns immediately, task runs in background.
+// Tasks are distributed round-robin to worker threads.
+spawn :: (fn(cb : Impl(Fn() -> unit, Send)) -> unit)({
+  __yo_worker_spawn(cb);
+});
+
+// Get number of threads in pool.
+// Default: number of hardware threads (CPU cores).
+get_num_threads :: (fn() -> usize)(
+  __yo_worker_get_num_threads()
+);
+
+// Configure thread pool size.
+// Must be called before first spawn to take effect.
+set_num_threads :: (fn(num: usize) -> unit)(
+  __yo_worker_set_num_threads(num)
+);
+
+export spawn, get_num_threads, set_num_threads;

package/vendor/mimalloc/.gitattributes

@@ -0,0 +1,12 @@
+# default behavior is to always use unix style line endings
+* text eol=lf
+*.png binary
+*.pdn binary
+*.jpg binary
+*.sln binary
+*.suo binary
+*.vcproj binary
+*.patch binary
+*.dll binary
+*.lib binary
+*.exe binary