@shd101wyy/yo 0.1.26 → 0.1.27

package/std/sync/channel.yo

@@ -18,60 +18,63 @@
 //! assert((val.unwrap() == i32(42)), "received value");
 //! t.join();
 //! ```
-
-{ GlobalAllocator } :: import "../allocator";
+{ GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
-{ Mutex } :: import "./mutex";
-{ Cond } :: import "./cond";
-
+{ Mutex } :: import("./mutex");
+{ Cond } :: import("./cond");
 /// Thread-safe bounded channel for passing values between threads.
 /// Uses atomic reference counting — implements `Send` and can be
 /// safely shared across threads without `Arc` wrapping.
 /// T must implement `Send` to ensure values are safe to transfer between threads.
-Channel :: (fn(comptime(T) : Type, where(T <: Send)) -> comptime(Type))
-  atomic object(
-    _data      : *(T),
-    _head      : usize,
-    _len       : usize,
-    _capacity  : usize,
-    _mutex     : Mutex,
-    _not_empty : Cond,
-    _not_full  : Cond,
-    _closed    : bool
+Channel :: (fn(comptime(T) : Type, where(T <: Send)) -> comptime(Type))(
+  atomic(
+    object(
+      _data : *(T),
+      _head : usize,
+      _len : usize,
+      _capacity : usize,
+      _mutex : Mutex,
+      _not_empty : Cond,
+      _not_full : Cond,
+      _closed : bool
+    )
   )
-;
-
-impl(forall(T : Type), Channel(T), where(T <: Send),
+);
+impl(
+  forall(T : Type),
+  Channel(T),
+  where(T <: Send),
   /// Create a bounded channel with the given capacity.
   /// Capacity must be > 0.
-  new : (fn(capacity: usize) -> Self)({
-    assert((capacity > usize(0)), "Channel.new: capacity must be > 0");
-    (ptr : *(T)) = *(T)(malloc((capacity * sizeof(T))).unwrap());
-    return Self(
-      _data: ptr,
-      _head: usize(0),
-      _len: usize(0),
-      _capacity: capacity,
-      _mutex: Mutex.new(),
-      _not_empty: Cond.new(),
-      _not_full: Cond.new(),
-      _closed: false
+  new : (fn(capacity : usize) -> Self)({
+    assert(capacity > usize(0), "Channel.new: capacity must be > 0");
+    (ptr : *(T)) = *(T)(malloc(capacity * sizeof(T)).unwrap());
+    return(
+      Self(
+        _data : ptr,
+        _head : usize(0),
+        _len : usize(0),
+        _capacity : capacity,
+        _mutex : Mutex.new(),
+        _not_empty : Cond.new(),
+        _not_full : Cond.new(),
+        _closed : false
+      )
     );
   }),
-
   /// Send a value into the channel.
   /// Blocks if the channel is full until space becomes available.
   /// Returns .Ok(()) on success, .Err(()) if the channel is closed.
-  send : (fn(self: Self, value: T) -> Result(unit, unit))({
+  send : (fn(self : Self, value : T) -> Result(unit, unit))({
     self._mutex.lock();
     // Wait while buffer is full and channel is not closed
-    while runtime(((self._len >= self._capacity) && (!(self._closed)))), {
+    while(runtime((self._len >= self._capacity) && (!(self._closed))), {
       self._not_full.wait(self._mutex);
-    };
+    });
     cond(
       self._closed => {
         self._mutex.unlock();
-        return .Err(());
+        return(.Err(()));
       },
       true => ()
     );
@@ -81,22 +84,21 @@ impl(forall(T : Type), Channel(T), where(T <: Send),
     self._len = (self._len + usize(1));
     self._not_empty.signal();
     self._mutex.unlock();
-    return .Ok(());
+    return(.Ok(()));
   }),
-
   /// Receive a value from the channel.
   /// Blocks if the channel is empty until a value is available.
   /// Returns .Some(value) on success, .None if the channel is closed and empty.
-  recv : (fn(self: Self) -> ?T)({
+  recv : (fn(self : Self) -> ?(T))({
     self._mutex.lock();
     // Wait while buffer is empty and channel is not closed
-    while runtime(((self._len == usize(0)) && (!(self._closed)))), {
+    while(runtime((self._len == usize(0)) && (!(self._closed))), {
       self._not_empty.wait(self._mutex);
-    };
+    });
     cond(
       (self._len == usize(0)) => {
         self._mutex.unlock();
-        return .None;
+        return(.None);
       },
       true => ()
     );
@@ -108,17 +110,16 @@ impl(forall(T : Type), Channel(T), where(T <: Send),
     self._len = (self._len - usize(1));
     self._not_full.signal();
     self._mutex.unlock();
-    return .Some(val);
+    return(.Some(val));
   }),
-
   /// Try to send a value without blocking.
   /// Returns .Ok(()) if sent, .Err(()) if full or closed.
-  try_send : (fn(self: Self, value: T) -> Result(unit, unit))({
+  try_send : (fn(self : Self, value : T) -> Result(unit, unit))({
     self._mutex.lock();
     cond(
       (self._closed || (self._len >= self._capacity)) => {
         self._mutex.unlock();
-        return .Err(());
+        return(.Err(()));
       },
       true => ()
     );
@@ -127,17 +128,16 @@ impl(forall(T : Type), Channel(T), where(T <: Send),
     self._len = (self._len + usize(1));
     self._not_empty.signal();
     self._mutex.unlock();
-    return .Ok(());
+    return(.Ok(()));
   }),
-
   /// Try to receive a value without blocking.
   /// Returns .Some(value) if available, .None if empty.
-  try_recv : (fn(self: Self) -> ?T)({
+  try_recv : (fn(self : Self) -> ?(T))({
     self._mutex.lock();
     cond(
       (self._len == usize(0)) => {
         self._mutex.unlock();
-        return .None;
+        return(.None);
       },
       true => ()
     );
@@ -148,47 +148,46 @@ impl(forall(T : Type), Channel(T), where(T <: Send),
     self._len = (self._len - usize(1));
     self._not_full.signal();
     self._mutex.unlock();
-    return .Some(val);
+    return(.Some(val));
   }),
-
   /// Close the channel. No more values can be sent.
   /// Pending recv() calls will return .None once the buffer is drained.
   /// Pending send() calls will return .Err(()).
-  close : (fn(self: Self) -> unit)({
+  close : (fn(self : Self) -> unit)({
     self._mutex.lock();
     self._closed = true;
     self._not_empty.broadcast();
     self._not_full.broadcast();
     self._mutex.unlock();
   }),
-
   /// Check if the channel is closed.
-  is_closed : (fn(self: Self) -> bool)(
+  is_closed : (fn(self : Self) -> bool)(
     self._closed
   ),
-
   /// Return the number of values currently buffered.
-  len : (fn(self: Self) -> usize)(
+  len : (fn(self : Self) -> usize)(
     self._len
   ),
-
   /// Check if the channel buffer is empty.
-  is_empty : (fn(self: Self) -> bool)(
-    (self._len == usize(0))
+  is_empty : (fn(self : Self) -> bool)(
+    self._len == usize(0)
   )
 );
-
 // Dispose: drop remaining elements and free the buffer
-impl(forall(T : Type), Channel(T), where(T <: Send), Dispose(
-  dispose : (fn(self: Self) -> unit)({
-    (i : usize) = usize(0);
-    while runtime((i < self._len)), {
-      (idx : usize) = ((self._head + i) % self._capacity);
-      unsafe.drop((self._data &+ idx).*);
-      i = (i + usize(1));
-    };
-    free(.Some(*(void)(self._data)));
-  })
-));
-
-export Channel;
+impl(
+  forall(T : Type),
+  Channel(T),
+  where(T <: Send),
+  Dispose(
+    dispose : (fn(self : Self) -> unit)({
+      (i : usize) = usize(0);
+      while(runtime(i < self._len), {
+        (idx : usize) = ((self._head + i) % self._capacity);
+        unsafe.drop((self._data &+ idx).*);
+        i = (i + usize(1));
+      });
+      free(.Some(*(void)(self._data)));
+    })
+  )
+);
+export(Channel);

package/std/sync/cond.yo

@@ -1,74 +1,69 @@
 //! Condition variable for thread synchronization.
-
-{ __YO_THREAD_SYNC_TYPE, mutex_t, Mutex } :: import "./mutex";
-
-extern "Yo",
+{ __YO_THREAD_SYNC_TYPE, mutex_t, Mutex } :: import("./mutex");
+extern(
+  "Yo",
   __YO_COND_TYPE : Type,
   __yo_cond_create : (fn() -> __YO_COND_TYPE),
   __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)
-;
-
+);
 impl(__YO_COND_TYPE, Send());
 impl(__YO_COND_TYPE, Acyclic());
-
 /// Low-level condition variable (manual lifetime via `destroy`).
 cond_t :: newtype(
   cv : __YO_COND_TYPE
 );
-impl(cond_t,
+impl(
+  cond_t,
   new : (fn() -> Self)({
-    return Self(__yo_cond_create());
+    return(Self(__yo_cond_create()));
   }),
-
   wait : (fn(self : *(Self), mutex : *(mutex_t)) -> unit)({
-    return __yo_cond_wait(&(self.cv), &(mutex.mutex));
+    return(__yo_cond_wait(&(self.cv), &(mutex.mutex)));
   }),
-
   signal : (fn(self : *(Self)) -> unit)({
-    return __yo_cond_signal(&(self.cv));
+    return(__yo_cond_signal(&(self.cv)));
   }),
-
   broadcast : (fn(self : *(Self)) -> unit)({
-    return __yo_cond_broadcast(&(self.cv));
+    return(__yo_cond_broadcast(&(self.cv)));
   }),
-
   destroy : (fn(self : *(Self)) -> unit)({
-    return __yo_cond_destroy(&(self.cv));
+    return(__yo_cond_destroy(&(self.cv)));
   })
 );
-
 /// Reference-counted condition variable with automatic cleanup via `Dispose`.
 /// Uses atomic reference counting for safe cross-thread sharing.
-Cond :: atomic object(
-  cv : __YO_COND_TYPE
+Cond :: atomic(
+  object(
+    cv : __YO_COND_TYPE
+  )
 );
-impl(Cond,
+impl(
+  Cond,
   new : (fn() -> Self)({
-    return Self(__yo_cond_create());
+    return(Self(__yo_cond_create()));
   }),
-
   wait : (fn(self : Self, mutex : Mutex) -> unit)({
-    return __yo_cond_wait(&(self.cv), &(mutex.mutex));
+    return(__yo_cond_wait(&(self.cv), &(mutex.mutex)));
   }),
-
   signal : (fn(self : Self) -> unit)({
-    return __yo_cond_signal(&(self.cv));
+    return(__yo_cond_signal(&(self.cv)));
   }),
-
   broadcast : (fn(self : Self) -> unit)({
-    return __yo_cond_broadcast(&(self.cv));
+    return(__yo_cond_broadcast(&(self.cv)));
   })
 );
-impl(Cond, Dispose(
-  dispose : (fn(self : Self) -> unit)({
-    return __yo_cond_destroy(&(self.cv));
-  })
-));
-
-export
+impl(
+  Cond,
+  Dispose(
+    dispose : (fn(self : Self) -> unit)({
+      return(__yo_cond_destroy(&(self.cv)));
+    })
+  )
+);
+export(
   cond_t,
   Cond
-;
+);

package/std/sync/mutex.yo

@@ -1,64 +1,62 @@
 //! Mutual exclusion lock primitives.
-
-extern "Yo",
+extern(
+  "Yo",
   __YO_THREAD_SYNC_TYPE : Type,
   __yo_mutex_create : (fn() -> __YO_THREAD_SYNC_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)
-;
-
+);
 impl(__YO_THREAD_SYNC_TYPE, Send());
 impl(__YO_THREAD_SYNC_TYPE, Acyclic());
-
 /// Low-level mutex (manual lifetime via `destroy`).
 mutex_t :: newtype(
   mutex : __YO_THREAD_SYNC_TYPE
 );
-impl(mutex_t,
+impl(
+  mutex_t,
   new : (fn() -> Self)({
-    return Self(__yo_mutex_create());
+    return(Self(__yo_mutex_create()));
   }),
-
-  lock : (fn(self : *(Self))-> unit)({
-    return __yo_mutex_lock(&(self.mutex));
+  lock : (fn(self : *(Self)) -> unit)({
+    return(__yo_mutex_lock(&(self.mutex)));
   }),
-
   unlock : (fn(self : *(Self)) -> unit)({
-    return __yo_mutex_unlock(&(self.mutex));
+    return(__yo_mutex_unlock(&(self.mutex)));
   }),
-
   destroy : (fn(self : *(Self)) -> unit)({
-    return __yo_mutex_destroy(&(self.mutex));
+    return(__yo_mutex_destroy(&(self.mutex)));
   })
 );
-
 /// Reference-counted mutex with automatic cleanup via `Dispose`.
 /// Uses atomic reference counting for safe cross-thread sharing.
-Mutex :: atomic object(
-  mutex : __YO_THREAD_SYNC_TYPE
+Mutex :: atomic(
+  object(
+    mutex : __YO_THREAD_SYNC_TYPE
+  )
 );
-impl(Mutex,
+impl(
+  Mutex,
   new : (fn() -> Self)({
-    return Self(__yo_mutex_create());
+    return(Self(__yo_mutex_create()));
   }),
-
-  lock : (fn(self : Self)-> unit)({
-    return __yo_mutex_lock(&(self.mutex));
+  lock : (fn(self : Self) -> unit)({
+    return(__yo_mutex_lock(&(self.mutex)));
   }),
-
   unlock : (fn(self : Self) -> unit)({
-    return __yo_mutex_unlock(&(self.mutex));
+    return(__yo_mutex_unlock(&(self.mutex)));
   })
 );
-impl(Mutex, Dispose(
-  dispose : (fn(self : Self) -> unit)({
-    return __yo_mutex_destroy(&(self.mutex));
-  })
-));
-
-export
+impl(
+  Mutex,
+  Dispose(
+    dispose : (fn(self : Self) -> unit)({
+      return(__yo_mutex_destroy(&(self.mutex)));
+    })
+  )
+);
+export(
   __YO_THREAD_SYNC_TYPE,
   mutex_t,
   Mutex
-;
+);

package/std/sync/once.yo

@@ -14,31 +14,30 @@
 //!   println("this will NOT run");
 //! });
 //! ```
-
-{ Mutex } :: import "./mutex";
-
+{ Mutex } :: import("./mutex");
 /// Execute a function exactly once, thread-safely.
 /// Uses atomic reference counting for safe cross-thread sharing.
-Once :: atomic object(
-  _done  : bool,
-  _mutex : Mutex
+Once :: atomic(
+  object(
+    _done : bool,
+    _mutex : Mutex
+  )
 );
-
-impl(Once,
+impl(
+  Once,
   // Create a new Once.
   new : (fn() -> Self)(
     Self(
-      _done: false,
-      _mutex: Mutex.new()
+      _done : false,
+      _mutex : Mutex.new()
     )
   ),
-
   // Execute the function exactly once.
   // Subsequent calls are no-ops.
   // Note: The fast-path read of _done is not strictly atomic, but since _done
   // is only ever set from false to true and the double-check inside the lock
   // prevents the function from running twice, this is safe in practice.
-  call : (fn(self: Self, f: Impl(Fn() -> unit)) -> unit)({
+  call : (fn(self : Self, f : Impl(Fn() -> unit)) -> unit)({
     // Fast path: already done
     cond(
       self._done => (),
@@ -58,11 +57,9 @@ impl(Once,
       }
     );
   }),
-
   // Check if the function has been called.
-  is_done : (fn(self: Self) -> bool)(
+  is_done : (fn(self : Self) -> bool)(
     self._done
   )
 );
-
-export Once;
+export(Once);

package/std/sync/rwlock.yo

@@ -16,45 +16,43 @@
 //! // ... write shared data ...
 //! lock.write_unlock();
 //! ```
-
-{ Mutex } :: import "./mutex";
-{ Cond } :: import "./cond";
-
+{ Mutex } :: import("./mutex");
+{ Cond } :: import("./cond");
 /// Reader-writer lock built on `Mutex` and `Cond`.
 /// Uses atomic reference counting for safe cross-thread sharing.
-RwLock :: atomic object(
-  _readers  : i32,
-  _writer   : bool,
-  _mutex    : Mutex,
-  _read_cv  : Cond,
-  _write_cv : Cond
+RwLock :: atomic(
+  object(
+    _readers : i32,
+    _writer : bool,
+    _mutex : Mutex,
+    _read_cv : Cond,
+    _write_cv : Cond
+  )
 );
-
-impl(RwLock,
+impl(
+  RwLock,
   // Create a new reader-writer lock.
   new : (fn() -> Self)(
     Self(
-      _readers: i32(0),
-      _writer: false,
-      _mutex: Mutex.new(),
-      _read_cv: Cond.new(),
-      _write_cv: Cond.new()
+      _readers : i32(0),
+      _writer : false,
+      _mutex : Mutex.new(),
+      _read_cv : Cond.new(),
+      _write_cv : Cond.new()
     )
   ),
-
   // Acquire a read lock. Blocks if a writer holds the lock.
   // Multiple readers can hold the lock simultaneously.
-  read_lock : (fn(self: Self) -> unit)({
+  read_lock : (fn(self : Self) -> unit)({
     self._mutex.lock();
-    while runtime(self._writer), {
+    while(runtime(self._writer), {
       self._read_cv.wait(self._mutex);
-    };
+    });
     self._readers = (self._readers + i32(1));
     self._mutex.unlock();
   }),
-
   // Release a read lock.
-  read_unlock : (fn(self: Self) -> unit)({
+  read_unlock : (fn(self : Self) -> unit)({
     self._mutex.lock();
     self._readers = (self._readers - i32(1));
     cond(
@@ -63,19 +61,17 @@ impl(RwLock,
     );
     self._mutex.unlock();
   }),
-
   // Acquire a write lock. Blocks until all readers and writers release.
-  write_lock : (fn(self: Self) -> unit)({
+  write_lock : (fn(self : Self) -> unit)({
     self._mutex.lock();
-    while runtime((self._writer || (self._readers > i32(0)))), {
+    while(runtime(self._writer || (self._readers > i32(0))), {
       self._write_cv.wait(self._mutex);
-    };
+    });
     self._writer = true;
     self._mutex.unlock();
   }),
-
   // Release a write lock.
-  write_unlock : (fn(self: Self) -> unit)({
+  write_unlock : (fn(self : Self) -> unit)({
     self._mutex.lock();
     self._writer = false;
     self._read_cv.broadcast();
@@ -83,5 +79,4 @@ impl(RwLock,
     self._mutex.unlock();
   })
 );
-
-export RwLock;
+export(RwLock);

package/std/sync/waitgroup.yo

@@ -18,31 +18,30 @@
 //! };
 //! wg.wait();  // blocks until all 3 tasks call done()
 //! ```
-
-{ Mutex } :: import "./mutex";
-{ Cond } :: import "./cond";
-
+{ Mutex } :: import("./mutex");
+{ Cond } :: import("./cond");
 /// Synchronization primitive that blocks until a counter reaches zero.
 /// Uses atomic reference counting for safe cross-thread sharing.
-WaitGroup :: atomic object(
-  _count : i32,
-  _mutex : Mutex,
-  _cv    : Cond
+WaitGroup :: atomic(
+  object(
+    _count : i32,
+    _mutex : Mutex,
+    _cv : Cond
+  )
 );
-
-impl(WaitGroup,
+impl(
+  WaitGroup,
   // Create a new WaitGroup with count 0.
   new : (fn() -> Self)(
     Self(
-      _count: i32(0),
-      _mutex: Mutex.new(),
-      _cv: Cond.new()
+      _count : i32(0),
+      _mutex : Mutex.new(),
+      _cv : Cond.new()
     )
   ),
-
   // Add delta to the counter (can be negative).
   // If the counter becomes zero, all waiters are woken.
-  add : (fn(self: Self, delta: i32) -> unit)({
+  add : (fn(self : Self, delta : i32) -> unit)({
     self._mutex.lock();
     self._count = (self._count + delta);
     cond(
@@ -54,25 +53,21 @@ impl(WaitGroup,
     );
     self._mutex.unlock();
   }),
-
   // Decrement the counter by one (equivalent to add(-1)).
-  done : (fn(self: Self) -> unit)(
+  done : (fn(self : Self) -> unit)(
     self.add(i32(-(1)))
   ),
-
   // Block until the counter reaches zero.
-  wait : (fn(self: Self) -> unit)({
+  wait : (fn(self : Self) -> unit)({
     self._mutex.lock();
-    while runtime((self._count > i32(0))), {
+    while(runtime(self._count > i32(0)), {
       self._cv.wait(self._mutex);
-    };
+    });
     self._mutex.unlock();
   }),
-
   // Get the current count (for debugging).
-  count : (fn(self: Self) -> i32)(
+  count : (fn(self : Self) -> i32)(
     self._count
   )
 );
-
-export WaitGroup;
+export(WaitGroup);