@shd101wyy/yo 0.1.31 → 0.1.32

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shd101wyy/yo",
   "displayName": "Yo",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "main": "./out/cjs/index.cjs",
   "module": "./out/esm/index.mjs",
   "types": "./out/types/src/index.d.ts",

package/std/libc/stdatomic.yo

@@ -284,8 +284,13 @@ extern(
   __yo_atomic_exchange_schar :
     fn(obj : *(atomic_schar), desired : i8, order : memory_order) -> i8,
   __yo_atomic_compare_exchange_schar :
-    fn(obj : *(atomic_schar), expected : *(i8), desired : i8,
-       success : memory_order, failure : memory_order) -> bool,
+    fn(
+      obj : *(atomic_schar),
+      expected : *(i8),
+      desired : i8,
+      success : memory_order,
+      failure : memory_order
+    ) -> bool,
   __yo_atomic_load_short :
     fn(obj : *(atomic_short), order : memory_order) -> i16,
   __yo_atomic_store_short :
@@ -293,8 +298,13 @@ extern(
   __yo_atomic_exchange_short :
     fn(obj : *(atomic_short), desired : i16, order : memory_order) -> i16,
   __yo_atomic_compare_exchange_short :
-    fn(obj : *(atomic_short), expected : *(i16), desired : i16,
-       success : memory_order, failure : memory_order) -> bool,
+    fn(
+      obj : *(atomic_short),
+      expected : *(i16),
+      desired : i16,
+      success : memory_order,
+      failure : memory_order
+    ) -> bool,
   __yo_atomic_load_uchar :
     fn(obj : *(atomic_uchar), order : memory_order) -> u8,
   __yo_atomic_store_uchar :
@@ -302,8 +312,13 @@ extern(
   __yo_atomic_exchange_uchar :
     fn(obj : *(atomic_uchar), desired : u8, order : memory_order) -> u8,
   __yo_atomic_compare_exchange_uchar :
-    fn(obj : *(atomic_uchar), expected : *(u8), desired : u8,
-       success : memory_order, failure : memory_order) -> bool,
+    fn(
+      obj : *(atomic_uchar),
+      expected : *(u8),
+      desired : u8,
+      success : memory_order,
+      failure : memory_order
+    ) -> bool,
   __yo_atomic_load_ushort :
     fn(obj : *(atomic_ushort), order : memory_order) -> u16,
   __yo_atomic_store_ushort :
@@ -311,8 +326,13 @@ extern(
   __yo_atomic_exchange_ushort :
     fn(obj : *(atomic_ushort), desired : u16, order : memory_order) -> u16,
   __yo_atomic_compare_exchange_ushort :
-    fn(obj : *(atomic_ushort), expected : *(u16), desired : u16,
-       success : memory_order, failure : memory_order) -> bool,
+    fn(
+      obj : *(atomic_ushort),
+      expected : *(u16),
+      desired : u16,
+      success : memory_order,
+      failure : memory_order
+    ) -> bool,
   __yo_atomic_load_uint :
     fn(obj : *(atomic_uint), order : memory_order) -> u32,
   __yo_atomic_store_uint :
@@ -320,8 +340,13 @@ extern(
   __yo_atomic_exchange_uint :
     fn(obj : *(atomic_uint), desired : u32, order : memory_order) -> u32,
   __yo_atomic_compare_exchange_uint :
-    fn(obj : *(atomic_uint), expected : *(u32), desired : u32,
-       success : memory_order, failure : memory_order) -> bool,
+    fn(
+      obj : *(atomic_uint),
+      expected : *(u32),
+      desired : u32,
+      success : memory_order,
+      failure : memory_order
+    ) -> bool,
   __yo_atomic_load_ullong :
     fn(obj : *(atomic_ullong), order : memory_order) -> u64,
   __yo_atomic_store_ullong :
@@ -329,8 +354,13 @@ extern(
   __yo_atomic_exchange_ullong :
     fn(obj : *(atomic_ullong), desired : u64, order : memory_order) -> u64,
   __yo_atomic_compare_exchange_ullong :
-    fn(obj : *(atomic_ullong), expected : *(u64), desired : u64,
-       success : memory_order, failure : memory_order) -> bool,
+    fn(
+      obj : *(atomic_ullong),
+      expected : *(u64),
+      desired : u64,
+      success : memory_order,
+      failure : memory_order
+    ) -> bool,
   __yo_atomic_load_ptrdiff :
     fn(obj : *(atomic_ptrdiff_t), order : memory_order) -> isize,
   __yo_atomic_store_ptrdiff :
@@ -338,8 +368,13 @@ extern(
   __yo_atomic_exchange_ptrdiff :
     fn(obj : *(atomic_ptrdiff_t), desired : isize, order : memory_order) -> isize,
   __yo_atomic_compare_exchange_ptrdiff :
-    fn(obj : *(atomic_ptrdiff_t), expected : *(isize), desired : isize,
-       success : memory_order, failure : memory_order) -> bool
+    fn(
+      obj : *(atomic_ptrdiff_t),
+      expected : *(isize),
+      desired : isize,
+      success : memory_order,
+      failure : memory_order
+    ) -> bool
 );
 export(
   // Atomic types

package/std/prelude.yo

@@ -59,7 +59,17 @@ Pragma :: enum(
   /// Test-runner directive: skip when target is wasm32-emscripten.
   SkipWasm32Emscripten,
   /// Test-runner directive: skip when target is wasm32-wasi.
-  SkipWasm32Wasi
+  SkipWasm32Wasi,
+  /// Formal verification: contracts in this file are proof obligations.
+  /// Phase 0 only registers the pragma; later phases will hook in
+  /// verification. See plans/FORMAL_VERIFICATION.md.
+  Verify,
+  /// Formal verification: try to prove, fall back to runtime assert
+  /// when proof times out. The production mode for verified code.
+  VerifyOrAssert,
+  /// Formal verification: erase contract clauses entirely (no proof,
+  /// no runtime assert). For release/benchmark builds.
+  NoContracts
 );
 export(Pragma);
 

package/std/spec/numeric.yo

@@ -0,0 +1,30 @@
+// Phase 0 of plans/FORMAL_VERIFICATION.md task #7.
+//
+// Numeric refinement aliases. All Phase 0 implementations are
+// type aliases; the verifier (Phase 2+) will attach concrete
+// predicates and enforce them.
+{ Refine } :: import("./refine.yo");
+
+/// Even integer.
+Even :: (fn(comptime(T) : Type) -> comptime(Type))(Refine(T));
+export(Even);
+
+/// Odd integer.
+Odd :: (fn(comptime(T) : Type) -> comptime(Type))(Refine(T));
+export(Odd);
+
+/// Strictly positive value (> 0).
+Positive :: (fn(comptime(T) : Type) -> comptime(Type))(Refine(T));
+export(Positive);
+
+/// Strictly negative value (< 0).
+Negative :: (fn(comptime(T) : Type) -> comptime(Type))(Refine(T));
+export(Negative);
+
+/// Non-negative value (>= 0).
+NonNegative :: (fn(comptime(T) : Type) -> comptime(Type))(Refine(T));
+export(NonNegative);
+
+/// Non-positive value (<= 0).
+NonPositive :: (fn(comptime(T) : Type) -> comptime(Type))(Refine(T));
+export(NonPositive);

package/std/spec/refine.yo

@@ -0,0 +1,43 @@
+// Phase 0 of plans/FORMAL_VERIFICATION.md task #7.
+//
+// `Refine`, `NonZero`, `Bounded` are comptime type constructors.
+// In Phase 0 they all return their underlying type unchanged —
+// effectively `Refine(T) = T`. The refinement predicate is
+// documented as a future parameter; the verifier (Phase 2) will
+// extend the surface to `Refine(T, predicate)` and enforce the
+// predicate at construction sites.
+//
+// Even without enforcement, these aliases serve as
+// human-and-LLM-readable signatures that signal intent. A function
+// taking `denom : NonZero(i32)` documents the precondition; callers
+// that want runtime enforcement can pair the alias with a
+// `requires(denom != i32(0))` clause until the verifier lands.
+/// A value of type `T` paired with a (compile-time) refinement
+/// predicate. Phase 0 ignores the predicate; later phases will
+/// require it as a second parameter and enforce it via
+/// the SMT backend.
+Refine :: (fn(comptime(T) : Type) -> comptime(Type))(T);
+export(Refine);
+
+/// `NonZero(T)` — values of `T` that are not zero. Phase 0 is a
+/// type alias for `T`; future phases will enforce via verification.
+NonZero :: (fn(comptime(T) : Type) -> comptime(Type))(Refine(T));
+export(NonZero);
+
+/// `Bounded(T, lo, hi)` — values of `T` in the closed range
+/// `[lo, hi]`. Phase 0 is a type alias for `T`. T must be `Comptime`
+/// so the bounds can be compile-time-known.
+Bounded :: (
+  fn(
+    comptime(T) : Type,
+    comptime(_lo) : T,
+    comptime(_hi) : T,
+    where(T <: Comptime)
+  ) -> comptime(Type)
+)(Refine(T));
+export(Bounded);
+
+/// `NonEmpty(T)` — collection types with at least one element.
+/// Phase 0 is a type alias for `T`.
+NonEmpty :: (fn(comptime(T) : Type) -> comptime(Type))(Refine(T));
+export(NonEmpty);