effect 3.0.2 → 3.0.4

package/src/Either.ts

@@ -4,7 +4,7 @@
 
 import * as Equivalence from "./Equivalence.js"
 import type { LazyArg } from "./Function.js"
-import { constNull, constUndefined, dual, identity } from "./Function.js"
+import { constNull, constUndefined, dual, identity, pipe } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
 import type { Inspectable } from "./Inspectable.js"
 import * as either from "./internal/either.js"
@@ -14,7 +14,7 @@ import type { Predicate, Refinement } from "./Predicate.js"
 import { isFunction } from "./Predicate.js"
 import type { Covariant, MergeRecord, NotFunction } from "./Types.js"
 import type * as Unify from "./Unify.js"
-import * as Gen from "./Utils.js"
+import type * as Gen from "./Utils.js"
 
 /**
  * @category models
@@ -698,26 +698,24 @@ export const all: <const I extends Iterable<Either<any, any>> | Record<string, E
  */
 export const flip = <R, L>(self: Either<R, L>): Either<L, R> => isLeft(self) ? right(self.left) : left(self.right)
 
-const adapter = Gen.adapter<EitherTypeLambda>()
-
 /**
  * @category generators
  * @since 2.0.0
  */
 export const gen: Gen.Gen<EitherTypeLambda, Gen.Adapter<EitherTypeLambda>> = (f) => {
-  const iterator = f(adapter)
+  const iterator = f(pipe)
   let state: IteratorYieldResult<any> | IteratorReturnResult<any> = iterator.next()
   if (state.done) {
     return right(state.value) as any
   } else {
-    let current = state.value.value
+    let current = state.value
     if (isLeft(current)) {
       return current
     }
     while (!state.done) {
       state = iterator.next(current.right)
       if (!state.done) {
-        current = state.value.value
+        current = state.value
         if (isLeft(current)) {
           return current
         }

package/src/Match.ts

@@ -25,21 +25,22 @@ export type MatcherTypeId = typeof MatcherTypeId
  * @category model
  * @since 1.0.0
  */
-export type Matcher<Input, Filters, RemainingApplied, Result, Provided> =
-  | TypeMatcher<Input, Filters, RemainingApplied, Result>
-  | ValueMatcher<Input, Filters, RemainingApplied, Result, Provided>
+export type Matcher<Input, Filters, RemainingApplied, Result, Provided, Return = any> =
+  | TypeMatcher<Input, Filters, RemainingApplied, Result, Return>
+  | ValueMatcher<Input, Filters, RemainingApplied, Result, Provided, Return>
 
 /**
  * @category model
  * @since 1.0.0
  */
-export interface TypeMatcher<in Input, out Filters, out Remaining, out Result> extends Pipeable {
+export interface TypeMatcher<in Input, out Filters, out Remaining, out Result, out Return = any> extends Pipeable {
   readonly _tag: "TypeMatcher"
   readonly [MatcherTypeId]: {
     readonly _input: Contravariant<Input>
     readonly _filters: Covariant<Filters>
     readonly _remaining: Covariant<Remaining>
     readonly _result: Covariant<Result>
+    readonly _return: Covariant<Return>
   }
   readonly cases: ReadonlyArray<Case>
   add<I, R, RA, A>(_case: Case): TypeMatcher<I, R, RA, A>
@@ -49,12 +50,15 @@ export interface TypeMatcher<in Input, out Filters, out Remaining, out Result> e
  * @category model
  * @since 1.0.0
  */
-export interface ValueMatcher<in Input, Filters, out Remaining, out Result, Provided> extends Pipeable {
+export interface ValueMatcher<in Input, Filters, out Remaining, out Result, Provided, out Return = any>
+  extends Pipeable
+{
   readonly _tag: "ValueMatcher"
   readonly [MatcherTypeId]: {
     readonly _input: Contravariant<Input>
     readonly _filters: Covariant<Filters>
     readonly _result: Covariant<Result>
+    readonly _return: Covariant<Return>
   }
   readonly provided: Provided
   readonly value: Either.Either<Provided, Remaining>
@@ -130,6 +134,15 @@ export const typeTags: <I>() => <
     & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
 >(fields: P) => (input: I) => Unify<ReturnType<P[keyof P]>> = internal.typeTags
 
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+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" = internal.withReturnType
+
 /**
  * @category combinators
  * @since 1.0.0
@@ -137,19 +150,21 @@ export const typeTags: <I>() => <
 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
-> = internal.when as any
+  Pr,
+  Ret
+> = internal.when
 
 /**
  * @category combinators
@@ -157,21 +172,21 @@ export const when: <
  */
 export const whenOr: <
   R,
-  const P extends ReadonlyArray<
-    Types.PatternPrimitive<R> | Types.PatternBase<R>
-  >,
-  Fn extends (_: Types.WhenMatch<R, P[number]>) => unknown
+  const P extends ReadonlyArray<Types.PatternPrimitive<R> | Types.PatternBase<R>>,
+  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
-> = internal.whenOr as any
+  Pr,
+  Ret
+> = internal.whenOr
 
 /**
  * @category combinators
@@ -179,24 +194,20 @@ export const whenOr: <
  */
 export const whenAnd: <
   R,
-  const P extends ReadonlyArray<
-    Types.PatternPrimitive<R> | Types.PatternBase<R>
-  >,
-  Fn extends (_: Types.WhenMatch<R, Types.ArrayToIntersection<P>>) => unknown
+  const P extends ReadonlyArray<Types.PatternPrimitive<R> | Types.PatternBase<R>>,
+  Ret,
+  Fn extends (_: Types.WhenMatch<R, UnionToIntersection<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<Types.ArrayToIntersection<P>>>,
-  Types.ApplyFilters<
-    I,
-    Types.AddWithout<F, Types.PForExclude<Types.ArrayToIntersection<P>>>
-  >,
+  Types.AddWithout<F, Types.PForExclude<UnionToIntersection<P[number]>>>,
+  Types.ApplyFilters<I, Types.AddWithout<F, Types.PForExclude<UnionToIntersection<P[number]>>>>,
   A | ReturnType<Fn>,
   Pr
-> = internal.whenAnd as any
+> = internal.whenAnd
 
 /**
  * @category combinators
@@ -204,20 +215,17 @@ export const whenAnd: <
  */
 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
-  ]
+) => <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]
 ) => <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>>>,
   Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<D, P>>>>,
   B | A,
-  Pr
+  Pr,
+  Ret
 > = internal.discriminator
 
 /**
@@ -226,20 +234,18 @@ export const discriminator: <D extends string>(
  */
 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
 ) => <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}`>>>,
-  Types.ApplyFilters<
-    I,
-    Types.AddWithout<F, Extract<R, Record<D, `${P}${string}`>>>
-  >,
+  Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<D, `${P}${string}`>>>>,
   B | A,
-  Pr
+  Pr,
+  Ret
 > = internal.discriminatorStartsWith as any
 
 /**
@@ -250,23 +256,21 @@ export const discriminators: <D extends string>(
   field: D
 ) => <
   R,
+  Ret,
   P extends
-    & {
-      readonly [Tag in Types.Tags<D, R> & string]?:
-        | ((_: Extract<R, Record<D, Tag>>) => any)
-        | undefined
-    }
+    & { 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
 ) => <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
 > = internal.discriminators
 
 /**
@@ -277,58 +281,50 @@ export const discriminatorsExhaustive: <D extends string>(
   field: D
 ) => <
   R,
+  Ret,
   P extends
-    & {
-      readonly [Tag in Types.Tags<D, R> & string]: (
-        _: Extract<R, Record<D, Tag>>
-      ) => any
-    }
+    & { 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>
-) => [Pr] extends [never] ? (u: I) => Unify<A | ReturnType<P[keyof P]>>
-  : Unify<A | ReturnType<P[keyof P]>> = internal.discriminatorsExhaustive
+  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]>> =
+  internal.discriminatorsExhaustive
 
 /**
  * @category combinators
  * @since 1.0.0
  */
-export const tag: <R, P extends Types.Tags<"_tag", R> & string, B>(
-  ...pattern: [
-    first: P,
-    ...values: Array<P>,
-    f: (_: Extract<R, Record<"_tag", P>>) => 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
 > = internal.tag
 
 /**
  * @category combinators
  * @since 1.0.0
  */
-export const tagStartsWith: <R, P extends string, B>(
+export const tagStartsWith: <R, P extends string, Ret, B extends Ret>(
   pattern: P,
   f: (_: Extract<R, Record<"_tag", `${P}${string}`>>) => 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}${string}`>>>,
-  Types.ApplyFilters<
-    I,
-    Types.AddWithout<F, Extract<R, Record<"_tag", `${P}${string}`>>>
-  >,
+  Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<"_tag", `${P}${string}`>>>>,
   B | A,
-  Pr
+  Pr,
+  Ret
 > = internal.tagStartsWith as any
 
 /**
@@ -337,26 +333,21 @@ export const tagStartsWith: <R, P extends string, B>(
  */
 export const tags: <
   R,
+  Ret,
   P extends
-    & {
-      readonly [Tag in Types.Tags<"_tag", R> & string]?:
-        | ((_: Extract<R, Record<"_tag", Tag>>) => any)
-        | undefined
-    }
+    & { readonly [Tag in Types.Tags<"_tag", R> & string]?: ((_: Extract<R, Record<"_tag", Tag>>) => Ret) | undefined }
     & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", R>>]: never }
 >(
   fields: P
 ) => <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", keyof P>>>,
-  Types.ApplyFilters<
-    I,
-    Types.AddWithout<F, Extract<R, Record<"_tag", keyof P>>>
-  >,
+  Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<"_tag", keyof P>>>>,
   A | ReturnType<P[keyof P] & {}>,
-  Pr
+  Pr,
+  Ret
 > = internal.tags
 
 /**
@@ -365,19 +356,16 @@ export const tags: <
  */
 export const tagsExhaustive: <
   R,
+  Ret,
   P extends
-    & {
-      readonly [Tag in Types.Tags<"_tag", R> & string]: (
-        _: Extract<R, Record<"_tag", Tag>>
-      ) => any
-    }
+    & { readonly [Tag in Types.Tags<"_tag", R> & string]: (_: Extract<R, Record<"_tag", Tag>>) => Ret }
     & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", R>>]: never }
 >(
   fields: P
 ) => <I, F, A, Pr>(
-  self: Matcher<I, F, R, A, Pr>
-) => [Pr] extends [never] ? (u: I) => Unify<A | ReturnType<P[keyof P]>>
-  : Unify<A | ReturnType<P[keyof P]>> = internal.tagsExhaustive
+  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]>> =
+  internal.tagsExhaustive
 
 /**
  * @category combinators
@@ -386,19 +374,21 @@ export const tagsExhaustive: <
 export const not: <
   R,
   const P extends Types.PatternPrimitive<R> | Types.PatternBase<R>,
-  Fn extends (_: Types.NotMatch<R, P>) => unknown
+  Ret,
+  Fn extends (_: Exclude<R, Types.ExtractMatch<R, Types.PForExclude<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
-> = internal.not as any
+  Pr,
+  Ret
+> = internal.not
 
 /**
  * @category predicates
@@ -506,44 +496,42 @@ export const instanceOfUnsafe: <A extends abstract new(...args: any) => any>(
  * @category conversions
  * @since 1.0.0
  */
-export const orElse: <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<B | A> : Unify<B | A> = internal.orElse
 
 /**
  * @category conversions
  * @since 1.0.0
  */
-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> = internal.orElseAbsurd
 
 /**
  * @category conversions
  * @since 1.0.0
  */
-export const either: <I, F, R, A, Pr>(
-  self: Matcher<I, F, R, A, Pr>
-) => [Pr] extends [never] ? (input: I) => Either.Either<Unify<A>, R>
-  : Either.Either<Unify<A>, R> = internal.either
+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> = internal.either
 
 /**
  * @category conversions
  * @since 1.0.0
  */
-export const option: <I, F, R, A, Pr>(
-  self: Matcher<I, F, R, A, Pr>
-) => [Pr] extends [never] ? (input: I) => Option.Option<Unify<A>>
-  : Option.Option<Unify<A>> = internal.option
+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>> = internal.option
 
 /**
  * @category conversions
  * @since 1.0.0
  */
-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> = internal.exhaustive
 
 /**

package/src/Option.ts

@@ -5,7 +5,7 @@ import type { Either } from "./Either.js"
 import * as Equal from "./Equal.js"
 import * as Equivalence from "./Equivalence.js"
 import type { LazyArg } from "./Function.js"
-import { constNull, constUndefined, dual, identity, isFunction } from "./Function.js"
+import { constNull, constUndefined, dual, identity, isFunction, pipe } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
 import type { Inspectable } from "./Inspectable.js"
 import * as either from "./internal/either.js"
@@ -16,7 +16,7 @@ import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
 import type { Covariant, NotFunction } from "./Types.js"
 import type * as Unify from "./Unify.js"
-import * as Gen from "./Utils.js"
+import type * as Gen from "./Utils.js"
 
 /**
  * @category models
@@ -1261,26 +1261,24 @@ export const bind: {
  */
 export const Do: Option<{}> = some({})
 
-const adapter = Gen.adapter<OptionTypeLambda>()
-
 /**
  * @category generators
  * @since 2.0.0
  */
 export const gen: Gen.Gen<OptionTypeLambda, Gen.Adapter<OptionTypeLambda>> = (f) => {
-  const iterator = f(adapter)
+  const iterator = f(pipe)
   let state: IteratorYieldResult<any> | IteratorReturnResult<any> = iterator.next()
   if (state.done) {
     return some(state.value)
   } else {
-    let current = state.value.value
+    let current = state.value
     if (isNone(current)) {
       return current
     }
     while (!state.done) {
       state = iterator.next(current.value)
       if (!state.done) {
-        current = state.value.value
+        current = state.value
         if (isNone(current)) {
           return current
         }

package/src/Order.ts

@@ -1,4 +1,19 @@
 /**
+ * This module provides an implementation of the `Order` type class which is used to define a total ordering on some type `A`.
+ * An order is defined by a relation `<=`, which obeys the following laws:
+ *
+ * - either `x <= y` or `y <= x` (totality)
+ * - if `x <= y` and `y <= x`, then `x == y` (antisymmetry)
+ * - if `x <= y` and `y <= z`, then `x <= z` (transitivity)
+ *
+ * The truth table for compare is defined as follows:
+ *
+ * | `x <= y` | `x >= y` | Ordering |                       |
+ * | -------- | -------- | -------- | --------------------- |
+ * | `true`   | `true`   | `0`      | corresponds to x == y |
+ * | `true`   | `false`  | `< 0`    | corresponds to x < y  |
+ * | `false`  | `true`   | `> 0`    | corresponds to x > y  |
+ *
  * @since 2.0.0
  */
 import { dual } from "./Function.js"