effect 2.3.8 → 2.4.1

package/src/Option.ts

@@ -255,7 +255,7 @@ export const fromIterable = <A>(collection: Iterable<A>): Option<A> => {
  * @category conversions
  * @since 2.0.0
  */
-export const getRight: <E, A>(self: Either<E, A>) => Option<A> = either.getRight
+export const getRight: <R, L>(self: Either<R, L>) => Option<R> = either.getRight
 
 /**
  * Converts a `Either` to an `Option` discarding the value.
@@ -270,7 +270,7 @@ export const getRight: <E, A>(self: Either<E, A>) => Option<A> = either.getRight
  * @category conversions
  * @since 2.0.0
  */
-export const getLeft: <E, A>(self: Either<E, A>) => Option<E> = either.getLeft
+export const getLeft: <R, L>(self: Either<R, L>) => Option<L> = either.getLeft
 
 /**
  * Returns the value of the `Option` if it is `Some`, otherwise returns `onNone`
@@ -395,11 +395,11 @@ export const orElseSome: {
  * @since 2.0.0
  */
 export const orElseEither: {
-  <B>(that: LazyArg<Option<B>>): <A>(self: Option<A>) => Option<Either<A, B>>
-  <A, B>(self: Option<A>, that: LazyArg<Option<B>>): Option<Either<A, B>>
+  <B>(that: LazyArg<Option<B>>): <A>(self: Option<A>) => Option<Either<B, A>>
+  <A, B>(self: Option<A>, that: LazyArg<Option<B>>): Option<Either<B, A>>
 } = dual(
   2,
-  <A, B>(self: Option<A>, that: LazyArg<Option<B>>): Option<Either<A, B>> =>
+  <A, B>(self: Option<A>, that: LazyArg<Option<B>>): Option<Either<B, A>> =>
     isNone(self) ? map(that(), either.right) : map(self, either.left)
 )
 
@@ -607,8 +607,8 @@ export const map: {
  * @since 2.0.0
  */
 export const as: {
-  <B>(b: B): <_>(self: Option<_>) => Option<B>
-} = dual(2, <_, B>(self: Option<_>, b: B): Option<B> => map(self, () => b))
+  <B>(b: B): <X>(self: Option<X>) => Option<B>
+} = dual(2, <X, B>(self: Option<X>, b: B): Option<B> => map(self, () => b))
 
 /**
  * Maps the `Some` value of this `Option` to the `void` constant value.
@@ -724,8 +724,8 @@ export const flatten: <A>(self: Option<Option<A>>) => Option<A> = flatMap(identi
  */
 export const zipRight: {
   <B>(that: Option<B>): <_>(self: Option<_>) => Option<B>
-  <_, B>(self: Option<_>, that: Option<B>): Option<B>
-} = dual(2, <_, B>(self: Option<_>, that: Option<B>): Option<B> => flatMap(self, () => that))
+  <X, B>(self: Option<X>, that: Option<B>): Option<B>
+} = dual(2, <X, B>(self: Option<X>, that: Option<B>): Option<B> => flatMap(self, () => that))
 
 /**
  * @category sequencing
@@ -749,8 +749,8 @@ export const composeK: {
  */
 export const zipLeft: {
   <_>(that: Option<_>): <A>(self: Option<A>) => Option<A>
-  <A, _>(self: Option<A>, that: Option<_>): Option<A>
-} = dual(2, <A, _>(self: Option<A>, that: Option<_>): Option<A> => tap(self, () => that))
+  <A, X>(self: Option<A>, that: Option<X>): Option<A>
+} = dual(2, <A, X>(self: Option<A>, that: Option<X>): Option<A> => tap(self, () => that))
 
 /**
  * Applies the provided function `f` to the value of the `Option` if it is `Some` and returns the original `Option`
@@ -774,9 +774,9 @@ export const zipLeft: {
  * @since 2.0.0
  */
 export const tap: {
-  <A, _>(f: (a: A) => Option<_>): (self: Option<A>) => Option<A>
-  <A, _>(self: Option<A>, f: (a: A) => Option<_>): Option<A>
-} = dual(2, <A, _>(self: Option<A>, f: (a: A) => Option<_>): Option<A> => flatMap(self, (a) => map(f(a), () => a)))
+  <A, X>(f: (a: A) => Option<X>): (self: Option<A>) => Option<A>
+  <A, X>(self: Option<A>, f: (a: A) => Option<X>): Option<A>
+} = dual(2, <A, X>(self: Option<A>, f: (a: A) => Option<X>): Option<A> => flatMap(self, (a) => map(f(a), () => a)))
 
 /**
  * @category combining
@@ -955,11 +955,11 @@ 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>) => [left: Option<B>, right: Option<C>]
-  <A, B, C>(self: Option<A>, f: (a: A) => Either<B, C>): [left: Option<B>, right: Option<C>]
+  <A, B, C>(f: (a: A) => Either<C, B>): (self: Option<A>) => [left: Option<B>, right: Option<C>]
+  <A, B, C>(self: Option<A>, f: (a: A) => Either<C, B>): [left: Option<B>, right: Option<C>]
 } = dual(2, <A, B, C>(
   self: Option<A>,
-  f: (a: A) => Either<B, C>
+  f: (a: A) => Either<C, B>
 ): [excluded: Option<B>, satisfying: Option<C>] => {
   if (isNone(self)) {
     return [none(), none()]

package/src/Predicate.ts

@@ -53,6 +53,43 @@ export const mapInput: {
   <A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B>
 } = dual(2, <A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B> => (b) => self(f(b)))
 
+/**
+ * Tests if a value is a `Set`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isSet } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isSet(new Set([1, 2])), true)
+ * assert.deepStrictEqual(isSet(new Set()), true)
+ * assert.deepStrictEqual(isSet({}), false)
+ * assert.deepStrictEqual(isSet(null), false)
+ * assert.deepStrictEqual(isSet(undefined), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const isSet = (input: unknown): input is Set<unknown> => input instanceof Set
+
+/**
+ * Tests if a value is a `Map`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isMap } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isMap(new Map()), true)
+ * assert.deepStrictEqual(isMap({}), false)
+ * assert.deepStrictEqual(isMap(null), false)
+ * assert.deepStrictEqual(isMap(undefined), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const isMap = (input: unknown): input is Map<unknown, unknown> => input instanceof Map
+
 /**
  * Tests if a value is a `string`.
  *
@@ -192,7 +229,7 @@ export const isUndefined = (input: unknown): input is undefined => input === und
 export const isNotUndefined = <A>(input: A): input is Exclude<A, undefined> => input !== undefined
 
 /**
- * Tests if a value is `undefined`.
+ * Tests if a value is `null`.
  *
  * @param input - The value to test.
  *
@@ -210,7 +247,7 @@ export const isNotUndefined = <A>(input: A): input is Exclude<A, undefined> => i
 export const isNull = (input: unknown): input is null => input === null
 
 /**
- * Tests if a value is not `undefined`.
+ * Tests if a value is not `null`.
  *
  * @param input - The value to test.
  *

package/src/ReadonlyArray.ts

@@ -17,7 +17,7 @@ import * as O from "./Option.js"
 import * as Order from "./Order.js"
 import type { Predicate, Refinement } from "./Predicate.js"
 import { isBoolean } from "./Predicate.js"
-import * as RR from "./ReadonlyRecord.js"
+import * as ReadonlyRecord from "./ReadonlyRecord.js"
 import * as Tuple from "./Tuple.js"
 import type { NoInfer } from "./Types.js"
 
@@ -128,7 +128,7 @@ export const fromIterable = <A>(collection: Iterable<A>): Array<A> =>
  * @category conversions
  * @since 2.0.0
  */
-export const fromRecord: <K extends string, A>(self: Readonly<Record<K, A>>) => Array<[K, A]> = RR.toEntries
+export const fromRecord: <K extends string, A>(self: Readonly<Record<K, A>>) => Array<[K, A]> = ReadonlyRecord.toEntries
 
 /**
  * @category conversions
@@ -1334,10 +1334,18 @@ export const group: <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray<NonEmpt
  * @since 2.0.0
  */
 export const groupBy: {
-  <A>(f: (a: A) => string): (self: Iterable<A>) => Record<string, NonEmptyArray<A>>
-  <A>(self: Iterable<A>, f: (a: A) => string): Record<string, NonEmptyArray<A>>
-} = dual(2, <A>(self: Iterable<A>, f: (a: A) => string): Record<string, NonEmptyArray<A>> => {
-  const out: Record<string, NonEmptyArray<A>> = {}
+  <A, K extends string | symbol>(
+    f: (a: A) => K
+  ): (self: Iterable<A>) => Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
+  <A, K extends string | symbol>(
+    self: Iterable<A>,
+    f: (a: A) => K
+  ): Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>>
+} = dual(2, <A, K extends string | symbol>(
+  self: Iterable<A>,
+  f: (a: A) => K
+): Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, NonEmptyArray<A>> => {
+  const out: Record<string | symbol, NonEmptyArray<A>> = {}
   for (const a of self) {
     const k = f(a)
     if (Object.prototype.hasOwnProperty.call(out, k)) {
@@ -1615,11 +1623,11 @@ export const filterMapWhile: {
  * @since 2.0.0
  */
 export const partitionMap: {
-  <A, B, C>(f: (a: A, i: number) => Either<B, C>): (self: Iterable<A>) => [left: Array<B>, right: Array<C>]
-  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either<B, C>): [left: Array<B>, right: Array<C>]
+  <A, B, C>(f: (a: A, i: number) => Either<C, B>): (self: Iterable<A>) => [left: Array<B>, right: Array<C>]
+  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either<C, B>): [left: Array<B>, right: Array<C>]
 } = dual(
   2,
-  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either<B, C>): [left: Array<B>, right: Array<C>] => {
+  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Either<C, B>): [left: Array<B>, right: Array<C>] => {
     const left: Array<B> = []
     const right: Array<C> = []
     const as = fromIterable(self)
@@ -1667,8 +1675,8 @@ export const getSomes: <A>(self: Iterable<Option<A>>) => Array<A> = filterMap(id
  * @category filtering
  * @since 2.0.0
  */
-export const getLefts = <E, A>(self: Iterable<Either<E, A>>): Array<E> => {
-  const out: Array<E> = []
+export const getLefts = <R, L>(self: Iterable<Either<R, L>>): Array<L> => {
+  const out: Array<L> = []
   for (const a of self) {
     if (E.isLeft(a)) {
       out.push(a.left)
@@ -1693,8 +1701,8 @@ export const getLefts = <E, A>(self: Iterable<Either<E, A>>): Array<E> => {
  * @category filtering
  * @since 2.0.0
  */
-export const getRights = <E, A>(self: Iterable<Either<E, A>>): Array<A> => {
-  const out: Array<A> = []
+export const getRights = <R, L>(self: Iterable<Either<R, L>>): Array<R> => {
+  const out: Array<R> = []
   for (const a of self) {
     if (E.isRight(a)) {
       out.push(a.right)
@@ -1766,7 +1774,7 @@ export const partition: {
  * @category filtering
  * @since 2.0.0
  */
-export const separate: <E, A>(self: Iterable<Either<E, A>>) => [Array<E>, Array<A>] = partitionMap(
+export const separate: <R, L>(self: Iterable<Either<R, L>>) => [Array<L>, Array<R>] = partitionMap(
   identity
 )
 
@@ -1847,7 +1855,7 @@ export const flatMapNullable: {
  * @since 2.0.0
  */
 export const liftEither = <A extends Array<unknown>, E, B>(
-  f: (...a: A) => Either<E, B>
+  f: (...a: A) => Either<B, E>
 ) =>
 (...a: A): Array<B> => {
   const e = f(...a)