@shd101wyy/yo 0.1.29 → 0.1.30

package/std/glob.yo

@@ -17,12 +17,12 @@ _glob_match_impl :: (fn(pb : ArrayList(u8), pi : usize, tb : ArrayList(u8), ti :
     },
     true => ()
   );
-  p := pb.get(pi).unwrap();
+  p := pb(pi);
   // Handle * and **
   cond(
     (p == u8(42)) => {
       is_dbl := cond(
-        ((pi + usize(1)) < pb.len()) => (pb.get(pi + usize(1)).unwrap() == u8(42)),
+        ((pi + usize(1)) < pb.len()) => (pb(pi + usize(1)) == u8(42)),
         true => false
       );
       cond(
@@ -33,7 +33,7 @@ _glob_match_impl :: (fn(pb : ArrayList(u8), pi : usize, tb : ArrayList(u8), ti :
           cond(
             (npi < pb.len()) => {
               cond(
-                (pb.get(npi).unwrap() == u8(47)) => {
+                (pb(npi) == u8(47)) => {
                   npi = (npi + usize(1));
                 },
                 true => ()
@@ -70,7 +70,7 @@ _glob_match_impl :: (fn(pb : ArrayList(u8), pi : usize, tb : ArrayList(u8), ti :
           // Try * consuming one non-/ char
           cond(
             (ti < tb.len()) => {
-              tc := tb.get(ti).unwrap();
+              tc := tb(ti);
               cond(
                 (tc != u8(47)) => {
                   return(recur(pb, pi, tb, ti + usize(1)));
@@ -96,7 +96,7 @@ _glob_match_impl :: (fn(pb : ArrayList(u8), pi : usize, tb : ArrayList(u8), ti :
     },
     true => ()
   );
-  t := tb.get(ti).unwrap();
+  t := tb(ti);
   // Handle ?
   cond(
     (p == u8(63)) => {
@@ -119,7 +119,7 @@ _glob_match_impl :: (fn(pb : ArrayList(u8), pi : usize, tb : ArrayList(u8), ti :
       // Check for negation: ! or ^
       cond(
         (ci < pb.len()) => {
-          nc := pb.get(ci).unwrap();
+          nc := pb(ci);
           cond(
             ((nc == u8(33)) || (nc == u8(94))) => {
               neg = true;
@@ -134,7 +134,7 @@ _glob_match_impl :: (fn(pb : ArrayList(u8), pi : usize, tb : ArrayList(u8), ti :
       found := false;
       cdone := false;
       while((ci < pb.len()) && (!(cdone)), ci = (ci + usize(1)), {
-        ch := pb.get(ci).unwrap();
+        ch := pb(ci);
         cond(
           (ch == u8(93)) => {
             cdone = true;

package/std/http/client.yo

@@ -8,16 +8,17 @@
 //   { fetch, HttpResponse } :: import "std/http";
 //   { Exception } :: import "std/error";
 //
-//   main :: (fn(io : IO, exn : Exception) -> unit)({
+//   main :: (fn(io : Io, exn : Exception) -> unit)({
 //     resp := io.await(fetch(`http://example.com/api/data`, io), { io, exn });
 //     println(resp.body);
 //   });
+pragma(Pragma.AllowUnsafe);
 open(import("../string"));
 { ArrayList } :: import("../collections/array_list");
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
 open(import("../fmt"));
-{ Error, AnyError, Exception, IOErr } :: import("../error");
+{ Error, AnyError, Exception, IoExn } :: import("../error");
 { TcpStream } :: import("../net/tcp");
 { IpAddr, SocketAddr } :: import("../net/addr");
 { lookup_host } :: import("../net/dns");
@@ -116,12 +117,12 @@ _find_header_end :: (fn(data : ArrayList(u8)) -> usize)({
   while(runtime(i < limit), {
     cond(
       (
-        (data.get(i).unwrap() == u8(13)) &&
+        (data(i) == u8(13)) &&
           (
-            (data.get(i + usize(1)).unwrap() == u8(10)) &&
+            (data(i + usize(1)) == u8(10)) &&
               (
-                (data.get(i + usize(2)).unwrap() == u8(13)) &&
-                  (data.get(i + usize(3)).unwrap() == u8(10))
+                (data(i + usize(2)) == u8(13)) &&
+                  (data(i + usize(3)) == u8(10))
               )
           )
       ) => {
@@ -139,7 +140,7 @@ _find_content_length :: (fn(data : ArrayList(u8), header_end : usize) -> i32)({
   header_bytes := ArrayList(u8).new();
   i := usize(0);
   while(runtime(i < header_end), {
-    header_bytes.push(data.get(i).unwrap());
+    header_bytes.push(data(i));
     i = (i + usize(1));
   });
   header_str := String.from_bytes(header_bytes).to_lowercase();
@@ -175,7 +176,7 @@ _find_content_length :: (fn(data : ArrayList(u8), header_end : usize) -> i32)({
 // ============================================================================
 // Internal: read full HTTP response from a TCP stream
 // ============================================================================
-_read_http_response :: (fn(stream : TcpStream, e : IOErr) -> String)({
+_read_http_response :: (fn(stream : TcpStream, e : IoExn) -> String)({
   buf_size := usize(8192);
   buf := *(u8)(malloc(buf_size).unwrap());
   result := ArrayList(u8).new();
@@ -242,8 +243,8 @@ _read_http_response :: (fn(stream : TcpStream, e : IOErr) -> String)({
 /// resp := io.await(fetch_with(`http://example.com/api`, opts, io), { io, exn });
 /// ```
 fetch_with :: (
-  fn(url_str : String, opts : FetchOptions, io : IO) ->
-    Impl(Future(HttpResponse, IOErr))
+  fn(url_str : String, opts : FetchOptions, io : Io) ->
+    Impl(Future(HttpResponse, IoExn))
 )(
   io.async((e) => {
     // Parse URL
@@ -284,7 +285,7 @@ fetch_with :: (
       },
       true => ()
     );
-    ip := addrs.get(usize(0)).unwrap();
+    ip := addrs(usize(0));
     addr := SocketAddr.new(ip, port);
     // Connect
     stream := e.io.await(TcpStream.connect(addr, e.io), e);
@@ -309,7 +310,7 @@ fetch_with :: (
     // Add user-provided headers
     hi := usize(0);
     while(runtime(hi < opts.headers.len()), {
-      h := opts.headers.get(hi).unwrap();
+      h := opts.headers(hi);
       req.set_header(h.name, h.value);
       hi = (hi + usize(1));
     });
@@ -352,8 +353,8 @@ export(fetch_with);
 /// cond(resp.is_ok() => println(resp.body), true => println(`Error`));
 /// ```
 fetch :: (
-  fn(url_str : String, io : IO) ->
-    Impl(Future(HttpResponse, IOErr))
+  fn(url_str : String, io : Io) ->
+    Impl(Future(HttpResponse, IoExn))
 )(
   io.async((e) => {
     return(e.io.await(fetch_with(url_str, FetchOptions.new(), e.io), e));

package/std/http/http.yo

@@ -71,7 +71,7 @@ impl(
     result := `${self.method.to_string()} ${self.path} HTTP/1.1\r\n`;
     i := usize(0);
     while(i < self.headers.len(), i = (i + usize(1)), {
-      h := self.headers.get(i).unwrap();
+      h := self.headers(i);
       result = `${result}${h.name}: ${h.value}\r\n`;
     });
     result = `${result}\r\n`;
@@ -102,7 +102,7 @@ impl(
     lower_name := name.to_lowercase();
     i := usize(0);
     while(i < self.headers.len(), i = (i + usize(1)), {
-      h := self.headers.get(i).unwrap();
+      h := self.headers(i);
       cond(
         (h.name.to_lowercase() == lower_name) => {
           return(.Some(h.value));
@@ -134,7 +134,7 @@ parse_response :: (fn(raw : String) -> Result(HttpResponse, String))({
     },
     true => ()
   );
-  status_line := lines.get(usize(0)).unwrap();
+  status_line := lines(usize(0));
   cond(
     (!(status_line.starts_with(`HTTP/`))) => {
       return(.Err(`Invalid status line`));
@@ -172,7 +172,7 @@ parse_response :: (fn(raw : String) -> Result(HttpResponse, String))({
   j := usize(1);
   body_start := lines.len();
   while(j < lines.len(), j = (j + usize(1)), {
-    hline := lines.get(j).unwrap();
+    hline := lines(j);
     cond(
       hline.is_empty() => {
         body_start = (j + usize(1));
@@ -194,10 +194,10 @@ parse_response :: (fn(raw : String) -> Result(HttpResponse, String))({
   });
   cond(
     (body_start < lines.len()) => {
-      resp.body = lines.get(body_start).unwrap();
+      resp.body = lines(body_start);
       m := (body_start + usize(1));
       while(m < lines.len(), m = (m + usize(1)), {
-        resp.body = `${resp.body}\r\n${lines.get(m).unwrap()}`;
+        resp.body = `${resp.body}\r\n${lines(m)}`;
       });
     },
     true => ()

package/std/http/index.yo

@@ -5,7 +5,7 @@
 //   { HttpRequest, HttpResponse, fetch } :: import "std/http";
 //   { Exception } :: import "std/error";
 //
-//   main :: (fn(io : IO) -> unit)({
+//   main :: (fn(io : Io) -> unit)({
 //     exn := Exception(throw : ((err) -> {
 //       println(err.message());
 //       unwind ();

package/std/imm/list.yo

@@ -15,6 +15,7 @@
 //! assert((xs.head().unwrap() == i32(1)), "head is 1");
 //! assert((xs.len() == usize(3)), "length is 3");
 //! ```
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
 { malloc, free } :: GlobalAllocator;
 { memcpy } :: import("../libc/string.yo");
@@ -243,6 +244,38 @@ impl(
     })
   )
 );
+/// Index trait — `list(idx)` walks the chain and returns the element at
+/// `idx`, panicking on out-of-bounds. O(n). The Rc-managed `ListNode`
+/// keeps the value field on the heap, so `&(node._value)` is a valid
+/// pointer for the immediate read; the dispatcher inlines and
+/// dereferences before any drop runs.
+impl(
+  forall(T : Type),
+  where(T <: Send),
+  List(T),
+  Index(usize)(
+    Output : T,
+    index : (fn(ref(self) : Self, idx : usize) -> *(Self.Output))({
+      assert(idx < self._len, "imm.List: index out of bounds");
+      (current : Option(ListNode(T))) = self._head;
+      i := usize(0);
+      while(runtime(true), {
+        match(
+          current,
+          .Some(node) => {
+            if(i == idx, {
+              return(unsafe(&(node._value)));
+            });
+            current = node._next;
+            i = (i + usize(1));
+          },
+          .None => panic("imm.List: unreachable past length check")
+        );
+      });
+      panic("imm.List: index loop exited without return")
+    })
+  )
+);
 export(
   List,
   ListNode

package/std/imm/map.yo

@@ -14,9 +14,10 @@
 //! m := Map(i32, i32).new();
 //! m = m.insert(i32(1), i32(100));
 //! m = m.insert(i32(2), i32(200));
-//! assert((m.get(i32(1)).unwrap() == i32(100)), "key 1 maps to 100");
+//! assert((m(i32(1)) == i32(100)), "key 1 maps to 100");
 //! assert((m.len() == usize(2)), "two entries");
 //! ```
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
 { malloc, free } :: GlobalAllocator;
 /// Number of bits per HAMT level.

package/std/imm/set.yo

@@ -17,6 +17,7 @@
 //! assert(s.contains(i32(1)), "set contains 1");
 //! assert((s.len() == usize(2)), "two elements");
 //! ```
+pragma(Pragma.AllowUnsafe);
 { Map } :: import("./map.yo");
 { List } :: import("./list.yo");
 /// Persistent immutable hash set backed by a HAMT.

package/std/imm/sorted_map.yo

@@ -17,6 +17,7 @@
 //! m = m.insert(i32(2), i32(20));
 //! // keys are always sorted: 1, 2, 3
 //! ```
+pragma(Pragma.AllowUnsafe);
 { List } :: import("./list.yo");
 { Pair } :: import("./map.yo");
 /// Color of a red-black tree node.

package/std/imm/sorted_set.yo

@@ -17,6 +17,7 @@
 //! s = s.insert(i32(2));
 //! // elements are always sorted: 1, 2, 3
 //! ```
+pragma(Pragma.AllowUnsafe);
 { SortedMap } :: import("./sorted_map.yo");
 { List } :: import("./list.yo");
 /// Persistent immutable sorted set backed by a left-leaning red-black tree.

package/std/imm/string.yo

@@ -2,6 +2,7 @@
 //!
 //! Uses atomic reference counting for safe sharing across threads.
 //! All "modification" operations return a new string; the original is unchanged.
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
 { malloc, free } :: GlobalAllocator;
 { memcpy, memcmp } :: import("../libc/string.yo");
@@ -57,7 +58,7 @@ impl(
       return(Self(_ptr :.None, _len : usize(0), _capacity : usize(0)));
     });
     ptr := _alloc_bytes(slen);
-    memcpy(*(void)(ptr), *(void)(s.ptr()), slen);
+    unsafe(memcpy(*(void)(ptr), *(void)(s.ptr()), slen));
     return(Self(_ptr :.Some(ptr), _len : slen, _capacity : slen));
   }),
   /// Create a string from a standard (mutable) String by copying its bytes.
@@ -68,7 +69,7 @@ impl(
     });
     ptr := _alloc_bytes(slen);
     (as_str : str) = s.as_str();
-    memcpy(*(void)(ptr), *(void)(as_str.ptr()), slen);
+    unsafe(memcpy(*(void)(ptr), *(void)(as_str.ptr()), slen));
     return(Self(_ptr :.Some(ptr), _len : slen, _capacity : slen));
   }),
   /// Byte length of the string.
@@ -138,7 +139,7 @@ impl(
           .Some(op) => match(
             self._ptr,
             .Some(sp) => {
-              memcpy(*(void)(sp &+ self._len), *(void)(op), other._len);
+              unsafe(memcpy(*(void)(sp &+ self._len), *(void)(op), other._len));
             },
             .None => ()
           ),
@@ -155,7 +156,7 @@ impl(
       match(
         self._ptr,
         .Some(sp) => {
-          memcpy(*(void)(ptr), *(void)(sp), self._len);
+          unsafe(memcpy(*(void)(ptr), *(void)(sp), self._len));
           free(.Some(*(void)(sp)));
         },
         .None => ()
@@ -163,7 +164,7 @@ impl(
       match(
         other._ptr,
         .Some(op) => {
-          memcpy(*(void)(ptr &+ self._len), *(void)(op), other._len);
+          unsafe(memcpy(*(void)(ptr &+ self._len), *(void)(op), other._len));
         },
         .None => ()
       );
@@ -176,14 +177,14 @@ impl(
     match(
       self._ptr,
       .Some(sp) => {
-        memcpy(*(void)(ptr), *(void)(sp), self._len);
+        unsafe(memcpy(*(void)(ptr), *(void)(sp), self._len));
       },
       .None => ()
     );
     match(
       other._ptr,
       .Some(op) => {
-        memcpy(*(void)(ptr &+ self._len), *(void)(op), other._len);
+        unsafe(memcpy(*(void)(ptr &+ self._len), *(void)(op), other._len));
       },
       .None => ()
     );
@@ -203,7 +204,7 @@ impl(
     match(
       self._ptr,
       .Some(sp) => {
-        memcpy(*(void)(ptr), *(void)(sp &+ clamped_start), new_len);
+        unsafe(memcpy(*(void)(ptr), *(void)(sp &+ clamped_start), new_len));
       },
       .None => ()
     );
@@ -221,7 +222,7 @@ impl(
       self._ptr,
       .Some(sp) => match(
         prefix._ptr,
-        .Some(pp) => (memcmp(*(void)(sp), *(void)(pp), prefix._len) == int(0)),
+        .Some(pp) => (unsafe(memcmp(*(void)(sp), *(void)(pp), prefix._len)) == int(0)),
         .None => true
       ),
       .None => (prefix._len == usize(0))
@@ -240,7 +241,7 @@ impl(
       self._ptr,
       .Some(sp) => match(
         suffix._ptr,
-        .Some(xp) => (memcmp(*(void)(sp &+ offset), *(void)(xp), suffix._len) == int(0)),
+        .Some(xp) => (unsafe(memcmp(*(void)(sp &+ offset), *(void)(xp), suffix._len)) == int(0)),
         .None => true
       ),
       .None => (suffix._len == usize(0))
@@ -269,7 +270,7 @@ impl(
           i := from_index;
           limit := ((self._len - needle._len) + usize(1));
           while(i < limit, i = (i + usize(1)), {
-            if(memcmp(*(void)(sp &+ i), *(void)(np), needle._len) == int(0), {
+            if(unsafe(memcmp(*(void)(sp &+ i), *(void)(np), needle._len)) == int(0), {
               return(.Some(i));
             });
           });
@@ -410,7 +411,7 @@ impl(
           return(self);
         });
         ptr := _alloc_bytes(self._len);
-        memcpy(*(void)(ptr), *(void)(sp), self._len);
+        unsafe(memcpy(*(void)(ptr), *(void)(sp), self._len));
         i := usize(0);
         while(i < self._len, i = (i + usize(1)), {
           (b : u8) = (ptr &+ i).*;
@@ -447,7 +448,7 @@ impl(
           return(self);
         });
         ptr := _alloc_bytes(self._len);
-        memcpy(*(void)(ptr), *(void)(sp), self._len);
+        unsafe(memcpy(*(void)(ptr), *(void)(sp), self._len));
         i := usize(0);
         while(i < self._len, i = (i + usize(1)), {
           (b : u8) = (ptr &+ i).*;
@@ -516,7 +517,7 @@ impl(
       .Some(sp) => {
         i := usize(0);
         while(i < n, i = (i + usize(1)), {
-          memcpy(*(void)(ptr &+ (i * self._len)), *(void)(sp), self._len);
+          unsafe(memcpy(*(void)(ptr &+ (i * self._len)), *(void)(sp), self._len));
         });
       },
       .None => ()
@@ -623,7 +624,7 @@ impl(
         self._ptr,
         .Some(sp) => match(
           other._ptr,
-          .Some(op) => (memcmp(*(void)(sp), *(void)(op), self._len) == int(0)),
+          .Some(op) => (unsafe(memcmp(*(void)(sp), *(void)(op), self._len)) == int(0)),
           .None => false
         ),
         .None => match(
@@ -653,7 +654,7 @@ impl(
     });
     match(
       self._ptr,
-      .Some(sp) => (memcmp(*(void)(sp), *(void)(other.ptr()), self._len) == int(0)),
+      .Some(sp) => (unsafe(memcmp(*(void)(sp), *(void)(other.ptr()), self._len)) == int(0)),
       .None => (other_len == usize(0))
     )
   })
@@ -670,7 +671,7 @@ impl(
           .Some(sp) => match(
             other._ptr,
             .Some(op) => {
-              (cmp_result : int) = memcmp(*(void)(sp), *(void)(op), min_len);
+              (cmp_result : int) = unsafe(memcmp(*(void)(sp), *(void)(op), min_len));
               if(cmp_result != int(0), {
                 return(cmp_result < int(0));
               });
@@ -697,15 +698,18 @@ impl(
 impl(
   String,
   Hash(
-    (hash) : (fn(self : *(Self)) -> u64)({
+    (hash) : (fn(ref(self) : Self) -> u64)({
       h := u64(14695981039346656037);
       match(
-        self.*._ptr,
+        self._ptr,
         .None => (),
         .Some(p) => {
           i := usize(0);
-          while(i < self.*._len, i = (i + usize(1)), {
-            h = (h ^ u64((p &+ i).*));
+          while(i < self._len, i = (i + usize(1)), {
+            // SAFETY: `p` points at the Rc-managed UTF-8 byte
+            // buffer of length `self._len`; the loop guard
+            // `i < self._len` keeps `p &+ i` inside the allocation.
+            h = (h ^ u64(unsafe((p &+ i).*)));
             h = (h * u64(1099511628211));
           });
         }
@@ -718,8 +722,8 @@ impl(
 impl(
   String,
   ToString(
-    to_string : (fn(self : *(Self)) -> std_string.String)(
-      std_string.String.from(self.*.as_str())
+    to_string : (fn(ref(self) : Self) -> std_string.String)(
+      std_string.String.from(self.as_str())
     )
   )
 );

package/std/imm/vec.yo

@@ -13,9 +13,10 @@
 //!
 //! v := Vec(i32).new();
 //! v = v.push(i32(1)).push(i32(2)).push(i32(3));
-//! assert((v.get(usize(0)).unwrap() == i32(1)), "first element");
+//! assert((v(usize(0)) == i32(1)), "first element");
 //! assert((v.len() == usize(3)), "length is 3");
 //! ```
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
 { malloc, free } :: GlobalAllocator;
 /// Persistent immutable vector.
@@ -406,7 +407,7 @@ impl(
     new_ptr := Vec(V)._raw_alloc(min_len);
     i := usize(0);
     while(i < min_len, i = (i + usize(1)), {
-      (new_ptr &+ i).* = f((self._ptr &+ i).*, other.get(i).unwrap());
+      (new_ptr &+ i).* = f((self._ptr &+ i).*, other(i));
     });
     Vec(V)(_ptr : new_ptr, _len : min_len, _cap : min_len)
   }),
@@ -445,4 +446,19 @@ impl(
     })
   )
 );
+/// Index trait — `vec(idx)` returns the element at `idx`, panicking if
+/// out of bounds. Body takes `&(self)` so the dispatcher's inlined call
+/// passes the right C-ABI shape. See plans/ITERATOR_REDESIGN.md.
+impl(
+  forall(T : Type),
+  where(T <: Send),
+  Vec(T),
+  Index(usize)(
+    Output : T,
+    index : (fn(ref(self) : Self, idx : usize) -> *(Self.Output))({
+      assert(idx < self._len, "imm.Vec: index out of bounds");
+      self._ptr &+ idx
+    })
+  )
+);
 export(Vec, PopResult);

package/std/io/reader.yo

@@ -1,10 +1,11 @@
 //! Reader trait for byte-level input.
+pragma(Pragma.AllowUnsafe);
 { Exception } :: import("../error");
 /// Common interface for reading bytes from various sources.
 Reader :: trait(
   /// Read up to `size` bytes into buffer `buf`.
   /// Returns the number of bytes actually read (0 at end-of-stream).
   read :
-    fn(self : *(Self), buf : *(u8), size : usize, exn : Exception) -> usize
+    fn(ref(self) : Self, buf : *(u8), size : usize, exn : Exception) -> usize
 );
 export(Reader);

package/std/io/writer.yo

@@ -1,12 +1,13 @@
 //! Writer trait for byte-level output.
+pragma(Pragma.AllowUnsafe);
 { Exception } :: import("../error");
 /// Common interface for writing bytes to a destination.
 Writer :: trait(
   /// Write bytes from buffer. Returns number of bytes written.
   write :
-    fn(self : *(Self), buf : *(u8), size : usize, exn : Exception) -> usize,
+    fn(ref(self) : Self, buf : *(u8), size : usize, exn : Exception) -> usize,
   /// Flush any buffered data to the underlying destination.
   flush :
-    fn(self : *(Self), exn : Exception) -> unit
+    fn(ref(self) : Self, exn : Exception) -> unit
 );
 export(Writer);

package/std/libc/assert.yo

@@ -1,5 +1,6 @@
 //! C11 `<assert.h>` — assertion debugging facility.
 //! Provides runtime assertion checking for debugging.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<assert.h>",
   // The actual assertion function called by the assert macro

package/std/libc/ctype.yo

@@ -1,4 +1,5 @@
 //! C11 `<ctype.h>` — character classification and conversion functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<ctype.h>",
   // Character classification functions

package/std/libc/dirent.yo

@@ -1,4 +1,5 @@
 //! C11 `<dirent.h>` — directory entry operations.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<dirent.h>",
   // Types

package/std/libc/errno.yo

@@ -1,4 +1,5 @@
 //! C11 `<errno.h>` — error handling constants and `errno` variable.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<errno.h>",
   // The errno variable - global error indicator

package/std/libc/fcntl.yo

@@ -1,5 +1,6 @@
 //! POSIX `<fcntl.h>` — file control options.
 //! Provides open flags and file control operations.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<fcntl.h>",
   // File access modes (for open)

package/std/libc/float.yo

@@ -1,4 +1,5 @@
 //! C11 `<float.h>` — floating-point implementation limits.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<float.h>",
   // Floating-point model parameters

package/std/libc/limits.yo

@@ -1,4 +1,5 @@
 //! C11 `<limits.h>` — implementation-defined limits for integer types.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<limits.h>",
   // Character limits

package/std/libc/math.yo

@@ -1,4 +1,5 @@
 //! C11 `<math.h>` — mathematical functions and constants.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<math.h>",
   // Mathematical constants (implementation-defined)

package/std/libc/signal.yo

@@ -1,4 +1,5 @@
 //! C11 `<signal.h>` — signal handling functions and constants.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<signal.h>",
   // Signal handler type

package/std/libc/stdatomic.yo

@@ -1,4 +1,5 @@
 //! C11 `<stdatomic.h>` — atomic operations and types.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<stdatomic.h>",
   // Atomic types

package/std/libc/stdint.yo

@@ -3,6 +3,7 @@
 //! Note: Yo already has `i8`, `i16`, `i32`, `i64`, `u8`, `u16`, `u32`, `u64`.
 //! This file provides C-compatible aliases and additional types/constants.
 // Type aliases for C compatibility (mapping Yo types to C stdint names)
+pragma(Pragma.AllowUnsafe);
 int8_t :: i8;
 int16_t :: i16;
 int32_t :: i32;

package/std/libc/stdio.yo

@@ -1,4 +1,5 @@
 //! C11 `<stdio.h>` — standard I/O functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<stdio.h>",
   // Types

package/std/libc/stdlib.yo

@@ -1,4 +1,5 @@
 //! C11 `<stdlib.h>` — general utility functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<stdlib.h>",
   // Types for div functions

package/std/libc/string.yo

@@ -1,4 +1,5 @@
 //! C11 `<string.h>` — string and memory functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<string.h>",
   // Memory functions

package/std/libc/sys/stat.yo

@@ -1,4 +1,5 @@
 //! POSIX `<sys/stat.h>` — file status and mode operations.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<sys/stat.h>",
   // Types