effect 3.0.2 → 3.0.4

package/src/internal/matcher.ts

@@ -26,7 +26,8 @@ const TypeMatcherProto: Omit<TypeMatcher<any, any, any, any>, "cases"> = {
     _input: identity,
     _filters: identity,
     _remaining: identity,
-    _result: identity
+    _result: identity,
+    _return: identity
   },
   _tag: "TypeMatcher",
   add<I, R, RA, A>(
@@ -55,7 +56,8 @@ const ValueMatcherProto: Omit<
   [TypeId]: {
     _input: identity,
     _filters: identity,
-    _result: identity
+    _result: identity,
+    _return: identity
   },
   _tag: "ValueMatcher",
   add<I, R, RA, A, Pr>(
@@ -217,7 +219,7 @@ export const valueTags = <
 >(
   fields: P
 ) => {
-  const match: any = tagsExhaustive(fields)(makeTypeMatcher([]))
+  const match: any = tagsExhaustive(fields as any)(makeTypeMatcher([]))
   return (input: I): Unify<ReturnType<P[keyof P]>> => match(input)
 }
 
@@ -232,27 +234,36 @@ export const typeTags = <I>() =>
 >(
   fields: P
 ) => {
-  const match: any = tagsExhaustive(fields)(makeTypeMatcher([]))
+  const match: any = tagsExhaustive(fields as any)(makeTypeMatcher([]))
   return (input: I): Unify<ReturnType<P[keyof P]>> => match(input)
 }
 
+/** @internal */
+export const withReturnType =
+  <Ret>() =>
+  <I, F, R, A, Pr, _>(self: Matcher<I, F, R, A, Pr, _>): Ret extends ([A] extends [never] ? any
+    : A) ? Matcher<I, F, R, A, Pr, Ret>
+    : "withReturnType constraint does not extend Result type" => self as any
+
 /** @internal */
 export const when = <
   R,
   const P extends Types.PatternPrimitive<R> | Types.PatternBase<R>,
-  Fn extends (_: Types.WhenMatch<R, P>) => unknown
+  Ret,
+  Fn extends (_: Types.WhenMatch<R, P>) => Ret
 >(
   pattern: P,
   f: Fn
 ) =>
 <I, F, A, Pr>(
-  self: Matcher<I, F, R, A, Pr>
+  self: Matcher<I, F, R, A, Pr, Ret>
 ): Matcher<
   I,
   Types.AddWithout<F, Types.PForExclude<P>>,
   Types.ApplyFilters<I, Types.AddWithout<F, Types.PForExclude<P>>>,
   A | ReturnType<Fn>,
-  Pr
+  Pr,
+  Ret
 > => (self as any).add(makeWhen(makePredicate(pattern), f as any))
 
 /** @internal */
@@ -261,18 +272,20 @@ export const whenOr = <
   const P extends ReadonlyArray<
     Types.PatternPrimitive<R> | Types.PatternBase<R>
   >,
-  Fn extends (_: Types.WhenMatch<R, P[number]>) => unknown
+  Ret,
+  Fn extends (_: Types.WhenMatch<R, P[number]>) => Ret
 >(
   ...args: [...patterns: P, f: Fn]
 ) =>
 <I, F, A, Pr>(
-  self: Matcher<I, F, R, A, Pr>
+  self: Matcher<I, F, R, A, Pr, Ret>
 ): Matcher<
   I,
   Types.AddWithout<F, Types.PForExclude<P[number]>>,
   Types.ApplyFilters<I, Types.AddWithout<F, Types.PForExclude<P[number]>>>,
   A | ReturnType<Fn>,
-  Pr
+  Pr,
+  Ret
 > => {
   const onMatch = args[args.length - 1] as any
   const patterns = args.slice(0, -1) as unknown as P
@@ -285,12 +298,13 @@ export const whenAnd = <
   const P extends ReadonlyArray<
     Types.PatternPrimitive<R> | Types.PatternBase<R>
   >,
-  Fn extends (_: Types.WhenMatch<R, Types.ArrayToIntersection<P>>) => unknown
+  Ret,
+  Fn extends (_: Types.WhenMatch<R, Types.ArrayToIntersection<P>>) => Ret
 >(
   ...args: [...patterns: P, f: Fn]
 ) =>
 <I, F, A, Pr>(
-  self: Matcher<I, F, R, A, Pr>
+  self: Matcher<I, F, R, A, Pr, Ret>
 ): Matcher<
   I,
   Types.AddWithout<F, Types.PForExclude<Types.ArrayToIntersection<P>>>,
@@ -307,41 +321,43 @@ export const whenAnd = <
 }
 
 /** @internal */
-export const discriminator = <D extends string>(field: D) =>
-<R, P extends Types.Tags<D, R> & string, B>(
-  ...pattern: [
-    first: P,
-    ...values: Array<P>,
-    f: (_: Extract<R, Record<D, P>>) => B
-  ]
-) => {
-  const f = pattern[pattern.length - 1]
-  const values: Array<P> = pattern.slice(0, -1) as any
-  const pred = values.length === 1
-    ? (_: any) => _[field] === values[0]
-    : (_: any) => values.includes(_[field])
-
-  return <I, F, A, Pr>(
-    self: Matcher<I, F, R, A, Pr>
-  ): Matcher<
-    I,
-    Types.AddWithout<F, Extract<R, Record<D, P>>>,
-    Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<D, P>>>>,
-    A | B,
-    Pr
-  > => (self as any).add(makeWhen(pred, f as any)) as any
-}
+export const discriminator =
+  <D extends string>(field: D) =>
+  <R, P extends Types.Tags<D, R> & string, Ret, B extends Ret>(
+    ...pattern: [
+      first: P,
+      ...values: Array<P>,
+      f: (_: Extract<R, Record<D, P>>) => B
+    ]
+  ) => {
+    const f = pattern[pattern.length - 1]
+    const values: Array<P> = pattern.slice(0, -1) as any
+    const pred = values.length === 1
+      ? (_: any) => _[field] === values[0]
+      : (_: any) => values.includes(_[field])
+
+    return <I, F, A, Pr>(
+      self: Matcher<I, F, R, A, Pr, Ret>
+    ): Matcher<
+      I,
+      Types.AddWithout<F, Extract<R, Record<D, P>>>,
+      Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<D, P>>>>,
+      A | B,
+      Pr,
+      Ret
+    > => (self as any).add(makeWhen(pred, f as any)) as any
+  }
 
 /** @internal */
 export const discriminatorStartsWith = <D extends string>(field: D) =>
-<R, P extends string, B>(
+<R, P extends string, Ret, B extends Ret>(
   pattern: P,
   f: (_: Extract<R, Record<D, `${P}${string}`>>) => B
 ) => {
   const pred = (_: any) => typeof _[field] === "string" && _[field].startsWith(pattern)
 
   return <I, F, A, Pr>(
-    self: Matcher<I, F, R, A, Pr>
+    self: Matcher<I, F, R, A, Pr, Ret>
   ): Matcher<
     I,
     Types.AddWithout<F, Extract<R, Record<D, `${P}${string}`>>>,
@@ -350,7 +366,8 @@ export const discriminatorStartsWith = <D extends string>(field: D) =>
       Types.AddWithout<F, Extract<R, Record<D, `${P}${string}`>>>
     >,
     A | B,
-    Pr
+    Pr,
+    Ret
   > => (self as any).add(makeWhen(pred, f as any)) as any
 }
 
@@ -358,11 +375,14 @@ export const discriminatorStartsWith = <D extends string>(field: D) =>
 export const discriminators = <D extends string>(field: D) =>
 <
   R,
-  P extends {
-    readonly [Tag in Types.Tags<D, R> & string]?: (
-      _: Extract<R, Record<D, Tag>>
-    ) => any
-  }
+  Ret,
+  P extends
+    & {
+      readonly [Tag in Types.Tags<D, R> & string]?:
+        | ((_: Extract<R, Record<D, Tag>>) => Ret)
+        | undefined
+    }
+    & { readonly [Tag in Exclude<keyof P, Types.Tags<D, R>>]: never }
 >(
   fields: P
 ) => {
@@ -372,13 +392,14 @@ export const discriminators = <D extends string>(field: D) =>
   )
 
   return <I, F, A, Pr>(
-    self: Matcher<I, F, R, A, Pr>
+    self: Matcher<I, F, R, A, Pr, Ret>
   ): Matcher<
     I,
     Types.AddWithout<F, Extract<R, Record<D, keyof P>>>,
     Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<D, keyof P>>>>,
     A | ReturnType<P[keyof P] & {}>,
-    Pr
+    Pr,
+    Ret
   > => (self as any).add(predicate)
 }
 
@@ -387,15 +408,18 @@ export const discriminatorsExhaustive: <D extends string>(
   field: D
 ) => <
   R,
-  P extends {
-    readonly [Tag in Types.Tags<D, R> & string]: (
-      _: Extract<R, Record<D, Tag>>
-    ) => any
-  }
+  Ret,
+  P extends
+    & {
+      readonly [Tag in Types.Tags<D, R> & string]: (
+        _: Extract<R, Record<D, Tag>>
+      ) => Ret
+    }
+    & { readonly [Tag in Exclude<keyof P, Types.Tags<D, R>>]: never }
 >(
   fields: P
 ) => <I, F, A, Pr>(
-  self: Matcher<I, F, R, A, Pr>
+  self: Matcher<I, F, R, A, Pr, Ret>
 ) => [Pr] extends [never] ? (u: I) => Unify<A | ReturnType<P[keyof P]>>
   : Unify<A | ReturnType<P[keyof P]>> = (field: string) => (fields: object) => {
     const addCases = discriminators(field)(fields)
@@ -403,20 +427,21 @@ export const discriminatorsExhaustive: <D extends string>(
   }
 
 /** @internal */
-export const tag: <R, P extends Types.Tags<"_tag", R> & string, B>(
+export const tag: <R, P extends Types.Tags<"_tag", R> & string, Ret, B extends Ret>(
   ...pattern: [
     first: P,
     ...values: Array<P>,
     f: (_: Extract<R, Record<"_tag", P>>) => B
   ]
 ) => <I, F, A, Pr>(
-  self: Matcher<I, F, R, A, Pr>
+  self: Matcher<I, F, R, A, Pr, Ret>
 ) => Matcher<
   I,
   Types.AddWithout<F, Extract<R, Record<"_tag", P>>>,
   Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<"_tag", P>>>>,
   B | A,
-  Pr
+  Pr,
+  Ret
 > = discriminator("_tag")
 
 /** @internal */
@@ -432,19 +457,21 @@ export const tagsExhaustive = discriminatorsExhaustive("_tag")
 export const not = <
   R,
   const P extends Types.PatternPrimitive<R> | Types.PatternBase<R>,
-  Fn extends (_: Types.NotMatch<R, P>) => unknown
+  Ret,
+  Fn extends (_: Types.NotMatch<R, P>) => Ret
 >(
   pattern: P,
   f: Fn
 ) =>
 <I, F, A, Pr>(
-  self: Matcher<I, F, R, A, Pr>
+  self: Matcher<I, F, R, A, Pr, Ret>
 ): Matcher<
   I,
   Types.AddOnly<F, Types.WhenMatch<R, P>>,
   Types.ApplyFilters<I, Types.AddOnly<F, Types.WhenMatch<R, P>>>,
   A | ReturnType<Fn>,
-  Pr
+  Pr,
+  Ret
 > => (self as any).add(makeNot(makePredicate(pattern), f as any))
 
 /** @internal */
@@ -485,9 +512,9 @@ export const instanceOfUnsafe: <A extends abstract new(...args: any) => any>(
 ) => SafeRefinement<InstanceType<A>, InstanceType<A>> = instanceOf
 
 /** @internal */
-export const orElse = <RA, B>(f: (b: RA) => B) =>
+export const orElse = <RA, Ret, B extends Ret>(f: (b: RA) => B) =>
 <I, R, A, Pr>(
-  self: Matcher<I, R, RA, A, Pr>
+  self: Matcher<I, R, RA, A, Pr, Ret>
 ): [Pr] extends [never] ? (input: I) => Unify<A | B> : Unify<A | B> => {
   const result = either(self)
 
@@ -504,16 +531,16 @@ export const orElse = <RA, B>(f: (b: RA) => B) =>
 }
 
 /** @internal */
-export const orElseAbsurd = <I, R, RA, A, Pr>(
-  self: Matcher<I, R, RA, A, Pr>
+export const orElseAbsurd = <I, R, RA, A, Pr, Ret>(
+  self: Matcher<I, R, RA, A, Pr, Ret>
 ): [Pr] extends [never] ? (input: I) => Unify<A> : Unify<A> =>
   orElse(() => {
     throw new Error("effect/Match/orElseAbsurd: absurd")
   })(self)
 
 /** @internal */
-export const either: <I, F, R, A, Pr>(
-  self: Matcher<I, F, R, A, Pr>
+export const either: <I, F, R, A, Pr, Ret>(
+  self: Matcher<I, F, R, A, Pr, Ret>
 ) => [Pr] extends [never] ? (input: I) => Either.Either<Unify<A>, R>
   : Either.Either<Unify<A>, R> = (<I, R, RA, A>(self: Matcher<I, R, RA, A, I>) => {
     if (self._tag === "ValueMatcher") {
@@ -547,8 +574,8 @@ export const either: <I, F, R, A, Pr>(
   }) as any
 
 /** @internal */
-export const option: <I, F, R, A, Pr>(
-  self: Matcher<I, F, R, A, Pr>
+export const option: <I, F, R, A, Pr, Ret>(
+  self: Matcher<I, F, R, A, Pr, Ret>
 ) => [Pr] extends [never] ? (input: I) => Option.Option<Unify<A>>
   : Option.Option<Unify<A>> = (<I, A>(self: Matcher<I, any, any, A, I>) => {
     const toEither = either(self)
@@ -568,8 +595,8 @@ export const option: <I, F, R, A, Pr>(
 const getExhaustiveAbsurdErrorMessage = "effect/Match/exhaustive: absurd"
 
 /** @internal */
-export const exhaustive: <I, F, A, Pr>(
-  self: Matcher<I, F, never, A, Pr>
+export const exhaustive: <I, F, A, Pr, Ret>(
+  self: Matcher<I, F, never, A, Pr, Ret>
 ) => [Pr] extends [never] ? (u: I) => Unify<A> : Unify<A> = (<I, F, A>(
   self: Matcher<I, F, never, A, I>
 ) => {

package/src/internal/rateLimiter.ts

@@ -34,7 +34,7 @@ const tokenBucket = (limit: number, window: DurationInput): Effect.Effect<
   Effect.gen(function*(_) {
     const millisPerToken = Math.ceil(Duration.toMillis(window) / limit)
     const semaphore = yield* _(Effect.makeSemaphore(limit))
-    const latch = yield* _(Effect.makeSemaphore(0))
+    const latch = yield* Effect.makeSemaphore(0)
     const refill: Effect.Effect<void> = Effect.sleep(millisPerToken).pipe(
       Effect.zipRight(latch.releaseAll),
       Effect.zipRight(semaphore.release(1)),

package/src/internal/stm/core.ts

@@ -19,6 +19,7 @@ import { ChannelTypeId } from "../core-stream.js"
 import { withFiberRuntime } from "../core.js"
 import { effectVariance } from "../effectable.js"
 import { OP_COMMIT } from "../opCodes/effect.js"
+import { SingleShotGen } from "../singleShotGen.js"
 import { SinkTypeId } from "../sink.js"
 import * as OpCodes from "./opCodes/stm.js"
 import * as TExitOpCodes from "./opCodes/tExit.js"
@@ -170,6 +171,9 @@ class STMPrimitive implements STM.STM<any, any, any> {
   [Hash.symbol](this: {}) {
     return Hash.cached(this, Hash.random(this))
   }
+  [Symbol.iterator]() {
+    return new SingleShotGen(this) as any
+  }
   commit(this: STM.STM<any, any, any>): Effect.Effect<any, any, any> {
     return unsafeAtomically(this, constVoid, constVoid)
   }

package/src/internal/stm/stm.ts

@@ -14,7 +14,6 @@ import * as predicate from "../../Predicate.js"
 import type * as STM from "../../STM.js"
 import type { MergeRecord } from "../../Types.js"
 import * as effectCore from "../core.js"
-import * as SingleShotGen from "../singleShotGen.js"
 import * as core from "./core.js"
 import * as Journal from "./stm/journal.js"
 import * as STMState from "./stm/stmState.js"
@@ -614,39 +613,20 @@ export const fromOption = <A>(option: Option.Option<A>): STM.STM<A, Option.Optio
     onSome: core.succeed
   })
 
-/** @internal */
-class STMGen {
-  constructor(readonly value: STM.STM<any, any, any>) {}
-  [Symbol.iterator]() {
-    return new SingleShotGen.SingleShotGen(this)
-  }
-}
-
-const adapter = function() {
-  let x = arguments[0]
-  for (let i = 1; i < arguments.length; i++) {
-    x = arguments[i](x)
-  }
-  return new STMGen(x) as any
-}
-
 /**
  * Inspired by https://github.com/tusharmath/qio/pull/22 (revised)
  * @internal
  */
 export const gen: typeof STM.gen = (f) =>
   suspend(() => {
-    const iterator = f(adapter)
+    const iterator = f(pipe)
     const state = iterator.next()
     const run = (
       state: IteratorYieldResult<any> | IteratorReturnResult<any>
     ): STM.STM<any, any, any> =>
       state.done ?
         core.succeed(state.value) :
-        core.flatMap(
-          state.value.value as unknown as STM.STM<any, any, any>,
-          (val: any) => run(iterator.next(val))
-        )
+        core.flatMap(state.value, (val: any) => run(iterator.next(val)))
     return run(state)
   })
 

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.0.2"
+let moduleVersion = "3.0.4"
 
 export const getCurrentVersion = () => moduleVersion