effect 4.0.0-beta.21 → 4.0.0-beta.22

package/src/internal/effect.ts

@@ -493,40 +493,6 @@ const fiberIdStore = { id: 0 }
 /** @internal */
 export const getCurrentFiber = (): Fiber.Fiber<any, any> | undefined => (globalThis as any)[currentFiberTypeId]
 
-const keepAlive = (() => {
-  let isAvailable: boolean | undefined
-  const start = () => {
-    if (isAvailable === true) return setInterval(constVoid, 2_147_483_647)
-    else if (isAvailable === false) return undefined
-
-    try {
-      const running = setInterval(constVoid, 2_147_483_647)
-      isAvailable = true
-      return running
-    } catch {
-      isAvailable = false
-      return undefined
-    }
-  }
-  let count = 0
-  let running: ReturnType<typeof globalThis.setInterval> | undefined = undefined
-  return ({
-    increment() {
-      count++
-      if (running === undefined) {
-        running = start()
-      }
-    },
-    decrement() {
-      count--
-      if (count === 0 && running !== undefined) {
-        clearInterval(running)
-        running = undefined
-      }
-    }
-  })
-})()
-
 /** @internal */
 export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   constructor(
@@ -1056,10 +1022,8 @@ const callbackOptions: <A, E = never, R = never>(
     }, controller?.signal)
     if (yielded !== false) return yielded
     yielded = true
-    keepAlive.increment()
     fiber._yielded = () => {
       resumed = true
-      keepAlive.decrement()
     }
     if (controller === undefined && onCancel === undefined) {
       return Yield
@@ -1133,7 +1097,7 @@ export const fnUntraced: Effect.fn.Untraced = (
   body: Function,
   ...pipeables: Array<any>
 ) => {
-  return pipeables.length === 0
+  const fn = pipeables.length === 0
     ? function(this: any) {
       return suspend(() => fromIteratorUnsafe(body.apply(this, arguments)))
     }
@@ -1144,8 +1108,15 @@ export const fnUntraced: Effect.fn.Untraced = (
       }
       return effect
     }
+  return defineFunctionLength(body.length, fn)
 }
 
+const defineFunctionLength = <F extends Function>(length: number, fn: F): F =>
+  Object.defineProperty(fn, "length", {
+    value: length,
+    configurable: true
+  })
+
 const fnStackCleaner = makeStackCleaner(2)
 
 /** @internal */
@@ -1186,7 +1157,7 @@ const makeFn = (
     ? bodyOrOptions
     : (pipeables.pop()!).bind(bodyOrOptions.self)
 
-  return function(this: any, ...args: Array<any>) {
+  return defineFunctionLength(body.length, function(this: any, ...args: Array<any>) {
     let result = suspend(() => {
       const iter = body.apply(this, arguments)
       return isEffect(iter) ? iter : fromIteratorUnsafe(iter)
@@ -1216,7 +1187,7 @@ const makeFn = (
         }
       })
     )
-  }
+  })
 }
 
 /** @internal */
@@ -1224,17 +1195,20 @@ export const fnUntracedEager: Effect.fn.Untraced = (
   body: Function,
   ...pipeables: Array<any>
 ) =>
-  pipeables.length === 0
-    ? function(this: any) {
-      return fromIteratorEagerUnsafe(() => body.apply(this, arguments))
-    }
-    : function(this: any) {
-      let effect = fromIteratorEagerUnsafe(() => body.apply(this, arguments))
-      for (const pipeable of pipeables) {
-        effect = pipeable(effect)
+  defineFunctionLength(
+    body.length,
+    pipeables.length === 0
+      ? function(this: any) {
+        return fromIteratorEagerUnsafe(() => body.apply(this, arguments))
       }
-      return effect
-    }
+      : function(this: any) {
+        let effect = fromIteratorEagerUnsafe(() => body.apply(this, arguments))
+        for (const pipeable of pipeables) {
+          effect = pipeable(effect)
+        }
+        return effect
+      }
+  )
 
 const fromIteratorEagerUnsafe = (
   evaluate: () => Iterator<Effect.Yieldable<any, any, any, any>>
@@ -4334,17 +4308,17 @@ const findFirstLoop = <A, E, R>(
 /** @internal */
 export const findFirstFilter: {
   <A, B, X, E, R>(
-    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R, [i: number]>
+    filter: (input: NoInfer<A>, i: number) => Effect.Effect<Result.Result<B, X>, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<Option.Option<B>, E, R>
   <A, B, X, E, R>(
     elements: Iterable<A>,
-    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R, [i: number]>
+    filter: (input: NoInfer<A>, i: number) => Effect.Effect<Result.Result<B, X>, E, R>
   ): Effect.Effect<Option.Option<B>, E, R>
 } = dual(
   (args) => isIterable(args[0]) && !isEffect(args[0]),
   <A, B, X, E, R>(
     elements: Iterable<A>,
-    filter: Filter.FilterEffect<A, B, X, E, R, [i: number]>
+    filter: (input: A, i: number) => Effect.Effect<Result.Result<B, X>, E, R>
   ): Effect.Effect<Option.Option<B>, E, R> =>
     suspend(() => {
       const iterator = elements[Symbol.iterator]()
@@ -4359,7 +4333,7 @@ export const findFirstFilter: {
 const findFirstFilterLoop = <A, B, X, E, R>(
   iterator: Iterator<A>,
   index: number,
-  filter: Filter.FilterEffect<A, B, X, E, R, [i: number]>,
+  filter: (input: A, i: number) => Effect.Effect<Result.Result<B, X>, E, R>,
   value: A
 ): Effect.Effect<Option.Option<B>, E, R> =>
   flatMap(filter(value, index), (result) => {

package/src/internal/hashMap.ts

@@ -3,7 +3,6 @@
  */
 
 import * as Equal_ from "../Equal.ts"
-import type * as Filter from "../Filter.ts"
 import { format } from "../Formatter.ts"
 import { dual, pipe } from "../Function.ts"
 import * as Hash from "../Hash.ts"
@@ -1257,9 +1256,9 @@ export const compact = <K, A>(self: HashMap<K, Option.Option<A>>): HashMap<K, A>
 
 /** @internal */
 export const filterMap = dual<
-  <A, K, B, X>(f: Filter.Filter<A, B, X, [key: K]>) => (self: HashMap<K, A>) => HashMap<K, B>,
-  <K, A, B, X>(self: HashMap<K, A>, f: Filter.Filter<A, B, X, [key: K]>) => HashMap<K, B>
->(2, <K, A, B, X>(self: HashMap<K, A>, f: Filter.Filter<A, B, X, [key: K]>): HashMap<K, B> => {
+  <A, K, B, X>(f: (input: A, key: K) => Result.Result<B, X>) => (self: HashMap<K, A>) => HashMap<K, B>,
+  <K, A, B, X>(self: HashMap<K, A>, f: (input: A, key: K) => Result.Result<B, X>) => HashMap<K, B>
+>(2, <K, A, B, X>(self: HashMap<K, A>, f: (input: A, key: K) => Result.Result<B, X>): HashMap<K, B> => {
   let result = empty<K, B>()
   for (const [key, value] of self) {
     const mapped = f(value, key)

package/src/internal/trie.ts

@@ -1,5 +1,4 @@
 import * as Equal from "../Equal.ts"
-import type * as Filter from "../Filter.ts"
 import { format } from "../Formatter.ts"
 import { dual, pipe } from "../Function.ts"
 import * as Hash from "../Hash.ts"
@@ -312,10 +311,10 @@ export const filter: {
 /** @internal */
 export const filterMap = dual<
   <A, B, X>(
-    f: Filter.Filter<A, B, X, [key: string]>
+    f: (input: A, key: string) => Result.Result<B, X>
   ) => (self: TR.Trie<A>) => TR.Trie<B>,
-  <A, B, X>(self: TR.Trie<A>, f: Filter.Filter<A, B, X, [key: string]>) => TR.Trie<B>
->(2, <A, B, X>(self: TR.Trie<A>, f: Filter.Filter<A, B, X, [key: string]>): TR.Trie<B> =>
+  <A, B, X>(self: TR.Trie<A>, f: (input: A, key: string) => Result.Result<B, X>) => TR.Trie<B>
+>(2, <A, B, X>(self: TR.Trie<A>, f: (input: A, key: string) => Result.Result<B, X>): TR.Trie<B> =>
   reduce(
     self,
     empty<B>(),

package/src/unstable/ai/Chat.ts

@@ -296,42 +296,8 @@ const encodeHistoryJson = Schema.encodeUnknownEffect(Schema.fromJsonString(Promp
 // Constructors
 // =============================================================================
 
-/**
- * Creates a new Chat service with empty conversation history.
- *
- * This is the most common way to start a fresh chat session without
- * any initial context or system prompts.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- * import { Chat } from "effect/unstable/ai"
- *
- * const freshChat = Effect.gen(function*() {
- *   const chat = yield* Chat.empty
- *
- *   const response = yield* chat.generateText({
- *     prompt: "Hello! Can you introduce yourself?"
- *   })
- *
- *   console.log(response.content)
- *
- *   return chat
- * })
- * ```
- *
- * @since 4.0.0
- * @category constructors
- */
-export const empty: Effect.Effect<Service> = Effect.gen(function*() {
-  const history = yield* Ref.make(Prompt.empty)
-  const services = yield* Effect.services<never>()
-  const semaphore = yield* Semaphore.make(1)
-
-  const provideContext = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-    Effect.updateServices(effect, (existing) => ServiceMap.merge(services, existing))
-  const provideContextStream = <A, E, R>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
-    Stream.updateServices(stream, (existing) => ServiceMap.merge(services, existing))
+const makeUnsafe = (history: Ref.Ref<Prompt.Prompt>) => {
+  const semaphore = Semaphore.makeUnsafe(1)
 
   return Chat.of({
     history,
@@ -368,7 +334,6 @@ export const empty: Effect.Effect<Service> = Effect.gen(function*() {
 
         return response
       },
-      provideContext,
       semaphore.withPermits(1),
       (effect) => Effect.withSpan(effect, "Chat.generateText", { captureStackTrace: false })
     ),
@@ -397,7 +362,6 @@ export const empty: Effect.Effect<Service> = Effect.gen(function*() {
               semaphore.release(1)
             )
         )).pipe(
-          provideContextStream,
           Stream.withSpan("Chat.streamText", {
             captureStackTrace: false
           })
@@ -418,7 +382,6 @@ export const empty: Effect.Effect<Service> = Effect.gen(function*() {
 
         return response
       },
-      provideContext,
       semaphore.withPermits(1),
       (effect, options) =>
         Effect.withSpan(effect, "Chat.generateObject", {
@@ -429,7 +392,36 @@ export const empty: Effect.Effect<Service> = Effect.gen(function*() {
         })
     )
   })
-})
+}
+
+/**
+ * Creates a new Chat service with empty conversation history.
+ *
+ * This is the most common way to start a fresh chat session without
+ * any initial context or system prompts.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Chat } from "effect/unstable/ai"
+ *
+ * const freshChat = Effect.gen(function*() {
+ *   const chat = yield* Chat.empty
+ *
+ *   const response = yield* chat.generateText({
+ *     prompt: "Hello! Can you introduce yourself?"
+ *   })
+ *
+ *   console.log(response.content)
+ *
+ *   return chat
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category constructors
+ */
+export const empty: Effect.Effect<Service> = Effect.sync(() => makeUnsafe(Ref.makeUnsafe(Prompt.empty)))
 
 /**
  * Creates a new Chat service from an initial prompt.
@@ -489,13 +481,8 @@ export const empty: Effect.Effect<Service> = Effect.gen(function*() {
  * @since 4.0.0
  * @category constructors
  */
-export const fromPrompt = Effect.fnUntraced(
-  function*(prompt: Prompt.RawInput) {
-    const chat = yield* empty
-    yield* Ref.set(chat.history, Prompt.make(prompt))
-    return chat
-  }
-)
+export const fromPrompt = (prompt: Prompt.RawInput) =>
+  Effect.sync(() => makeUnsafe(Ref.makeUnsafe(Prompt.make(prompt))))
 
 /**
  * Creates a Chat service from previously exported chat data.
@@ -534,8 +521,7 @@ export const fromPrompt = Effect.fnUntraced(
  */
 export const fromExport = (data: unknown): Effect.Effect<
   Service,
-  Schema.SchemaError,
-  LanguageModel.LanguageModel
+  Schema.SchemaError
 > => Effect.flatMap(decodeHistory(data), fromPrompt)
 
 /**
@@ -576,8 +562,7 @@ export const fromExport = (data: unknown): Effect.Effect<
  */
 export const fromJson = (data: string): Effect.Effect<
   Service,
-  Schema.SchemaError,
-  LanguageModel.LanguageModel
+  Schema.SchemaError
 > => Effect.flatMap(decodeHistoryJson(data), fromPrompt)
 
 // =============================================================================

package/src/unstable/ai/LanguageModel.ts

@@ -1236,7 +1236,6 @@ export const make: (params: ConstructorParams) => Effect.Effect<Service> = Effec
     const queue = yield* Queue.make<
       Response.StreamPart<Tools>,
       | AiError.AiError
-      | AiError.AiErrorReason
       | Cause.Done
       | Schema.SchemaError
     >()

package/src/unstable/ai/Tool.ts

@@ -952,7 +952,7 @@ export type HandlerError<T> = T extends Tool<
   infer _Name,
   infer _Config,
   infer _Requirements
-> ? _Config["failureMode"] extends "error" ? _Config["failure"]["Type"] | AiError.AiError | AiError.AiErrorReason
+> ? _Config["failureMode"] extends "error" ? _Config["failure"]["Type"] | AiError.AiError
   : never
   : never
 

package/src/unstable/httpapi/HttpApiClient.ts

@@ -120,6 +120,44 @@ export declare namespace Client {
       never
 }
 
+type ApiGroups<Api extends HttpApi.Any> = Api extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? Groups : never
+
+type EndpointId<Endpoint extends HttpApiEndpoint.Any> = Endpoint extends {
+  readonly method: infer Method extends HttpMethod.HttpMethod
+  readonly path: infer Path extends string
+} ? `${Method} ${Path}`
+  : never
+
+type EndpointWithId<Endpoints extends HttpApiEndpoint.Any, Id extends string> = Id extends
+  `${infer Method extends HttpMethod.HttpMethod} ${infer Path extends string}` ?
+  Extract<Endpoints, { readonly method: Method; readonly path: Path }> :
+  never
+
+type UrlBuilderRequest<Endpoint extends HttpApiEndpoint.Any> = (
+  & ([HttpApiEndpoint.Params<Endpoint>["Encoded"]] extends [never] ? {}
+    : { readonly params: HttpApiEndpoint.Params<Endpoint>["Encoded"] })
+  & ([HttpApiEndpoint.Query<Endpoint>["Encoded"]] extends [never] ? {}
+    : { readonly query: HttpApiEndpoint.Query<Endpoint>["Encoded"] })
+) extends infer Request ? keyof Request extends never ? void | undefined : Request
+  : never
+
+type UrlBuilderArgs<Endpoint extends HttpApiEndpoint.Any> = [UrlBuilderRequest<Endpoint>] extends [void | undefined] ?
+  [request?: UrlBuilderRequest<Endpoint>]
+  : [request: UrlBuilderRequest<Endpoint>]
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type UrlBuilder<Api extends HttpApi.Any> = <
+  const GroupName extends HttpApiGroup.Name<ApiGroups<Api>>,
+  const Id extends EndpointId<HttpApiGroup.EndpointsWithName<ApiGroups<Api>, GroupName>>
+>(
+  group: GroupName,
+  endpoint: Id,
+  ...args: UrlBuilderArgs<EndpointWithId<HttpApiGroup.EndpointsWithName<ApiGroups<Api>, GroupName>, Id>>
+) => string
+
 const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>(
   api: HttpApi.HttpApi<ApiId, Groups>,
   options: {
@@ -438,6 +476,49 @@ export const endpoint = <
   }).pipe(Effect.map(() => client)) as any
 }
 
+/**
+ * Creates a type-safe URL builder keyed by `${method} ${path}`.
+ *
+ * @example
+ * ```ts
+ * import { Schema } from "effect"
+ * import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi"
+ *
+ * const Api = HttpApi.make("Api").add(
+ *   HttpApiGroup.make("users").add(
+ *     HttpApiEndpoint.get("getUser", "/users/:id", {
+ *       params: { id: Schema.String }
+ *     })
+ *   )
+ * )
+ *
+ * const buildUrl = HttpApiClient.urlBuilder<typeof Api>({
+ *   baseUrl: "https://api.example.com"
+ * })
+ *
+ * buildUrl("users", "GET /users/:id", {
+ *   params: { id: "123" }
+ * })
+ * //=> "https://api.example.com/users/123"
+ * ```
+ * @since 4.0.0
+ * @category constructors
+ */
+export const urlBuilder = <Api extends HttpApi.Any>(options?: {
+  readonly baseUrl?: URL | string | undefined
+}): UrlBuilder<Api> => {
+  return ((_: string, endpoint: string, request?: {
+    readonly params?: Record<string, string | undefined> | undefined
+    readonly query?: UrlParams.Input | undefined
+  }) => {
+    const path = endpoint.slice(endpoint.indexOf(" ") + 1)
+    const withParams = request?.params === undefined ? path : compilePath(path)(request.params)
+    const query = request?.query === undefined ? "" : UrlParams.toString(UrlParams.fromInput(request.query))
+    const url = query === "" ? withParams : `${withParams}?${query}`
+    return options?.baseUrl === undefined ? url : new URL(url, options.baseUrl.toString()).toString()
+  }) as UrlBuilder<Api>
+}
+
 // ----------------------------------------------------------------------------
 
 const paramsRegExp = /:(\w+)\??/g
@@ -448,7 +529,7 @@ const compilePath = (path: string) => {
   if (len === 1) {
     return (_: any) => path
   }
-  return (params: Record<string, string>) => {
+  return (params: Record<string, string | undefined>) => {
     let url = segments[0]
     for (let i = 1; i < len; i++) {
       if (i % 2 === 0) {

package/src/unstable/schema/VariantSchema.ts

@@ -17,7 +17,7 @@ import * as Struct_ from "../../Struct.ts"
  * @since 4.0.0
  * @category Type IDs
  */
-export const TypeId = "~effect/unstable/schema/VariantSchema"
+export const TypeId = "~effect/schema/VariantSchema"
 
 const cacheSymbol = Symbol.for(`${TypeId}/cache`)
 
@@ -71,7 +71,7 @@ export declare namespace Struct {
   }
 }
 
-const FieldTypeId = "~effect/unstable/schema/VariantSchema/Field"
+const FieldTypeId = "~effect/schema/VariantSchema/Field"
 
 /**
  * @since 4.0.0
@@ -542,7 +542,7 @@ const Union = <Members extends ReadonlyArray<Struct<any>>, Variants extends Read
   members: Members,
   variants: Variants
 ) => {
-  class VariantUnion extends (Schema.Union(members.filter((member) => Schema.isSchema(member))) as any) {}
+  const VariantUnion = Schema.Union(members.filter((member) => Schema.isSchema(member))) as any
   for (const variant of variants) {
     Object.defineProperty(VariantUnion, variant, {
       value: Schema.Union(members.map((member) => extract(member, variant)))