effect 2.0.0-next.50 → 2.0.0-next.51

package/src/Chunk.ts

@@ -822,6 +822,21 @@ export const last = <A>(self: Chunk<A>): Option<A> => get(self, self.length - 1)
  */
 export const unsafeLast = <A>(self: Chunk<A>): A => unsafeGet(self, self.length - 1)
 
+/**
+ * @since 2.0.0
+ */
+export declare namespace Chunk {
+  /**
+   * @since 2.0.0
+   */
+  export type Infer<T extends Chunk<any>> = T extends Chunk<infer A> ? A : never
+
+  /**
+   * @since 2.0.0
+   */
+  export type With<T extends Chunk<any>, A> = T extends NonEmptyChunk<any> ? NonEmptyChunk<A> : Chunk<A>
+}
+
 /**
  * Returns a chunk with the elements mapped by the specified f function.
  *
@@ -829,24 +844,13 @@ export const unsafeLast = <A>(self: Chunk<A>): A => unsafeGet(self, self.length
  * @category mapping
  */
 export const map: {
-  <A, B>(f: (a: A, i: number) => B): (self: Chunk<A>) => Chunk<B>
-  <A, B>(self: Chunk<A>, f: (a: A, i: number) => B): Chunk<B>
+  <T extends Chunk<any>, B>(f: (a: Chunk.Infer<T>, i: number) => B): (self: T) => Chunk.With<T, B>
+  <T extends Chunk<any>, B>(self: T, f: (a: Chunk.Infer<T>, i: number) => B): Chunk.With<T, B>
 } = dual(2, <A, B>(self: Chunk<A>, f: (a: A, i: number) => B): Chunk<B> =>
   self.backing._tag === "ISingleton" ?
     of(f(self.backing.a, 0)) :
     unsafeFromArray(pipe(toReadonlyArray(self), RA.map((a, i) => f(a, i)))))
 
-/**
- * Returns a non empty chunk with the elements mapped by the specified f function.
- *
- * @since 2.0.0
- * @category mapping
- */
-export const mapNonEmpty: {
-  <A, B>(f: (a: A, i: number) => B): (self: NonEmptyChunk<A>) => NonEmptyChunk<B>
-  <A, B>(self: NonEmptyChunk<A>, f: (a: A, i: number) => B): NonEmptyChunk<B>
-} = map as any
-
 /**
  * Statefully maps over the chunk, producing new elements of type `B`.
  *

package/src/Data.ts

@@ -14,8 +14,8 @@ import type * as Types from "./Types"
  * @category models
  * @since 2.0.0
  */
-export type Data<A extends Readonly<Record<string, any>> | ReadonlyArray<any>> =
-  & Readonly<A>
+export type Data<A> =
+  & { readonly [P in keyof A]: A[P] }
   & Equal.Equal
 
 /**
@@ -36,41 +36,93 @@ export declare namespace Case {
    * @since 2.0.0
    * @category models
    */
-  export interface Constructor<A extends Case, T extends keyof A = never> {
-    (args: Omit<A, T | keyof Equal.Equal> extends Record<PropertyKey, never> ? void : Omit<A, T | keyof Equal.Equal>): A
+  export interface Constructor<A extends Case, Tag extends keyof A = never> {
+    (
+      args: Types.Equals<Omit<A, Tag | keyof Equal.Equal>, {}> extends true ? void
+        : { readonly [P in keyof A as P extends Tag | keyof Equal.Equal ? never : P]: A[P] }
+    ): A
   }
 }
 
 /**
+ * @example
+ * import * as Data from "effect/Data"
+ * import * as Equal from "effect/Equal"
+ *
+ * const alice = Data.struct({ name: "Alice", age: 30 })
+ *
+ * const bob = Data.struct({ name: "Bob", age: 40 })
+ *
+ * assert.deepStrictEqual(Equal.equals(alice, alice), true)
+ * assert.deepStrictEqual(Equal.equals(alice, Data.struct({ name: "Alice", age: 30 })), true)
+ *
+ * assert.deepStrictEqual(Equal.equals(alice, { name: "Alice", age: 30 }), false)
+ * assert.deepStrictEqual(Equal.equals(alice, bob), false)
+ *
  * @category constructors
  * @since 2.0.0
  */
-export const struct: <As extends Readonly<Record<string, any>>>(as: As) => Data<As> = internal.struct
+export const struct: <A extends Record<string, any>>(a: A) => Data<{ readonly [P in keyof A]: A[P] }> = internal.struct
 
 /**
  * @category constructors
  * @since 2.0.0
  */
-export const unsafeStruct = <As extends Readonly<Record<string, any>>>(as: As): Data<As> =>
+export const unsafeStruct = <A extends Record<string, any>>(as: A): Data<{ readonly [P in keyof A]: A[P] }> =>
   Object.setPrototypeOf(as, internal.StructProto)
 
 /**
+ * @example
+ * import * as Data from "effect/Data"
+ * import * as Equal from "effect/Equal"
+ *
+ * const alice = Data.tuple("Alice", 30)
+ *
+ * const bob = Data.tuple("Bob", 40)
+ *
+ * assert.deepStrictEqual(Equal.equals(alice, alice), true)
+ * assert.deepStrictEqual(Equal.equals(alice, Data.tuple("Alice", 30)), true)
+ *
+ * assert.deepStrictEqual(Equal.equals(alice, ["Alice", 30]), false)
+ * assert.deepStrictEqual(Equal.equals(alice, bob), false)
+ *
  * @category constructors
  * @since 2.0.0
  */
-export const tuple = <As extends ReadonlyArray<any>>(...as: As): Data<As> => unsafeArray(as)
+export const tuple = <As extends ReadonlyArray<any>>(...as: As): Data<Readonly<As>> => unsafeArray(as)
 
 /**
+ * @example
+ * import * as Data from "effect/Data"
+ * import * as Equal from "effect/Equal"
+ *
+ * const alice = Data.struct({ name: "Alice", age: 30 })
+ * const bob = Data.struct({ name: "Bob", age: 40 })
+ *
+ * const persons = Data.array([alice, bob])
+ *
+ * assert.deepStrictEqual(
+ *   Equal.equals(
+ *     persons,
+ *     Data.array([
+ *       Data.struct({ name: "Alice", age: 30 }),
+ *       Data.struct({ name: "Bob", age: 40 })
+ *     ])
+ *   ),
+ *   true
+ * )
+ *
  * @category constructors
  * @since 2.0.0
  */
-export const array = <As extends ReadonlyArray<any>>(as: As): Data<As> => unsafeArray(as.slice(0) as unknown as As)
+export const array = <As extends ReadonlyArray<any>>(as: As): Data<Readonly<As>> =>
+  unsafeArray(as.slice(0) as unknown as As)
 
 /**
  * @category constructors
  * @since 2.0.0
  */
-export const unsafeArray = <As extends ReadonlyArray<any>>(as: As): Data<As> =>
+export const unsafeArray = <As extends ReadonlyArray<any>>(as: As): Data<Readonly<As>> =>
   Object.setPrototypeOf(as, internal.ArrayProto)
 
 const _case = <A extends Case>(): Case.Constructor<A> => (args) =>
@@ -80,6 +132,27 @@ export {
   /**
    * Provides a constructor for the specified `Case`.
    *
+   * @example
+   * import * as Data from "effect/Data"
+   * import * as Equal from "effect/Equal"
+   *
+   * // Extending Data.Case to implement Equal
+   * interface Person extends Data.Case {
+   *   readonly name: string
+   * }
+   *
+   * // Creating a constructor for the specified Case
+   * const Person = Data.case<Person>()
+   *
+   * // Creating instances of Person
+   * const mike1 = Person({ name: "Mike" })
+   * const mike2 = Person({ name: "Mike" })
+   * const john = Person({ name: "John" })
+   *
+   * // Checking equality
+   * assert.deepStrictEqual(Equal.equals(mike1, mike2), true)
+   * assert.deepStrictEqual(Equal.equals(mike1, john), false)
+   *
    * @since 2.0.0
    * @category constructors
    */
@@ -89,10 +162,24 @@ export {
 /**
  * Provides a tagged constructor for the specified `Case`.
  *
+ * @example
+ * import * as Data from "effect/Data"
+ *
+ * interface Person extends Data.Case {
+ *   readonly _tag: "Person" // the tag
+ *   readonly name: string
+ * }
+ *
+ * const Person = Data.tagged<Person>("Person")
+ *
+ * const mike = Person({ name: "Mike" })
+ *
+ * assert.deepEqual(mike, { _tag: "Person", name: "Mike" })
+ *
  * @since 2.0.0
  * @category constructors
  */
-export const tagged = <A extends Case & { _tag: string }>(
+export const tagged = <A extends Case & { readonly _tag: string }>(
   tag: A["_tag"]
 ): Case.Constructor<A, "_tag"> =>
 (args) => {
@@ -101,33 +188,67 @@ export const tagged = <A extends Case & { _tag: string }>(
   return value
 }
 
+/**
+ * Provides a constructor for a Case Class.
+ *
+ * @example
+ * import * as Data from "effect/Data"
+ * import * as Equal from "effect/Equal"
+ *
+ * class Person extends Data.Class<{ readonly name: string }> {}
+ *
+ * // Creating instances of Person
+ * const mike1 = new Person({ name: "Mike" })
+ * const mike2 = new Person({ name: "Mike" })
+ * const john = new Person({ name: "John" })
+ *
+ * // Checking equality
+ * assert.deepStrictEqual(Equal.equals(mike1, mike2), true)
+ * assert.deepStrictEqual(Equal.equals(mike1, john), false)
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Class: new<A extends Record<string, any>>(
+  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
+    : { readonly [P in Exclude<keyof A, keyof Equal.Equal>]: A[P] }
+) => Data<Readonly<A>> = internal.Structural as any
+
 /**
  * Provides a Tagged constructor for a Case Class.
  *
+ * @example
+ * import * as Data from "effect/Data"
+ * import * as Equal from "effect/Equal"
+ *
+ * class Person extends Data.TaggedClass("Person")<{ readonly name: string }> {}
+ *
+ * // Creating instances of Person
+ * const mike1 = new Person({ name: "Mike" })
+ * const mike2 = new Person({ name: "Mike" })
+ * const john = new Person({ name: "John" })
+ *
+ * // Checking equality
+ * assert.deepStrictEqual(Equal.equals(mike1, mike2), true)
+ * assert.deepStrictEqual(Equal.equals(mike1, john), false)
+ *
+ * assert.deepStrictEqual(mike1._tag, "Person")
+ *
  * @since 2.0.0
  * @category constructors
  */
 export const TaggedClass = <Tag extends string>(
   tag: Tag
 ): new<A extends Record<string, any>>(
-  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>
-) => Data<A & { readonly _tag: Tag }> => {
+  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
+    : { readonly [P in Exclude<keyof A, keyof Equal.Equal>]: A[P] }
+) => Data<Readonly<A> & { readonly _tag: Tag }> => {
   class Base extends Class<any> {
     readonly _tag = tag
   }
   return Base as any
 }
 
-/**
- * Provides a constructor for a Case Class.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const Class: new<A extends Record<string, any>>(
-  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>
-) => Data<A> = internal.Structural as any
-
 /**
  * @since 2.0.0
  * @category constructors
@@ -143,8 +264,8 @@ export const Structural: new<A>(
  * import * as Data from "effect/Data"
  *
  * type HttpError = Data.TaggedEnum<{
- *   BadRequest: { status: 400, message: string }
- *   NotFound: { status: 404, message: string }
+ *   BadRequest: { readonly status: 400, readonly message: string }
+ *   NotFound: { readonly status: 404, readonly message: string }
  * }>
  *
  * // Equivalent to:
@@ -166,8 +287,9 @@ export const Structural: new<A>(
  */
 export type TaggedEnum<
   A extends Record<string, Record<string, any>> & UntaggedChildren<A>
-> = keyof A extends infer Tag
-  ? Tag extends keyof A ? Data<{ readonly [K in `_tag` | keyof A[Tag]]: K extends `_tag` ? Tag : A[Tag][K] }>
+> = keyof A extends infer Tag ? Tag extends keyof A ? Data<
+      Types.Simplify<{ readonly _tag: Tag } & { readonly [K in keyof A[Tag]]: A[Tag][K] }>
+    >
   : never
   : never
 
@@ -219,20 +341,18 @@ export declare namespace TaggedEnum {
    * @since 2.0.0
    */
   export type Args<
-    A extends Data<{ readonly _tag: string }>,
-    K extends A["_tag"]
-  > = Omit<
-    Extract<A, { readonly _tag: K }>,
-    "_tag" | keyof Case
-  > extends infer T ? {} extends T ? void
-    : T
+    A extends { readonly _tag: string } & Equal.Equal,
+    K extends A["_tag"],
+    E = Extract<A, { readonly _tag: K }>
+  > = { readonly [K in keyof E as K extends "_tag" | keyof Case ? never : K]: E[K] } extends infer T ?
+    {} extends T ? void : T
     : never
 
   /**
    * @since 2.0.0
    */
   export type Value<
-    A extends Data<{ readonly _tag: string }>,
+    A extends { readonly _tag: string } & Equal.Equal,
     K extends A["_tag"]
   > = Extract<A, { readonly _tag: K }>
 }
@@ -246,73 +366,86 @@ export declare namespace TaggedEnum {
  * @example
  * import * as Data from "effect/Data"
  *
- * const HttpError = Data.taggedEnum<
- *   | Data.Data<{ _tag: "BadRequest"; status: 400; message: string }>
- *   | Data.Data<{ _tag: "NotFound"; status: 404; message: string }>
+ * const { BadRequest, NotFound } = Data.taggedEnum<
+ *   | Data.Data<{ readonly _tag: "BadRequest"; readonly status: 400; readonly message: string }>
+ *   | Data.Data<{ readonly _tag: "NotFound"; readonly status: 404; readonly message: string }>
  * >()
  *
- * const notFound = HttpError("NotFound")({ status: 404, message: "Not Found" })
+ * const notFound = NotFound({ status: 404, message: "Not Found" })
  *
  * @example
  * import * as Data from "effect/Data"
  *
  * type MyResult<E, A> = Data.TaggedEnum<{
- *   Failure: { error: E }
- *   Success: { value: A }
+ *   Failure: { readonly error: E }
+ *   Success: { readonly value: A }
  * }>
  * interface MyResultDefinition extends Data.TaggedEnum.WithGenerics<2> {
  *   readonly taggedEnum: MyResult<this["A"], this["B"]>
  * }
- * const MyResult = Data.taggedEnum<MyResultDefinition>()
+ * const { Failure, Success } = Data.taggedEnum<MyResultDefinition>()
  *
- * const success = MyResult("Success")({ value: 1 })
+ * const success = Success({ value: 1 })
  *
  * @category constructors
  * @since 2.0.0
  */
 export const taggedEnum: {
-  <Z extends TaggedEnum.WithGenerics<1>>(): <
-    K extends Z["taggedEnum"]["_tag"]
-  >(
-    tag: K
-  ) => <A>(
-    args: TaggedEnum.Args<TaggedEnum.Kind<Z, A>, K>
-  ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A>, K>
+  <Z extends TaggedEnum.WithGenerics<1>>(): {
+    readonly [Tag in Z["taggedEnum"]["_tag"]]: <A>(
+      args: TaggedEnum.Args<
+        TaggedEnum.Kind<Z, A>,
+        Tag,
+        Extract<TaggedEnum.Kind<Z, A>, { readonly _tag: Tag }>
+      >
+    ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A>, Tag>
+  }
 
-  <Z extends TaggedEnum.WithGenerics<2>>(): <
-    K extends Z["taggedEnum"]["_tag"]
-  >(
-    tag: K
-  ) => <A, B>(
-    args: TaggedEnum.Args<TaggedEnum.Kind<Z, A, B>, K>
-  ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B>, K>
+  <Z extends TaggedEnum.WithGenerics<2>>(): {
+    readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B>(
+      args: TaggedEnum.Args<
+        TaggedEnum.Kind<Z, A, B>,
+        Tag,
+        Extract<TaggedEnum.Kind<Z, A, B>, { readonly _tag: Tag }>
+      >
+    ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B>, Tag>
+  }
 
-  <Z extends TaggedEnum.WithGenerics<3>>(): <
-    K extends Z["taggedEnum"]["_tag"]
-  >(
-    tag: K
-  ) => <A, B, C>(
-    args: TaggedEnum.Args<TaggedEnum.Kind<Z, A, B, C>, K>
-  ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C>, K>
+  <Z extends TaggedEnum.WithGenerics<3>>(): {
+    readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C>(
+      args: TaggedEnum.Args<
+        TaggedEnum.Kind<Z, A, B, C>,
+        Tag,
+        Extract<TaggedEnum.Kind<Z, A, B, C>, { readonly _tag: Tag }>
+      >
+    ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C>, Tag>
+  }
 
-  <Z extends TaggedEnum.WithGenerics<4>>(): <
-    K extends Z["taggedEnum"]["_tag"]
-  >(
-    tag: K
-  ) => <A, B, C, D>(
-    args: TaggedEnum.Args<TaggedEnum.Kind<Z, A, B, C, D>, K>
-  ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C, D>, K>
+  <Z extends TaggedEnum.WithGenerics<4>>(): {
+    readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C, D>(
+      args: TaggedEnum.Args<
+        TaggedEnum.Kind<Z, A, B, C, D>,
+        Tag,
+        Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
+      >
+    ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C, D>, Tag>
+  }
 
-  <A extends Data<{ readonly _tag: string }>>(): <K extends A["_tag"]>(
-    tag: K
-  ) => Case.Constructor<Extract<A, { readonly _tag: K }>, "_tag">
-} = () => tagged as any
+  <A extends { readonly _tag: string } & Equal.Equal>(): {
+    readonly [Tag in A["_tag"]]: Case.Constructor<Extract<A, { readonly _tag: Tag }>, "_tag">
+  }
+} = () =>
+  new Proxy({}, {
+    get(_target, tag, _receiver) {
+      return tagged(tag as string)
+    }
+  }) as any
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface YieldableError extends Case, Pipeable, Error {
+export interface YieldableError extends Case, Pipeable, Readonly<Error> {
   readonly [Effectable.EffectTypeId]: Effect.Effect.VarianceStruct<never, this, never>
   readonly [Effectable.StreamTypeId]: Effect.Effect.VarianceStruct<never, this, never>
   readonly [Effectable.SinkTypeId]: Sink.Sink.VarianceStruct<never, this, unknown, never, never>
@@ -327,21 +460,13 @@ export interface YieldableError extends Case, Pipeable, Error {
   >
 }
 
-const YieldableErrorMessage = Symbol.for("effect/Data/YieldableError/message")
 const YieldableErrorProto = {
   ...Effectable.StructuralCommitPrototype,
-  __proto__: globalThis.Error.prototype,
   commit() {
     return Effect.fail(this)
   },
   toString(this: globalThis.Error) {
     return `${this.name}: ${this.message}`
-  },
-  get message() {
-    return (this as any)[YieldableErrorMessage] ?? JSON.stringify(this)
-  },
-  set message(value: string) {
-    ;(this as any)[YieldableErrorMessage] = value
   }
 }
 
@@ -352,15 +477,16 @@ const YieldableErrorProto = {
  * @category constructors
  */
 export const Error: new<A extends Record<string, any>>(
-  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>
-) => YieldableError & A = (function() {
-  function Base(this: any, args: any) {
-    if (args) {
+  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
+    : { readonly [P in Exclude<keyof A, keyof Equal.Equal>]: A[P] }
+) => YieldableError & Readonly<A> = (function() {
+  class Base extends globalThis.Error {
+    constructor(args: any) {
+      super()
       Object.assign(this, args)
     }
-    globalThis.Error.captureStackTrace(this, this.constructor)
   }
-  Base.prototype = YieldableErrorProto
+  Object.assign(Base.prototype, YieldableErrorProto)
   return Base as any
 })()
 
@@ -369,11 +495,12 @@ export const Error: new<A extends Record<string, any>>(
  * @category constructors
  */
 export const TaggedError = <Tag extends string>(tag: Tag): new<A extends Record<string, any>>(
-  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>
-) => YieldableError & { readonly _tag: Tag } & A => {
+  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
+    : { readonly [P in Exclude<keyof A, keyof Equal.Equal>]: A[P] }
+) => YieldableError & { readonly _tag: Tag } & Readonly<A> => {
   class Base extends Error<{}> {
     readonly _tag = tag
   }
-  Base.prototype.name = tag
+  ;(Base.prototype as any).name = tag
   return Base as any
 }

package/src/List.ts

@@ -710,6 +710,21 @@ export const head = <A>(self: List<A>): Option.Option<A> => isNil(self) ? Option
  */
 export const last = <A>(self: List<A>): Option.Option<A> => isNil(self) ? Option.none() : Option.some(unsafeLast(self)!)
 
+/**
+ * @since 2.0.0
+ */
+export declare namespace List {
+  /**
+   * @since 2.0.0
+   */
+  export type Infer<T extends List<any>> = T extends List<infer A> ? A : never
+
+  /**
+   * @since 2.0.0
+   */
+  export type With<T extends List<any>, A> = T extends Cons<any> ? Cons<A> : List<A>
+}
+
 /**
  * Applies the specified mapping function to each element of the list.
  *
@@ -717,8 +732,8 @@ export const last = <A>(self: List<A>): Option.Option<A> => isNil(self) ? Option
  * @category combinators
  */
 export const map: {
-  <A, B>(f: (a: A) => B): (self: List<A>) => List<B>
-  <A, B>(self: List<A>, f: (a: A) => B): List<B>
+  <T extends List<any>, B>(f: (a: List.Infer<T>, i: number) => B): (self: T) => List.With<T, B>
+  <T extends List<any>, B>(self: T, f: (a: List.Infer<T>, i: number) => B): List.With<T, B>
 } = dual(2, <A, B>(self: List<A>, f: (a: A) => B): List<B> => {
   if (isNil(self)) {
     return self as unknown as List<B>
@@ -736,15 +751,6 @@ export const map: {
   }
 })
 
-/**
- * @since 2.0.0
- * @category combinators
- */
-export const mapNonEmpty: {
-  <A, B>(f: (a: A) => B): (self: Cons<A>) => Cons<B>
-  <A, B>(self: Cons<A>, f: (a: A) => B): Cons<B>
-} = map as any
-
 /**
  * Partition a list into two lists, where the first list contains all elements
  * that did not satisfy the specified predicate, and the second list contains

package/src/Match.ts

@@ -538,7 +538,7 @@ export const exhaustive: <I, F, A, Pr>(
  * @since 1.0.0
  * @category type ids
  */
-export const SafeRefinementId = Symbol.for("./SafeRefinement")
+export const SafeRefinementId = Symbol.for("effect/SafeRefinement")
 
 /**
  * @since 1.0.0
@@ -554,7 +554,7 @@ export interface SafeRefinement<A, R = A> {
   readonly [SafeRefinementId]: (a: A) => R
 }
 
-const Fail = Symbol.for("./Fail")
+const Fail = Symbol.for("effect/Fail")
 type Fail = typeof Fail
 
 /**

package/src/ReadonlyArray.ts

@@ -1508,22 +1508,31 @@ export const empty: <A = never>() => Array<A> = () => []
 export const of = <A>(a: A): NonEmptyArray<A> => [a]
 
 /**
- * @category mapping
  * @since 2.0.0
  */
-export const map: {
-  <A, B>(f: (a: A, i: number) => B): (self: ReadonlyArray<A>) => Array<B>
-  <A, B>(self: ReadonlyArray<A>, f: (a: A, i: number) => B): Array<B>
-} = dual(2, <A, B>(self: ReadonlyArray<A>, f: (a: A, i: number) => B): Array<B> => self.map(f))
+export declare namespace ReadonlyArray {
+  /**
+   * @since 2.0.0
+   */
+  export type Infer<T extends ReadonlyArray<any>> = T[number]
+
+  /**
+   * @since 2.0.0
+   */
+  export type With<T extends ReadonlyArray<any>, A> = T extends NonEmptyReadonlyArray<any> ? NonEmptyArray<A>
+    : Array<A>
+}
 
 /**
  * @category mapping
  * @since 2.0.0
  */
-export const mapNonEmpty: {
-  <A, B>(f: (a: A, i: number) => B): (self: readonly [A, ...Array<A>]) => [B, ...Array<B>]
-  <A, B>(self: readonly [A, ...Array<A>], f: (a: A, i: number) => B): [B, ...Array<B>]
-} = map as any
+export const map: {
+  <T extends ReadonlyArray<any>, B>(
+    f: (a: ReadonlyArray.Infer<T>, i: number) => B
+  ): (self: T) => ReadonlyArray.With<T, B>
+  <T extends ReadonlyArray<any>, B>(self: T, f: (a: ReadonlyArray.Infer<T>, i: number) => B): ReadonlyArray.With<T, B>
+} = dual(2, <A, B>(self: ReadonlyArray<A>, f: (a: A, i: number) => B): Array<B> => self.map(f))
 
 /**
  * @category sequencing

package/src/Struct.ts

@@ -7,6 +7,7 @@
 import * as Equivalence from "./Equivalence"
 import { dual } from "./Function"
 import * as order from "./Order"
+import type { Simplify } from "./Types"
 
 /**
  * Create a new object by picking properties of an existing object.
@@ -22,7 +23,7 @@ import * as order from "./Order"
 export const pick = <S, Keys extends readonly [keyof S, ...Array<keyof S>]>(
   ...keys: Keys
 ) =>
-(s: S): { [K in Keys[number]]: S[K] } => {
+(s: S): Simplify<Pick<S, Keys[number]>> => {
   const out: any = {}
   for (const k of keys) {
     out[k] = s[k]
@@ -44,7 +45,7 @@ export const pick = <S, Keys extends readonly [keyof S, ...Array<keyof S>]>(
 export const omit = <S, Keys extends readonly [keyof S, ...Array<keyof S>]>(
   ...keys: Keys
 ) =>
-(s: S): { [K in Exclude<keyof S, Keys[number]>]: S[K] } => {
+(s: S): Simplify<Omit<S, Keys[number]>> => {
   const out: any = { ...s }
   for (const k of keys) {
     delete out[k]