@shd101wyy/yo 0.1.15 → 0.1.16

package/std/sync/channel.yo

@@ -1,6 +1,9 @@
 //! Bounded multi-producer multi-consumer (MPMC) channel.
 //! Uses blocking send/recv via condition variables — does not require IO.
 //!
+//! Channel uses `atomic object` with atomic reference counting, so it can be
+//! safely shared across threads without `Arc` wrapping.
+//!
 //! # Example
 //!
 //! ```rust
@@ -16,43 +19,53 @@
 //! t.join();
 //! ```
 
-{ Deque } :: import "../collections/deque";
+{ GlobalAllocator } :: import "../allocator";
+{ malloc, free } :: GlobalAllocator;
 { Mutex } :: import "./mutex";
 { Cond } :: import "./cond";
 
 /// Thread-safe bounded channel for passing values between threads.
-Channel :: (fn(comptime(T) : Type) -> comptime(Type))
-  object(
-    _buf      : Deque(T),
-    _capacity : usize,
-    _mutex    : Mutex,
+/// 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
+    _closed    : bool
   )
 ;
 
-impl(forall(T : Type), Channel(T),
-  // Create a bounded channel with the given capacity.
-  // Capacity must be > 0.
-  new : (fn(capacity: usize) -> Self)(
-    Self(
-      _buf: Deque(T).new(),
+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
-    )
-  ),
+    );
+  }),
 
-  // 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 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))({
     self._mutex.lock();
     // Wait while buffer is full and channel is not closed
-    while runtime(((self._buf.len() >= self._capacity) && (!(self._closed)))), {
+    while runtime(((self._len >= self._capacity) && (!(self._closed)))), {
       self._not_full.wait(self._mutex);
     };
     cond(
@@ -62,63 +75,85 @@ impl(forall(T : Type), Channel(T),
       },
       true => ()
     );
-    self._buf.push_back(value);
+    // Write value at tail position
+    (tail : usize) = ((self._head + self._len) % self._capacity);
+    consume((self._data &+ tail).* = value);
+    self._len = (self._len + usize(1));
     self._not_empty.signal();
     self._mutex.unlock();
     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.
+  /// 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)({
     self._mutex.lock();
     // Wait while buffer is empty and channel is not closed
-    while runtime(((self._buf.is_empty()) && (!(self._closed)))), {
+    while runtime(((self._len == usize(0)) && (!(self._closed)))), {
       self._not_empty.wait(self._mutex);
     };
-    result := self._buf.pop_front();
     cond(
-      (result.is_some()) => self._not_full.signal(),
+      (self._len == usize(0)) => {
+        self._mutex.unlock();
+        return .None;
+      },
       true => ()
     );
+    // Read value at head position and neutralize the slot's RC
+    element_ptr := (self._data &+ self._head);
+    (val : T) = element_ptr.*;
+    unsafe.drop(element_ptr.*);
+    self._head = ((self._head + usize(1)) % self._capacity);
+    self._len = (self._len - usize(1));
+    self._not_full.signal();
     self._mutex.unlock();
-    return result;
+    return .Some(val);
   }),
 
-  // Try to send a value without blocking.
-  // Returns .Ok(()) if sent, .Err(()) if full or closed.
+  /// 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))({
     self._mutex.lock();
     cond(
-      (self._closed || (self._buf.len() >= self._capacity)) => {
+      (self._closed || (self._len >= self._capacity)) => {
         self._mutex.unlock();
         return .Err(());
       },
       true => ()
     );
-    self._buf.push_back(value);
+    (tail : usize) = ((self._head + self._len) % self._capacity);
+    consume((self._data &+ tail).* = value);
+    self._len = (self._len + usize(1));
     self._not_empty.signal();
     self._mutex.unlock();
     return .Ok(());
   }),
 
-  // Try to receive a value without blocking.
-  // Returns .Some(value) if available, .None if empty.
+  /// Try to receive a value without blocking.
+  /// Returns .Some(value) if available, .None if empty.
   try_recv : (fn(self: Self) -> ?T)({
     self._mutex.lock();
-    result := self._buf.pop_front();
     cond(
-      (result.is_some()) => self._not_full.signal(),
+      (self._len == usize(0)) => {
+        self._mutex.unlock();
+        return .None;
+      },
       true => ()
     );
+    element_ptr := (self._data &+ self._head);
+    (val : T) = element_ptr.*;
+    unsafe.drop(element_ptr.*);
+    self._head = ((self._head + usize(1)) % self._capacity);
+    self._len = (self._len - usize(1));
+    self._not_full.signal();
     self._mutex.unlock();
-    return result;
+    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 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)({
     self._mutex.lock();
     self._closed = true;
@@ -127,20 +162,33 @@ impl(forall(T : Type), Channel(T),
     self._mutex.unlock();
   }),
 
-  // Check if the channel is closed.
+  /// Check if the channel is closed.
   is_closed : (fn(self: Self) -> bool)(
     self._closed
   ),
 
-  // Return the number of values currently buffered.
+  /// Return the number of values currently buffered.
   len : (fn(self: Self) -> usize)(
-    self._buf.len()
+    self._len
   ),
 
-  // Check if the channel buffer is empty.
+  /// Check if the channel buffer is empty.
   is_empty : (fn(self: Self) -> bool)(
-    self._buf.is_empty()
+    (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;

package/std/sync/cond.yo

@@ -11,6 +11,9 @@ extern "Yo",
   __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
@@ -38,7 +41,8 @@ impl(cond_t,
 );
 
 /// Reference-counted condition variable with automatic cleanup via `Dispose`.
-Cond :: object(
+/// Uses atomic reference counting for safe cross-thread sharing.
+Cond :: atomic object(
   cv : __YO_COND_TYPE
 );
 impl(Cond,

package/std/sync/mutex.yo

@@ -8,6 +8,9 @@ extern "Yo",
   __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
@@ -31,7 +34,8 @@ impl(mutex_t,
 );
 
 /// Reference-counted mutex with automatic cleanup via `Dispose`.
-Mutex :: object(
+/// Uses atomic reference counting for safe cross-thread sharing.
+Mutex :: atomic object(
   mutex : __YO_THREAD_SYNC_TYPE
 );
 impl(Mutex,

package/std/sync/once.yo

@@ -18,7 +18,8 @@
 { Mutex } :: import "./mutex";
 
 /// Execute a function exactly once, thread-safely.
-Once :: object(
+/// Uses atomic reference counting for safe cross-thread sharing.
+Once :: atomic object(
   _done  : bool,
   _mutex : Mutex
 );

package/std/sync/rwlock.yo

@@ -21,7 +21,8 @@
 { Cond } :: import "./cond";
 
 /// Reader-writer lock built on `Mutex` and `Cond`.
-RwLock :: object(
+/// Uses atomic reference counting for safe cross-thread sharing.
+RwLock :: atomic object(
   _readers  : i32,
   _writer   : bool,
   _mutex    : Mutex,

package/std/sync/waitgroup.yo

@@ -23,7 +23,8 @@
 { Cond } :: import "./cond";
 
 /// Synchronization primitive that blocks until a counter reaches zero.
-WaitGroup :: object(
+/// Uses atomic reference counting for safe cross-thread sharing.
+WaitGroup :: atomic object(
   _count : i32,
   _mutex : Mutex,
   _cv    : Cond

package/out/types/src/codegen/exprs/arc.d.ts

@@ -1,5 +0,0 @@
-import type { FnCallExpr } from "../../expr";
-import { type CodeGenContext } from "../utils";
-export declare function generateYoArcDispose(expr: FnCallExpr, indent: string, context: CodeGenContext): string;
-export declare function isArcTypeCall(expr: FnCallExpr): boolean;
-export declare function generateArcTypeCall(expr: FnCallExpr, indent: string, context: CodeGenContext): string;

package/out/types/src/evaluator/calls/arc.d.ts

@@ -1,15 +0,0 @@
-import { type Environment } from "../../env";
-import { type FnCallExpr } from "../../expr";
-import type { ArcType } from "../../types/definitions";
-import type { EvaluatorContext } from "../context";
-export declare function evaluateArcTypeCall({ expr, env, context, }: {
-    expr: FnCallExpr;
-    env: Environment;
-    context: EvaluatorContext;
-}): FnCallExpr;
-export declare function evaluateArcValueCall({ expr, env, context, arcType, }: {
-    expr: FnCallExpr;
-    env: Environment;
-    context: EvaluatorContext;
-    arcType: ArcType;
-}): FnCallExpr;