@shd101wyy/yo 0.0.25 → 0.0.27

package/std/prelude.yo

@@ -3822,11 +3822,23 @@ impl(FutureState, Eq(FutureState)(
 ));
 export FutureState;
 
+// JoinHandle(T) — a handle to a spawned async task.
+// Wraps a raw pointer to the spawned future's state machine.
+// Generic over T, the return type of the spawned task.
+// NOTE: __future uses *(T) (not *(void)) so that the type parameter T is visible
+// in the struct fields for generic impl matching to extract T from JoinHandle(T).
+JoinHandle :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    __future : *(T)
+  )
+);
+export JoinHandle;
+
 IO :: module(
   async : (fn(forall(T : Type, ...(E)), action : Impl(Fn(using(...(E))) -> T)) -> Impl(Future(T, ...(E)))),
   await : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E))), using(...(E))) -> T),
   state : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E)))) -> FutureState),
-  spawn : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E))), using(...(E))) -> unit)
+  spawn : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E))), using(...(E))) -> JoinHandle(T))
 );
 export IO;
 
@@ -3834,7 +3846,7 @@ extern "Yo",
   __yo_io_async : (fn(forall(T : Type, ...(E)), action : Impl(Fn(using(...(E))) -> T)) -> Impl(Future(T, ...(E)))),
   __yo_io_await : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E))), using(...(E))) -> T),
   __yo_io_state : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E)))) -> FutureState),
-  __yo_io_spawn : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E))), using(...(E))) -> unit)
+  __yo_io_spawn : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E))), using(...(E))) -> JoinHandle(T))
 ;
 
 // It's intended not to use `given` here.
@@ -3848,18 +3860,11 @@ __yo_builtin_io :: IO(
 );
 export __yo_builtin_io;
 
-/// === Exception ===
-// Example (function that may throw):
-//
-//   safe_div :: (fn(x: i32, y: i32, using(exception : Exception(String))) -> i32)(
-//     cond(
-//       (y == i32(0)) => exception.throw(`division by zero`)),
-//       true => (x / y)
-//     )
-//   );
-Exception :: (fn(comptime(ErrorType) : Type) -> comptime(Module))(
-  module(
-    throw : (fn(forall(ResumeType : Type), error : ErrorType) -> ResumeType)
-  )
+// JoinHandle methods — defined after IO so using(io : IO) resolves
+extern "Yo",
+  __yo_join_handle_await : (fn(forall(T : Type), self : JoinHandle(T), using(io : IO)) -> Option(T))
+;
+
+impl(forall(T : Type), JoinHandle(T),
+  await : __yo_join_handle_await
 );
-export Exception;

package/std/sys/errors.yo

@@ -4,6 +4,7 @@
 
 { String } :: import "../string";
 { ToString } :: import "../fmt";
+{ Error, Exception } :: import "../error";
 {
   ENOENT, EPERM, EACCES, EEXIST, ENOTDIR, EISDIR, ENOTEMPTY, EPIPE,
   EAGAIN, EWOULDBLOCK, EINVAL, EINTR, EMFILE, ENFILE, EFBIG, ENOSPC,
@@ -107,42 +108,53 @@ impl(IOError,
 impl(IOError, ToString(
   to_string : (self -> {
     s := match(self,
-      .NotFound => String.from_cstr("file or directory not found").unwrap(),
-      .PermissionDenied => String.from_cstr("permission denied").unwrap(),
-      .AlreadyExists => String.from_cstr("file or directory already exists").unwrap(),
-      .NotADirectory => String.from_cstr("not a directory").unwrap(),
-      .IsADirectory => String.from_cstr("is a directory").unwrap(),
-      .DirectoryNotEmpty => String.from_cstr("directory not empty").unwrap(),
-      .BrokenPipe => String.from_cstr("broken pipe").unwrap(),
-      .WouldBlock => String.from_cstr("operation would block").unwrap(),
-      .InvalidInput => String.from_cstr("invalid input").unwrap(),
-      .Interrupted => String.from_cstr("operation interrupted").unwrap(),
-      .TooManyOpenFiles => String.from_cstr("too many open files").unwrap(),
-      .FileTooLarge => String.from_cstr("file too large").unwrap(),
-      .NoSpace => String.from_cstr("no space left on device").unwrap(),
-      .ReadOnlyFilesystem => String.from_cstr("read-only filesystem").unwrap(),
-      .CrossDeviceLink => String.from_cstr("cross-device link").unwrap(),
-      .TooManyLinks => String.from_cstr("too many links").unwrap(),
-      .NameTooLong => String.from_cstr("name too long").unwrap(),
-      .NotSupported => String.from_cstr("operation not supported").unwrap(),
-      .TimedOut => String.from_cstr("operation timed out").unwrap(),
-      .Busy => String.from_cstr("resource busy").unwrap(),
-      .BadFileDescriptor => String.from_cstr("bad file descriptor").unwrap(),
-      .IOError => String.from_cstr("I/O error").unwrap(),
-      .ConnectionRefused => String.from_cstr("connection refused").unwrap(),
-      .ConnectionReset => String.from_cstr("connection reset by peer").unwrap(),
-      .ConnectionAborted => String.from_cstr("connection aborted").unwrap(),
-      .NotConnected => String.from_cstr("socket not connected").unwrap(),
-      .AddressInUse => String.from_cstr("address already in use").unwrap(),
-      .AddressNotAvailable => String.from_cstr("address not available").unwrap(),
-      .NetworkUnreachable => String.from_cstr("network unreachable").unwrap(),
-      .HostUnreachable => String.from_cstr("host unreachable").unwrap(),
-      .NetworkDown => String.from_cstr("network is down").unwrap(),
-      .AlreadyConnected => String.from_cstr("socket already connected").unwrap(),
-      .Other(errno) => String.from_cstr("unknown I/O error").unwrap()
+      .NotFound => String.from("file or directory not found"),
+      .PermissionDenied => String.from("permission denied"),
+      .AlreadyExists => String.from("file or directory already exists"),
+      .NotADirectory => String.from("not a directory"),
+      .IsADirectory => String.from("is a directory"),
+      .DirectoryNotEmpty => String.from("directory not empty"),
+      .BrokenPipe => String.from("broken pipe"),
+      .WouldBlock => String.from("operation would block"),
+      .InvalidInput => String.from("invalid input"),
+      .Interrupted => String.from("operation interrupted"),
+      .TooManyOpenFiles => String.from("too many open files"),
+      .FileTooLarge => String.from("file too large"),
+      .NoSpace => String.from("no space left on device"),
+      .ReadOnlyFilesystem => String.from("read-only filesystem"),
+      .CrossDeviceLink => String.from("cross-device link"),
+      .TooManyLinks => String.from("too many links"),
+      .NameTooLong => String.from("name too long"),
+      .NotSupported => String.from("operation not supported"),
+      .TimedOut => String.from("operation timed out"),
+      .Busy => String.from("resource busy"),
+      .BadFileDescriptor => String.from("bad file descriptor"),
+      .IOError => String.from("I/O error"),
+      .ConnectionRefused => String.from("connection refused"),
+      .ConnectionReset => String.from("connection reset by peer"),
+      .ConnectionAborted => String.from("connection aborted"),
+      .NotConnected => String.from("socket not connected"),
+      .AddressInUse => String.from("address already in use"),
+      .AddressNotAvailable => String.from("address not available"),
+      .NetworkUnreachable => String.from("network unreachable"),
+      .HostUnreachable => String.from("host unreachable"),
+      .NetworkDown => String.from("network is down"),
+      .AlreadyConnected => String.from("socket already connected"),
+      .Other(errno) => String.from("unknown I/O error")
     );
     return s;
   })
 ));
+impl(IOError, Error());
+
+impl(IOError,
+  // Check a raw result code, throwing on error via Exception effect.
+  check : (fn(result: i32, using(exn : Exception)) -> i32)(
+    cond(
+      (result >= i32(0)) => result,
+      true => exn.throw(dyn Self.from_errno(i32(0) - result))
+    )
+  )
+);
 
 export IOError;

package/std/url/url.yo

@@ -17,6 +17,7 @@
 open import "../string";
 { ArrayList } :: import "../collections/array_list";
 { ToString } :: import "../fmt";
+{ Error, AnyError, Exception } :: import "../error";
 
 // ============================================================================
 // UrlError
@@ -42,6 +43,8 @@ impl(UrlError, ToString(
   )
 ));
 
+impl(UrlError, Error());
+
 // ============================================================================
 // Url
 // ============================================================================
@@ -68,10 +71,10 @@ _DOT       :: u8(46);   // '.'
 // Helper: parse port number from bytes
 // ============================================================================
 
-_parse_port :: (fn(s: str, start: usize, end: usize) -> Result(u16, UrlError))({
+_parse_port :: (fn(s: str, start: usize, end: usize, using(exn : Exception)) -> u16)({
   cond(
     (start >= end) => {
-      return .Err(.InvalidPort);
+      exn.throw(dyn UrlError.InvalidPort);
     },
     true => ()
   );
@@ -84,18 +87,18 @@ _parse_port :: (fn(s: str, start: usize, end: usize) -> Result(u16, UrlError))({
         val = ((val * u32(10)) + u32((ch - _ZERO)));
         cond(
           (val > u32(65535)) => {
-            return .Err(.InvalidPort);
+            exn.throw(dyn UrlError.InvalidPort);
           },
           true => ()
         );
       },
       true => {
-        return .Err(.InvalidPort);
+        exn.throw(dyn UrlError.InvalidPort);
       }
     );
     i = (i + usize(1));
   };
-  .Ok(u16(val))
+  u16(val)
 });
 
 Url :: object(
@@ -112,10 +115,10 @@ impl(Url,
   // Parse a URL string.
   // Supports: scheme://[userinfo@]host[:port]/path[?query][#fragment]
   // Also supports scheme:path (opaque URIs like mailto:user@example.com)
-  parse : (fn(s: str) -> Result(Url, UrlError))({
+  parse : (fn(s: str, using(exn : Exception)) -> Url)({
     cond(
       (s.len() == usize(0)) => {
-        return .Err(.EmptyInput);
+        exn.throw(dyn UrlError.EmptyInput);
       },
       true => ()
     );
@@ -128,7 +131,7 @@ impl(Url,
     scheme_end := usize(0);
     cond(
       (src_len == usize(0)) => {
-        return .Err(.MissingScheme);
+        exn.throw(dyn UrlError.MissingScheme);
       },
       true => ()
     );
@@ -138,7 +141,7 @@ impl(Url,
     cond(
       ((((first >= _LOWER_A) && (first <= _LOWER_Z)) || ((first >= _UPPER_A) && (first <= _UPPER_Z)))) => (),
       true => {
-        return .Err(.MissingScheme);
+        exn.throw(dyn UrlError.MissingScheme);
       }
     );
 
@@ -154,14 +157,14 @@ impl(Url,
         },
         (((((first >= _LOWER_A) && (first <= _LOWER_Z)) || ((first >= _UPPER_A) && (first <= _UPPER_Z))) || (((ch >= _LOWER_A) && (ch <= _LOWER_Z)) || ((ch >= _UPPER_A) && (ch <= _UPPER_Z)))) || ((((ch >= _ZERO) && (ch <= _NINE)) || (ch == _PLUS)) || ((ch == _MINUS) || (ch == _DOT)))) => (),
         true => {
-          return .Err(.MissingScheme);
+          exn.throw(dyn UrlError.MissingScheme);
         }
       );
       i = (i + usize(1));
     };
     cond(
       (!(found_colon)) => {
-        return .Err(.MissingScheme);
+        exn.throw(dyn UrlError.MissingScheme);
       },
       true => ()
     );
@@ -261,15 +264,7 @@ impl(Url,
             after_bracket := (bracket_end + usize(1));
             cond(
               ((after_bracket < auth_end) && (s.bytes(after_bracket) == _COLON)) => {
-                port_result := _parse_port(s, (after_bracket + usize(1)), auth_end);
-                cond(
-                  port_result.is_err() => {
-                    return .Err(.InvalidPort);
-                  },
-                  true => {
-                    port = .Some(port_result.unwrap());
-                  }
-                );
+                port = .Some(_parse_port(s, (after_bracket + usize(1)), auth_end));
               },
               true => ()
             );
@@ -300,15 +295,7 @@ impl(Url,
                 };
                 host = .Some(String.from_bytes(host_b));
 
-                port_result := _parse_port(s, (cp_val + usize(1)), auth_end);
-                cond(
-                  port_result.is_err() => {
-                    return .Err(.InvalidPort);
-                  },
-                  true => {
-                    port = .Some(port_result.unwrap());
-                  }
-                );
+                port = .Some(_parse_port(s, (cp_val + usize(1)), auth_end));
               },
               .None => {
                 // No port, entire range is host
@@ -414,12 +401,12 @@ impl(Url,
     // Ensure authority-based URLs have a path starting with "/" or empty
     cond(
       (has_authority && ((!(path_str.is_empty())) && (path_str.as_bytes().get(usize(0)).unwrap() != _SLASH))) => {
-        return .Err(.Other(`authority path must start with '/'`));
+        exn.throw(dyn UrlError.Other(`authority path must start with '/'`));
       },
       true => ()
     );
 
-    .Ok(Self(
+    Self(
       _scheme: scheme,
       _host: host,
       _port: port,
@@ -427,7 +414,7 @@ impl(Url,
       _query: query,
       _fragment: fragment,
       _userinfo: userinfo
-    ))
+    )
   }),
 
   // --- Accessors ---

package/out/types/src/codegen/effects/effect-state-machine.d.ts

@@ -1,34 +0,0 @@
-import type { EffectAnalysisResult } from "../../evaluator/effects/effect-analysis-types";
-import { type Expr } from "../../expr";
-import type { FunctionValue } from "../../function-value";
-import type { FunctionType, Type } from "../../types/definitions";
-import type { FunctionGenerationContext } from "../functions/context";
-export declare function handlerBodyContainsExplicitReturn(expr: Expr): boolean;
-export interface EffectSmTypeInfo {
-    yieldTypeCNames: string[];
-    resumeTypeCName: string;
-}
-export interface EffectStateMachineInfo {
-    structName: string;
-    resumeFunctionName: string;
-    analysis: EffectAnalysisResult;
-    functionType: FunctionType;
-    returnTypeCName: string;
-    yieldTypeCNames: string[];
-    resumeTypeCName: string;
-    effectInfos?: EffectSmTypeInfo[];
-    isClosure?: boolean;
-    closureCaptureTypeCName?: string;
-    closureCapturedVarNames?: Set<string>;
-}
-export declare function generateEffectStateMachineStruct(info: EffectStateMachineInfo, context: FunctionGenerationContext): void;
-export declare function generateEffectResumeFunctionDeclaration(info: EffectStateMachineInfo, context: FunctionGenerationContext): void;
-export declare function generateEffectResumeFunction(bodyExpr: Expr, info: EffectStateMachineInfo, context: FunctionGenerationContext, functionValue?: FunctionValue): void;
-export declare function generateEffectCallSite(info: EffectStateMachineInfo, argCodes: string[], functionType: FunctionType, handlerBody: Expr, handlerType: FunctionType, handlerHasResume: boolean, callerReturnType: Type | undefined, tempVar: string | undefined, indent: string, context: FunctionGenerationContext, closureContextCode?: string): string;
-export interface EffectCallSiteHandler {
-    handlerBody: Expr;
-    handlerType: FunctionType;
-    hasResume: boolean;
-    effectIndex: number;
-}
-export declare function generateMultiEffectCallSite(info: EffectStateMachineInfo, argCodes: string[], functionType: FunctionType, handlers: EffectCallSiteHandler[], tempVar: string | undefined, indent: string, context: FunctionGenerationContext): string;