@shd101wyy/yo 0.0.23 → 0.0.25

package/std/collections/priority_queue.yo

@@ -118,4 +118,73 @@ impl(forall(T : Type), PriorityQueue(T),
   })
 );
 
-export PriorityQueue;
+/**
+ * Value iterator for PriorityQueue - yields elements in heap (arbitrary) order
+ * Note: This iterates in internal storage order, NOT sorted order.
+ */
+PriorityQueueIter :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _data  : ArrayList(T),
+    _index : usize
+  )
+);
+
+impl(forall(T : Type), PriorityQueueIter(T), Iterator(
+  Item : T,
+  next : (fn(self : *(Self)) -> Option(T))(
+    cond(
+      (self._index >= self._data.len()) => .None,
+      true => {
+        value := self._data.get(self._index).unwrap();
+        self._index = (self._index + usize(1));
+        .Some(value)
+      }
+    )
+  )
+));
+
+impl(forall(T : Type), PriorityQueue(T),
+  into_iter : (fn(self : Self) -> PriorityQueueIter(T))(
+    PriorityQueueIter(T)(_data: self._data, _index: usize(0))
+  )
+);
+
+/**
+ * Pointer iterator for PriorityQueue - yields pointers to elements in heap order
+ */
+PriorityQueueIterPtr :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _data  : ArrayList(T),
+    _index : usize
+  )
+);
+
+impl(forall(T : Type), PriorityQueueIterPtr(T), Iterator(
+  Item : *(T),
+  next : (fn(self : *(Self)) -> Option(*(T)))(
+    cond(
+      (self._index >= self._data.len()) => .None,
+      true =>
+        match(self._data._ptr,
+          .Some(ptr) => {
+            element_ptr := (ptr &+ self._index);
+            self._index = (self._index + usize(1));
+            .Some(element_ptr)
+          },
+          .None => .None
+        )
+    )
+  )
+));
+
+impl(forall(T : Type), PriorityQueue(T),
+  iter : (fn(self : *(Self)) -> PriorityQueueIterPtr(T))(
+    PriorityQueueIterPtr(T)(_data: self.*._data, _index: usize(0))
+  )
+);
+
+export
+  PriorityQueue,
+  PriorityQueueIter,
+  PriorityQueueIterPtr
+;

package/std/crypto/md5.yo

@@ -51,8 +51,8 @@ _rotl32 :: (fn(x: u32, n: u32) -> u32)(
 );
 
 _le32 :: (fn(p: *(u8)) -> u32)(
-  (u32(p.*) | (u32((p &+ usize(1)).*) << u32(8)) |
-  (u32((p &+ usize(2)).*) << u32(16)) | (u32((p &+ usize(3)).*) << u32(24)))
+  ((u32(p.*) | (u32((p &+ usize(1)).*) << u32(8))) |
+  ((u32((p &+ usize(2)).*) << u32(16)) | (u32((p &+ usize(3)).*) << u32(24))))
 );
 
 _md5_block :: (fn(block: *(u8), h: *(u32)) -> unit)({
@@ -74,7 +74,7 @@ _md5_block :: (fn(block: *(u8), h: *(u32)) -> unit)({
         g  = (((i * usize(5)) + usize(1)) % usize(16));
       },
       (i < usize(48)) => {
-        fv = (b ^ c ^ d);
+        fv = ((b ^ c) ^ d);
         g  = (((i * usize(3)) + usize(5)) % usize(16));
       },
       true => {
@@ -104,7 +104,7 @@ md5 :: (fn(data: ArrayList(u8)) -> Array(u8, usize(16)))({
   // Process full blocks
   i := usize(0);
   while ((i + usize(64)) <= n), (i = (i + usize(64))), {
-    chunk_ptr := *(u8)(data.ptr().unwrap()) &+ i;
+    chunk_ptr := (*(u8)(data.ptr().unwrap()) &+ i);
     _md5_block(chunk_ptr, h_ptr);
   };
   // Final block(s) with padding

package/std/crypto/random.yo

@@ -93,12 +93,12 @@ random_f64 :: (fn() -> f64)(
 
 // Return a random integer in the half-open range [min, max).
 random_range :: (fn(min: i64, max: i64) -> i64)({
-  span := i64((max - min));
+  span := (max - min);
   cond(
     (span <= i64(0)) => min,
     true => {
-      r := i64(random_u64());
-      (min + (r % span))
+      r := random_u64();
+      (min + i64((r % u64(span))))
     }
   )
 });

package/std/crypto/sha256.yo

@@ -39,7 +39,7 @@ _rotr32 :: (fn(x: u32, n: u32) -> u32)(
 );
 
 _ch  :: (fn(e: u32, f: u32, g: u32) -> u32)( ((e & f) ^ ((~e) & g)) );
-_maj :: (fn(a: u32, b: u32, c: u32) -> u32)( ((a & b) ^ (a & c) ^ (b & c)) );
+_maj :: (fn(a: u32, b: u32, c: u32) -> u32)( (((a & b) ^ (a & c)) ^ (b & c)) );
 _ep0 :: (fn(a: u32) -> u32)( ((_rotr32(a, u32(2)) ^ _rotr32(a, u32(13))) ^ _rotr32(a, u32(22))) );
 _ep1 :: (fn(e: u32) -> u32)( ((_rotr32(e, u32(6)) ^ _rotr32(e, u32(11))) ^ _rotr32(e, u32(25))) );
 _sg0 :: (fn(x: u32) -> u32)( ((_rotr32(x, u32(7)) ^ _rotr32(x, u32(18))) ^ (x >> u32(3))) );
@@ -53,15 +53,16 @@ _sha256_block :: (fn(block: *(u8), h: *(u32)) -> unit)({
   while (i < usize(16)), (i = (i + usize(1))), {
     off := (i * usize(4));
     w(i) = (
-      ((u32((block &+ off).*) << u32(24)) |
-       (u32((block &+ (off + usize(1))).*) << u32(16)) |
-       (u32((block &+ (off + usize(2))).*) << u32(8)) |
-        u32((block &+ (off + usize(3))).*)
-      )
+      (((u32((block &+ off).*) << u32(24)) |
+       (u32((block &+ (off + usize(1))).*) << u32(16))) |
+       ((u32((block &+ (off + usize(2))).*) << u32(8)) |
+        u32((block &+ (off + usize(3))).*)))
     );
   };
   while (i < usize(64)), (i = (i + usize(1))), {
-    w(i) = ((((_sg1(w((i - usize(2)))) + w((i - usize(7)))) + _sg0(w((i - usize(15))))) + w((i - usize(16))));
+    s1 := _sg1(w((i - usize(2))));
+    s0 := _sg0(w((i - usize(15))));
+    w(i) = (((s1 + w((i - usize(7)))) + s0) + w((i - usize(16))));
   };
   // Compression
   a := (h &+ usize(0)).*;

package/std/encoding/base64.yo

@@ -30,8 +30,8 @@ _encode_with :: (fn(data: ArrayList(u8), alpha: str, pad: bool) -> String)({
   i   := usize(0);
   while (i < n), (i = (i + usize(3))), {
     b0 := data.get(i).unwrap();
-    b1 := cond((i + usize(1)) < n => data.get((i + usize(1))).unwrap(), true => u8(0));
-    b2 := cond((i + usize(2)) < n => data.get((i + usize(2))).unwrap(), true => u8(0));
+    b1 := cond(((i + usize(1)) < n) => data.get((i + usize(1))).unwrap(), true => u8(0));
+    b2 := cond(((i + usize(2)) < n) => data.get((i + usize(2))).unwrap(), true => u8(0));
 
     out.push(alpha.bytes(usize((b0 >> u8(2)))));
     out.push(alpha.bytes(usize(((b0 & u8(3)) << u8(4)) | (b1 >> u8(4)))));
@@ -87,22 +87,22 @@ _decode_char :: (fn(c: u8, alpha: str) -> Result(u8, EncodingError))({
 _decode_with :: (fn(s: str, alpha: str) -> Result(ArrayList(u8), EncodingError))({
   // Strip trailing padding
   len := s.len();
-  while ((len > usize(0)) && (s.bytes((len - usize(1))) == _PAD)), (len = (len - usize(1))), {};
+  while ((len > usize(0)) && (s.bytes((len - usize(1))) == _PAD)), (len = (len - usize(1))), ();
   out := ArrayList(u8).with_capacity(((len * usize(3)) / usize(4)));
   i   := usize(0);
   while (i < len), (i = (i + usize(4))), {
     c0_r := _decode_char(s.bytes(i), alpha);
     c1_r := cond(
       ((i + usize(1)) < len) => _decode_char(s.bytes((i + usize(1))), alpha),
-      true => .Ok(u8(0))
+      true => Result(u8, EncodingError).Ok(u8(0))
     );
     c2_r := cond(
       ((i + usize(2)) < len) => _decode_char(s.bytes((i + usize(2))), alpha),
-      true => .Ok(u8(0))
+      true => Result(u8, EncodingError).Ok(u8(0))
     );
     c3_r := cond(
       ((i + usize(3)) < len) => _decode_char(s.bytes((i + usize(3))), alpha),
-      true => .Ok(u8(0))
+      true => Result(u8, EncodingError).Ok(u8(0))
     );
     match(c0_r,
       .Err(e) => { return .Err(e); },

package/std/encoding/hex.yo

@@ -29,19 +29,23 @@ export EncodingError;
 _HEX_CHARS :: "0123456789abcdef";
 
 // Encode bytes as lowercase hexadecimal.
-hex_encode :: (fn(data: ArrayList(u8)) -> String)({
+_hex_encode_impl :: (fn(data: ArrayList(u8), hex_chars: str) -> String)({
   out := ArrayList(u8).with_capacity((data.len() * usize(2)));
   i := usize(0);
   while (i < data.len()), (i = (i + usize(1))), {
     b := data.get(i).unwrap();
     hi := usize(((b >> u8(4)) & u8(0xF)));
     lo := usize((b & u8(0xF)));
-    out.push(_HEX_CHARS.bytes(hi));
-    out.push(_HEX_CHARS.bytes(lo));
+    out.push(hex_chars.bytes(hi));
+    out.push(hex_chars.bytes(lo));
   };
   String.from_bytes(out)
 });
 
+hex_encode :: (fn(data: ArrayList(u8)) -> String)(
+  _hex_encode_impl(data, _HEX_CHARS)
+);
+
 export hex_encode;
 
 // ============================================================================
@@ -60,28 +64,29 @@ _hex_nibble :: (fn(c: u8) -> Result(u8, EncodingError))(
 // Decode a hexadecimal string into bytes.
 hex_decode :: (fn(s: str) -> Result(ArrayList(u8), EncodingError))({
   cond(
-    (((s.len() % usize(2)) != usize(0))) => .Err(.OddLength),
-    true => {
-      out := ArrayList(u8).with_capacity((s.len() / usize(2)));
-      i   := usize(0);
-      while (i < s.len()), (i = (i + usize(2))), {
-        hi_r := _hex_nibble(s.bytes(i));
-        lo_r := _hex_nibble(s.bytes((i + usize(1))));
-        match(hi_r,
+    (((s.len() % usize(2)) != usize(0))) => {
+      return .Err(.OddLength);
+    },
+    true => ()
+  );
+  out := ArrayList(u8).with_capacity((s.len() / usize(2)));
+  i   := usize(0);
+  while (i < s.len()), (i = (i + usize(2))), {
+    hi_r := _hex_nibble(s.bytes(i));
+    lo_r := _hex_nibble(s.bytes((i + usize(1))));
+    match(hi_r,
+      .Err(e) => { return .Err(e); },
+      .Ok(hi) => {
+        match(lo_r,
           .Err(e) => { return .Err(e); },
-          .Ok(hi) => {
-            match(lo_r,
-              .Err(e) => { return .Err(e); },
-              .Ok(lo) => {
-                out.push(((hi << u8(4)) | lo));
-              }
-            );
+          .Ok(lo) => {
+            out.push(((hi << u8(4)) | lo));
           }
         );
-      };
-      .Ok(out)
-    }
-  )
+      }
+    );
+  };
+  .Ok(out)
 });
 
 export hex_decode;