effect 4.0.0-beta.17 → 4.0.0-beta.19

package/src/internal/hashMap.ts

@@ -3,6 +3,7 @@
  */
 
 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"
@@ -12,6 +13,7 @@ import * as Option from "../Option.ts"
 import type { Pipeable } from "../Pipeable.ts"
 import { pipeArguments } from "../Pipeable.ts"
 import { hasProperty } from "../Predicate.ts"
+import * as Result from "../Result.ts"
 import type { NoInfer } from "../Types.ts"
 
 /** @internal */
@@ -1255,14 +1257,14 @@ export const compact = <K, A>(self: HashMap<K, Option.Option<A>>): HashMap<K, A>
 
 /** @internal */
 export const filterMap = dual<
-  <A, K, B>(f: (value: A, key: K) => Option.Option<B>) => (self: HashMap<K, A>) => HashMap<K, B>,
-  <K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => Option.Option<B>) => HashMap<K, B>
->(2, <K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => Option.Option<B>): HashMap<K, B> => {
+  <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> => {
   let result = empty<K, B>()
   for (const [key, value] of self) {
     const mapped = f(value, key)
-    if (Option.isSome(mapped)) {
-      result = set(result, key, mapped.value)
+    if (Result.isSuccess(mapped)) {
+      result = set(result, key, mapped.success)
     }
   }
   return result

package/src/internal/trie.ts

@@ -1,12 +1,14 @@
 import * as Equal from "../Equal.ts"
+import type * as Filter from "../Filter.ts"
 import { format } from "../Formatter.ts"
-import { dual, identity, pipe } from "../Function.ts"
+import { dual, pipe } from "../Function.ts"
 import * as Hash from "../Hash.ts"
 import { NodeInspectSymbol, toJson } from "../Inspectable.ts"
 import * as Option from "../Option.ts"
 import type * as Ordering from "../Ordering.ts"
 import { pipeArguments } from "../Pipeable.ts"
 import { hasProperty } from "../Predicate.ts"
+import * as Result from "../Result.ts"
 import type * as TR from "../Trie.ts"
 import type { NoInfer } from "../Types.ts"
 
@@ -309,22 +311,27 @@ export const filter: {
 
 /** @internal */
 export const filterMap = dual<
-  <A, B>(
-    f: (value: A, key: string) => Option.Option<B>
+  <A, B, X>(
+    f: Filter.Filter<A, B, X, [key: string]>
   ) => (self: TR.Trie<A>) => TR.Trie<B>,
-  <A, B>(self: TR.Trie<A>, f: (value: A, key: string) => Option.Option<B>) => TR.Trie<B>
->(2, (self, f) =>
+  <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> =>
   reduce(
     self,
-    empty(),
+    empty<B>(),
     (trie, value, key) => {
-      const option = f(value, key)
-      return Option.isSome(option) ? insert(trie, key, option.value) : trie
+      const result = f(value, key)
+      return Result.isSuccess(result) ? insert(trie, key, result.success) : trie
     }
   ))
 
 /** @internal */
-export const compact = <A>(self: TR.Trie<Option.Option<A>>) => filterMap(self, identity)
+export const compact = <A>(self: TR.Trie<Option.Option<A>>) =>
+  reduce(
+    self,
+    empty<A>(),
+    (trie, option, key) => Option.isSome(option) ? insert(trie, key, option.value) : trie
+  )
 
 /** @internal */
 export const forEach = dual<

package/src/unstable/ai/Tool.ts

@@ -1622,15 +1622,6 @@ export const getJsonSchema = <Tool extends Any>(tool: Tool, options?: {
 export const getJsonSchemaFromSchema = <S extends Schema.Top>(schema: S, options?: {
   readonly transformer?: CodecTransformer
 }): JsonSchema.JsonSchema => {
-  const props = AST.isObjects(schema.ast) ? schema.ast.propertySignatures : []
-  if (props.length === 0) {
-    return {
-      type: "object",
-      properties: {},
-      required: [],
-      additionalProperties: false
-    }
-  }
   if (Predicate.isNotUndefined(options?.transformer)) {
     return options.transformer(schema).jsonSchema
   }

package/src/unstable/cli/Command.ts

@@ -994,8 +994,10 @@ export const withGlobalFlags: {
 )
 
 // Type extractors for subcommand arrays - T[number] gives union of all elements
-type ExtractGlobalFlagContext<T extends ReadonlyArray<GlobalFlag.GlobalFlag<any>>> = T[number] extends
-  GlobalFlag.Setting<infer Id, any> ? GlobalFlag.Setting.Identifier<Id> : never
+type ExtractGlobalFlagContext<T extends ReadonlyArray<GlobalFlag.GlobalFlag<any>>> = T[number] extends infer F
+  ? F extends GlobalFlag.Setting<infer Id, any> ? GlobalFlag.Setting.Identifier<Id>
+  : never
+  : never
 type ExtractSubcommand<T> = T extends Command<any, any, any, any> ? T
   : T extends Command.SubcommandGroup<infer Commands> ? Commands[number]
   : never
@@ -1847,14 +1849,14 @@ export const runWith = <const Name extends string, Input, E, R>(
       // 9. Run command handler with composed context
       yield* Effect.provideServices(program, services)
     },
-    Effect.catchIf(
+    Effect.catchFilter(
       ((error: any) =>
         CliError.isCliError(error) && error._tag === "ShowHelp"
           ? Result.succeed(error)
           : Result.fail(error)) as any,
       (error: any) => showHelp(command, error.commandPath)
     ),
-    Effect.catchIf(
+    Effect.catchFilter(
       (e) =>
         Terminal.isQuitError(e)
           ? Result.succeed(e)

package/src/unstable/cluster/K8sHttpClient.ts

@@ -121,7 +121,7 @@ export const makeCreatePod = Effect.gen(function*() {
         while: (e) => e._tag === "SchemaError",
         schedule: Schedule.spaced("1 seconds")
       }),
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 404
@@ -133,7 +133,7 @@ export const makeCreatePod = Effect.gen(function*() {
     )
     const isPodFound = readPodRaw.pipe(
       Effect.as(true),
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 404
@@ -145,7 +145,7 @@ export const makeCreatePod = Effect.gen(function*() {
     const createPod = HttpClientRequest.post(`/v1/namespaces/${namespace}/pods`).pipe(
       HttpClientRequest.bodyJsonUnsafe(spec),
       client.execute,
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 409
@@ -159,7 +159,7 @@ export const makeCreatePod = Effect.gen(function*() {
     const deletePod = HttpClientRequest.delete(`/v1/namespaces/${namespace}/pods/${name}`).pipe(
       client.execute,
       Effect.flatMap((res) => res.json),
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 404

package/src/unstable/cluster/Sharding.ts

@@ -812,7 +812,7 @@ const make = Effect.gen(function*() {
     void,
     MailboxFull | AlreadyProcessingMessage | PersistenceError
   > {
-    return Effect.catchIf(
+    return Effect.catchFilter(
       Effect.suspend(() => {
         const address = message.envelope.address
         const isPersisted = ServiceMap.get(message.rpc.annotations, Persisted)

package/src/unstable/encoding/Sse.ts

@@ -311,7 +311,7 @@ export const encode = <IE, Done>(): Channel.Channel<
       let done = false
       const pull = upstream.pipe(
         Effect.map(Arr.map(encoder.write)),
-        Effect.catchIf(Retry.filter as any, (retry: any) => {
+        Effect.catchFilter(Retry.filter as any, (retry: any) => {
           done = true
           return Effect.succeed(Arr.of(encoder.write(retry)))
         }),

package/src/unstable/rpc/RpcServer.ts

@@ -15,7 +15,6 @@ import type * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Pull from "../../Pull.ts"
 import * as Queue from "../../Queue.ts"
-import * as Result from "../../Result.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
@@ -1362,12 +1361,7 @@ const makeSocketProtocol: Effect.Effect<
         return writeRaw(parser.encode(ResponseDefectEncoded(cause))!)
       }
     }).pipe(
-      Effect.catchIf(
-        ((
-          error: any
-        ) => (error.reason._tag === "SocketCloseError" ? Result.succeed(error.reason) : Result.fail(error))) as any,
-        (_: any) => Effect.void
-      ),
+      Effect.catchReason("SocketError", "SocketCloseError", (_) => Effect.void),
       Effect.orDie
     )
   }

package/src/unstable/socket/Socket.ts

@@ -281,7 +281,7 @@ export const toChannelMap = <IE, A>(
         return writeChunk
       }),
       Effect.forever({ disableYield: true }),
-      Effect.catchCauseIf(
+      Effect.catchCauseFilter(
         Pull.filterNoDone,
         (cause) => Queue.failCause(queue, cause)
       ),
@@ -545,11 +545,10 @@ export const fromWebSocket = <RO>(
         currentWS = ws
         latch.openUnsafe()
         if (opts?.onOpen) yield* opts.onOpen
-        return yield* FiberSet.join(fiberSet).pipe(
-          Effect.catchIf(
-            SocketCloseError.filterClean((_) => !closeCodeIsError(_)) as any,
-            (_: any) => Effect.void
-          )
+        return yield* Effect.catchFilter(
+          FiberSet.join(fiberSet),
+          SocketCloseError.filterClean((_) => !closeCodeIsError(_)),
+          () => Effect.void
         )
       })).pipe(
         Effect.updateServices((input: ServiceMap.ServiceMap<R>) => ServiceMap.merge(acquireContext, input)),
@@ -693,11 +692,10 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
         yield* latch.open
         if (opts?.onOpen) yield* opts.onOpen
 
-        return yield* FiberSet.join(fiberSet).pipe(
-          Effect.catchIf(
-            SocketCloseError.filterClean((_) => !closeCodeIsError(_)) as any,
-            (_: any) => Effect.void
-          )
+        return yield* Effect.catchFilter(
+          FiberSet.join(fiberSet),
+          SocketCloseError.filterClean((_) => !closeCodeIsError(_)),
+          () => Effect.void
         )
       })).pipe(
         (_) => _,