effect 2.0.0-next.55 → 2.0.0-next.57

package/src/Option.ts

@@ -6,7 +6,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 } from "./Function.js"
+import { constNull, constUndefined, dual, identity, isFunction } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
 import type { Inspectable } from "./Inspectable.js"
 import * as either from "./internal/either.js"
@@ -15,6 +15,7 @@ import type { Order } from "./Order.js"
 import * as order from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
+import type * as Types from "./Types.js"
 import type * as Unify from "./Unify.js"
 import * as Gen from "./Utils.js"
 
@@ -40,11 +41,11 @@ export type TypeId = typeof TypeId
  * @category models
  * @since 2.0.0
  */
-export interface None<A> extends Data.Case, Pipeable, Inspectable {
+export interface None<out A> extends Data.Case, Pipeable, Inspectable {
   readonly _tag: "None"
   readonly _op: "None"
   readonly [TypeId]: {
-    readonly _A: (_: never) => A
+    readonly _A: Types.Covariant<A>
   }
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: OptionUnify<this>
@@ -55,12 +56,12 @@ export interface None<A> extends Data.Case, Pipeable, Inspectable {
  * @category models
  * @since 2.0.0
  */
-export interface Some<A> extends Data.Case, Pipeable, Inspectable {
+export interface Some<out A> extends Data.Case, Pipeable, Inspectable {
   readonly _tag: "Some"
   readonly _op: "Some"
   readonly value: A
   readonly [TypeId]: {
-    readonly _A: (_: never) => A
+    readonly _A: Types.Covariant<A>
   }
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: OptionUnify<this>
@@ -553,7 +554,7 @@ export const getOrThrow: <A>(self: Option<A>) => A = getOrThrowWith(() => new Er
  * @param self - An `Option` to map
  * @param f - The function to map over the value of the `Option`
  *
- * @category transforming
+ * @category mapping
  * @since 2.0.0
  */
 export const map: {
@@ -567,7 +568,7 @@ export const map: {
 /**
  * Maps the `Some` value of this `Option` to the specified constant value.
  *
- * @category transforming
+ * @category mapping
  * @since 2.0.0
  */
 export const as: {
@@ -579,7 +580,7 @@ export const as: {
  *
  * This is useful when the value of the `Option` is not needed, but the presence or absence of the value is important.
  *
- * @category transforming
+ * @category mapping
  * @since 2.0.0
  */
 export const asUnit: <_>(self: Option<_>) => Option<void> = as(undefined)
@@ -592,7 +593,7 @@ export const unit: Option<void> = some(undefined)
 /**
  * Applies a function to the value of an `Option` and flattens the result, if the input is `Some`.
  *
- * @category transforming
+ * @category sequencing
  * @since 2.0.0
  */
 export const flatMap: {
@@ -603,6 +604,23 @@ export const flatMap: {
   <A, B>(self: Option<A>, f: (a: A) => Option<B>): Option<B> => isNone(self) ? none() : f(self.value)
 )
 
+/**
+ * Executes a sequence of two `Option`s. The second `Option` can be dependent on the result of the first `Option`.
+ *
+ * @category sequencing
+ * @since 2.0.0
+ */
+export const andThen: {
+  <A, B>(f: (a: A) => Option<B>): (self: Option<A>) => Option<B>
+  <B>(f: Option<B>): <A>(self: Option<A>) => Option<B>
+  <A, B>(self: Option<A>, f: (a: A) => Option<B>): Option<B>
+  <A, B>(self: Option<A>, f: Option<B>): Option<B>
+} = dual(
+  2,
+  <A, B>(self: Option<A>, f: (a: A) => Option<B> | Option<B>): Option<B> =>
+    isFunction(f) ? flatMap(self, f) : flatMap(self, () => f)
+)
+
 /**
  * This is `flatMap` + `fromNullable`, useful when working with optional values.
  *
@@ -640,7 +658,7 @@ export const flatMap: {
  *   none()
  * )
  *
- * @category transforming
+ * @category sequencing
  * @since 2.0.0
  */
 export const flatMapNullable: {
@@ -653,13 +671,13 @@ export const flatMapNullable: {
 )
 
 /**
- * @category transforming
+ * @category sequencing
  * @since 2.0.0
  */
 export const flatten: <A>(self: Option<Option<A>>) => Option<A> = flatMap(identity)
 
 /**
- * @category transforming
+ * @category zipping
  * @since 2.0.0
  */
 export const zipRight: {
@@ -668,7 +686,7 @@ export const zipRight: {
 } = dual(2, <_, B>(self: Option<_>, that: Option<B>): Option<B> => flatMap(self, () => that))
 
 /**
- * @category transforming
+ * @category sequencing
  * @since 2.0.0
  */
 export const composeK: {
@@ -684,7 +702,7 @@ export const composeK: {
  * @param that - The `Option` that will be ignored in the chain and discarded
  * @param self - The `Option` we care about
  *
- * @category transforming
+ * @category zipping
  * @since 2.0.0
  */
 export const zipLeft: {
@@ -710,7 +728,7 @@ export const zipLeft: {
  * assert.deepStrictEqual(O.tap(O.some(1), getInteger), O.some(1))
  * assert.deepStrictEqual(O.tap(O.some(1.14), getInteger), O.none())
  *
- * @category transforming
+ * @category sequencing
  * @since 2.0.0
  */
 export const tap: {
@@ -807,7 +825,7 @@ export const all: <const I extends Iterable<Option<any>> | Record<string, Option
  * @example
  * import * as O from "effect/Option"
  *
- * type Complex = [number, number]
+ * type Complex = [real: number, imaginary: number]
  *
  * const complex = (real: number, imaginary: number): Complex => [real, imaginary]
  *
@@ -818,7 +836,7 @@ export const all: <const I extends Iterable<Option<any>> | Record<string, Option
  *
  * assert.deepStrictEqual(O.zipWith(O.some(1), complex)(O.some(2)), O.some([2, 1]))
  *
- * @category combining
+ * @category zipping
  * @since 2.0.0
  */
 export const zipWith: {
@@ -895,12 +913,12 @@ export const toArray = <A>(self: Option<A>): Array<A> => isNone(self) ? [] : [se
  * @since 2.0.0
  */
 export const partitionMap: {
-  <A, B, C>(f: (a: A) => Either<B, C>): (self: Option<A>) => [Option<B>, Option<C>]
-  <A, B, C>(self: Option<A>, f: (a: A) => Either<B, C>): [Option<B>, Option<C>]
+  <A, B, C>(f: (a: A) => Either<B, C>): (self: Option<A>) => [left: Option<B>, right: Option<C>]
+  <A, B, C>(self: Option<A>, f: (a: A) => Either<B, C>): [left: Option<B>, right: Option<C>]
 } = dual(2, <A, B, C>(
   self: Option<A>,
   f: (a: A) => Either<B, C>
-): [Option<B>, Option<C>] => {
+): [excluded: Option<B>, satisfying: Option<C>] => {
   if (isNone(self)) {
     return [none(), none()]
   }
@@ -965,13 +983,13 @@ export const filterMap: {
  * @since 2.0.0
  */
 export const filter: {
-  <C extends A, B extends A, A = C>(refinement: (a: A) => a is B): (self: Option<C>) => Option<B>
-  <B extends A, A = B>(predicate: (a: A) => boolean): (self: Option<B>) => Option<B>
-  <C extends A, B extends A, A = C>(self: Option<C>, refinement: (a: A) => a is B): Option<B>
-  <B extends A, A = B>(self: Option<B>, predicate: (a: A) => boolean): Option<B>
+  <A, B extends A>(refinement: Refinement<A, B>): (self: Option<A>) => Option<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Option<B>) => Option<B>
+  <A, B extends A>(self: Option<A>, refinement: Refinement<A, B>): Option<B>
+  <A>(self: Option<A>, predicate: Predicate<A>): Option<A>
 } = dual(
   2,
-  <B extends A, A = B>(self: Option<B>, predicate: (a: A) => boolean): Option<B> =>
+  <A>(self: Option<A>, predicate: Predicate<A>): Option<A> =>
     filterMap(self, (b) => (predicate(b) ? option.some(b) : option.none))
 )
 
@@ -1049,9 +1067,9 @@ export const lift2 = <A, B, C>(f: (a: A, b: B) => C): {
  * @since 2.0.0
  */
 export const liftPredicate: {
-  <C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (c: C) => Option<B>
+  <A, B extends A>(refinement: Refinement<A, B>): (a: A) => Option<B>
   <B extends A, A = B>(predicate: Predicate<A>): (b: B) => Option<B>
-} = <B extends A, A = B>(predicate: Predicate<A>) => (b: B) => predicate(b) ? some(b) : none()
+} = <B extends A, A = B>(predicate: Predicate<A>) => (b: B): Option<B> => predicate(b) ? some(b) : none()
 
 /**
  * Returns a function that checks if a `Option` contains a given value using a provided `isEquivalent` function.
@@ -1109,11 +1127,14 @@ export const contains: {
  * @since 2.0.0
  */
 export const exists: {
-  <A>(predicate: Predicate<A>): (self: Option<A>) => boolean
+  <A, B extends A>(refinement: Refinement<A, B>): (self: Option<A>) => self is Option<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: Option<B>) => boolean
+  <A, B extends A>(self: Option<A>, refinement: Refinement<A, B>): self is Option<B>
   <A>(self: Option<A>, predicate: Predicate<A>): boolean
 } = dual(
   2,
-  <A>(self: Option<A>, predicate: Predicate<A>): boolean => isNone(self) ? false : predicate(self.value)
+  <A, B extends A>(self: Option<A>, refinement: Refinement<A, B>): self is Option<B> =>
+    isNone(self) ? false : refinement(self.value)
 )
 
 // -------------------------------------------------------------------------------------

package/src/Order.ts

@@ -8,7 +8,7 @@ import type { TypeLambda } from "./HKT.js"
  * @category type class
  * @since 2.0.0
  */
-export interface Order<A> {
+export interface Order<in A> {
   (self: A, that: A): -1 | 0 | 1
 }
 
@@ -108,7 +108,7 @@ export const empty = <A>(): Order<A> => make(() => 0)
 export const combineAll = <A>(collection: Iterable<Order<A>>): Order<A> => combineMany(empty(), collection)
 
 /**
- * @category combinators
+ * @category mapping
  * @since 2.0.0
  */
 export const mapInput: {