effect 2.0.0-next.57 → 2.0.0-next.59

package/src/BigDecimal.ts

@@ -64,7 +64,7 @@ const BigDecimalProto: Omit<BigDecimal, "value" | "scale" | "normalized"> = {
     return isBigDecimal(that) && equals(this, that)
   },
   toString(this: BigDecimal) {
-    return format(this)
+    return `BigDecimal(${format(this)})`
   },
   toJSON(this: BigDecimal) {
     return {

package/src/Chunk.ts

@@ -243,9 +243,9 @@ export const make = <As extends readonly [any, ...ReadonlyArray<any>]>(
 export const of = <A>(a: A): NonEmptyChunk<A> => makeChunk({ _tag: "ISingleton", a }) as any
 
 /**
- * Converts from an `Iterable<A>`
+ * Creates a new `Chunk` from an iterable collection of values.
  *
- * @category conversions
+ * @category constructors
  * @since 2.0.0
  */
 export const fromIterable = <A>(self: Iterable<A>): Chunk<A> =>
@@ -562,7 +562,9 @@ export const dropWhile: {
  * @since 2.0.0
  */
 export const prependAll: {
-  <S extends Chunk<any>, T extends Chunk<any>>(that: T): (self: S) => Chunk.With2<S, T, Chunk.Infer<S> | Chunk.Infer<T>>
+  <S extends Chunk<any>, T extends Chunk<any>>(
+    that: T
+  ): (self: S) => Chunk.OrNonEmpty<S, T, Chunk.Infer<S> | Chunk.Infer<T>>
   <A, B>(self: Chunk<A>, that: NonEmptyChunk<B>): NonEmptyChunk<A | B>
   <A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B>
   <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>
@@ -584,7 +586,9 @@ export const prependAll: {
  * @since 2.0.0
  */
 export const appendAll: {
-  <S extends Chunk<any>, T extends Chunk<any>>(that: T): (self: S) => Chunk.With2<S, T, Chunk.Infer<S> | Chunk.Infer<T>>
+  <S extends Chunk<any>, T extends Chunk<any>>(
+    that: T
+  ): (self: S) => Chunk.OrNonEmpty<S, T, Chunk.Infer<S> | Chunk.Infer<T>>
   <A, B>(self: Chunk<A>, that: NonEmptyChunk<B>): NonEmptyChunk<A | B>
   <A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B>
   <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>
@@ -688,7 +692,7 @@ export const compact = <A>(self: Chunk<Option<A>>): Chunk<A> => filterMap(self,
 export const flatMap: {
   <S extends Chunk<any>, T extends Chunk<any>>(
     f: (a: Chunk.Infer<S>, i: number) => T
-  ): (self: S) => Chunk.With2<S, T, Chunk.Infer<T>>
+  ): (self: S) => Chunk.AndNonEmpty<S, T, Chunk.Infer<T>>
   <A, B>(self: NonEmptyChunk<A>, f: (a: A, i: number) => NonEmptyChunk<B>): NonEmptyChunk<B>
   <A, B>(self: Chunk<A>, f: (a: A, i: number) => Chunk<B>): Chunk<B>
 } = dual(2, <A, B>(self: Chunk<A>, f: (a: A, i: number) => Chunk<B>) => {
@@ -720,10 +724,7 @@ export const forEach: {
  * @since 2.0.0
  * @category sequencing
  */
-export const flatten: {
-  <A>(self: NonEmptyChunk<NonEmptyChunk<A>>): NonEmptyChunk<A>
-  <A>(self: Chunk<Chunk<A>>): Chunk<A>
-} = flatMap(identity) as any
+export const flatten: <S extends Chunk<Chunk<any>>>(self: S) => Chunk.Flatten<S> = flatMap(identity) as any
 
 /**
  * Groups elements in chunks of up to `n` elements.
@@ -840,9 +841,25 @@ export declare namespace Chunk {
   /**
    * @since 2.0.0
    */
-  export type With2<S extends Chunk<any>, T extends Chunk<any>, A> = S extends NonEmptyChunk<any> ? NonEmptyChunk<A>
+  export type OrNonEmpty<S extends Chunk<any>, T extends Chunk<any>, A> = S extends NonEmptyChunk<any> ?
+    NonEmptyChunk<A>
     : T extends NonEmptyChunk<any> ? NonEmptyChunk<A>
     : Chunk<A>
+
+  /**
+   * @since 2.0.0
+   */
+  export type AndNonEmpty<S extends Chunk<any>, T extends Chunk<any>, A> = S extends NonEmptyChunk<any> ?
+    T extends NonEmptyChunk<any> ? NonEmptyChunk<A>
+    : Chunk<A> :
+    Chunk<A>
+
+  /**
+   * @since 2.0.0
+   */
+  export type Flatten<T extends Chunk<Chunk<any>>> = T extends NonEmptyChunk<NonEmptyChunk<infer A>> ? NonEmptyChunk<A>
+    : T extends Chunk<Chunk<infer A>> ? Chunk<A>
+    : never
 }
 
 /**
@@ -949,7 +966,7 @@ export const size = <A>(self: Chunk<A>): number => self.length
  * Sort the elements of a Chunk in increasing order, creating a new Chunk.
  *
  * @since 2.0.0
- * @category elements
+ * @category sorting
  */
 export const sort: {
   <B>(O: Order.Order<B>): <A extends B>(self: Chunk<A>) => Chunk<A>
@@ -961,7 +978,7 @@ export const sort: {
 
 /**
  * @since 2.0.0
- * @category elements
+ * @category sorting
  */
 export const sortWith: {
   <A, B>(f: (a: A) => B, order: Order.Order<B>): (self: Chunk<A>) => Chunk<A>
@@ -975,18 +992,35 @@ export const sortWith: {
  *  Returns two splits of this chunk at the specified index.
  *
  * @since 2.0.0
- * @category elements
+ * @category splitting
  */
 export const splitAt: {
   (n: number): <A>(self: Chunk<A>) => [beforeIndex: Chunk<A>, fromIndex: Chunk<A>]
   <A>(self: Chunk<A>, n: number): [beforeIndex: Chunk<A>, fromIndex: Chunk<A>]
 } = dual(2, <A>(self: Chunk<A>, n: number): [Chunk<A>, Chunk<A>] => [take(self, n), drop(self, n)])
 
+/**
+ * Splits a `NonEmptyChunk` into two segments, with the first segment containing a maximum of `n` elements.
+ * The value of `n` must be `>= 1`.
+ *
+ * @category splitting
+ * @since 2.0.0
+ */
+export const splitNonEmptyAt: {
+  (n: number): <A>(self: NonEmptyChunk<A>) => [beforeIndex: NonEmptyChunk<A>, fromIndex: Chunk<A>]
+  <A>(self: NonEmptyChunk<A>, n: number): [beforeIndex: NonEmptyChunk<A>, fromIndex: Chunk<A>]
+} = dual(2, <A>(self: NonEmptyChunk<A>, n: number): [Chunk<A>, Chunk<A>] => {
+  const _n = Math.max(1, Math.floor(n))
+  return _n >= self.length ?
+    [self, empty()] :
+    [take(self, _n), drop(self, _n)]
+})
+
 /**
  * Splits this chunk into `n` equally sized chunks.
  *
  * @since 2.0.0
- * @category elements
+ * @category splitting
  */
 export const split: {
   (n: number): <A>(self: Chunk<A>) => Chunk<Chunk<A>>
@@ -995,8 +1029,9 @@ export const split: {
 
 /**
  * Splits this chunk on the first element that matches this predicate.
+ * Returns a tuple containing two chunks: the first one is before the match, and the second one is from the match onward.
  *
- * @category elements
+ * @category splitting
  * @since 2.0.0
  */
 export const splitWhere: {

package/src/Config.ts

@@ -3,7 +3,6 @@
  */
 import type * as Chunk from "./Chunk.js"
 import type * as ConfigError from "./ConfigError.js"
-import type * as ConfigSecret from "./ConfigSecret.js"
 import type * as Either from "./Either.js"
 import type { LazyArg } from "./Function.js"
 import type * as HashMap from "./HashMap.js"
@@ -13,6 +12,7 @@ import type * as LogLevel from "./LogLevel.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
+import type * as Secret from "./Secret.js"
 import type * as Types from "./Types.js"
 
 /**
@@ -300,7 +300,7 @@ export const repeat: <A>(self: Config<A>) => Config<Array<A>> = internal.repeat
  * @since 2.0.0
  * @category constructors
  */
-export const secret: (name?: string) => Config<ConfigSecret.ConfigSecret> = internal.secret
+export const secret: (name?: string) => Config<Secret.Secret> = internal.secret
 
 /**
  * Constructs a config for a sequence of values.

package/src/Differ.ts

@@ -14,6 +14,7 @@ import * as ContextPatch from "./internal/differ/contextPatch.js"
 import * as HashMapPatch from "./internal/differ/hashMapPatch.js"
 import * as HashSetPatch from "./internal/differ/hashSetPatch.js"
 import * as OrPatch from "./internal/differ/orPatch.js"
+import * as ReadonlyArrayPatch from "./internal/differ/readonlyArrayPatch.js"
 import type * as Types from "./Types.js"
 
 /**
@@ -63,6 +64,8 @@ const ContextPatchTypeId: unique symbol = ContextPatch.ContextPatchTypeId as Dif
 const HashMapPatchTypeId: unique symbol = HashMapPatch.HashMapPatchTypeId as Differ.HashMap.TypeId
 const HashSetPatchTypeId: unique symbol = HashSetPatch.HashSetPatchTypeId as Differ.HashSet.TypeId
 const OrPatchTypeId: unique symbol = OrPatch.OrPatchTypeId as Differ.Or.TypeId
+const ReadonlyArrayPatchTypeId: unique symbol = ReadonlyArrayPatch
+  .ReadonlyArrayPatchTypeId as Differ.ReadonlyArray.TypeId
 
 /**
  * @since 2.0.0
@@ -186,6 +189,29 @@ export declare namespace Differ {
       }
     }
   }
+
+  /**
+   * @since 2.0.0
+   */
+  export namespace ReadonlyArray {
+    /**
+     * @since 2.0.0
+     * @category symbol
+     */
+    export type TypeId = typeof ReadonlyArrayPatchTypeId
+    /**
+     * A patch which describes updates to a ReadonlyArray of values.
+     *
+     * @since 2.0.0
+     * @category models
+     */
+    export interface Patch<in out Value, in out Patch> extends Equal {
+      readonly [ReadonlyArrayPatchTypeId]: {
+        readonly _Value: Types.Invariant<Value>
+        readonly _Patch: Types.Invariant<Patch>
+      }
+    }
+  }
 }
 
 /**
@@ -352,6 +378,16 @@ export const orElseEither: {
   >
 } = internal.orElseEither
 
+/**
+ * Constructs a differ that knows how to diff a `ReadonlyArray` of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const readonlyArray: <Value, Patch>(
+  differ: Differ<Value, Patch>
+) => Differ<ReadonlyArray<Value>, Differ.ReadonlyArray.Patch<Value, Patch>> = internal.readonlyArray
+
 /**
  * Transforms the type of values that this differ knows how to differ using
  * the specified functions that map the new and old value types to each other.

package/src/Effect.ts

@@ -7,6 +7,7 @@ import type * as Clock from "./Clock.js"
 import type { Config } from "./Config.js"
 import type { ConfigError } from "./ConfigError.js"
 import type { ConfigProvider } from "./ConfigProvider.js"
+import type { Console } from "./Console.js"
 import type * as Context from "./Context.js"
 import type * as Deferred from "./Deferred.js"
 import type * as Duration from "./Duration.js"
@@ -25,6 +26,7 @@ import { dual, identity } from "./Function.js"
 import type * as HashMap from "./HashMap.js"
 import type * as HashSet from "./HashSet.js"
 import type { TypeLambda } from "./HKT.js"
+import * as _console from "./internal/console.js"
 import * as effect from "./internal/core-effect.js"
 import * as core from "./internal/core.js"
 import * as defaultServices from "./internal/defaultServices.js"
@@ -2828,6 +2830,49 @@ export const withClock: {
   <R, E, A extends Clock.Clock>(effect: Effect<R, E, A>, value: A): Effect<R, E, A>
 } = defaultServices.withClock
 
+// -------------------------------------------------------------------------------------
+// console
+// -------------------------------------------------------------------------------------
+
+/**
+ * Retreives the `Console` service from the context
+ *
+ * @since 2.0.0
+ * @category console
+ */
+export const console: Effect<never, never, Console> = _console.console
+
+/**
+ * Retreives the `Console` service from the context and provides it to the
+ * specified effectful function.
+ *
+ * @since 2.0.0
+ * @category console
+ */
+export const consoleWith: <R, E, A>(f: (console: Console) => Effect<R, E, A>) => Effect<R, E, A> = _console.consoleWith
+
+/**
+ * Sets the implementation of the clock service to the specified value and
+ * restores it to its original value when the scope is closed.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const withConsoleScoped: <A extends Console>(console: A) => Effect<Scope.Scope, never, void> =
+  _console.withConsoleScoped
+
+/**
+ * Executes the specified workflow with the specified implementation of the
+ * console service.
+ *
+ * @since 2.0.0
+ * @category console
+ */
+export const withConsole: {
+  <A extends Console>(console: A): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>
+  <R, E, A extends Console>(effect: Effect<R, E, A>, console: A): Effect<R, E, A>
+} = _console.withConsole
+
 // ---------------------------------------------------------------------------------------
 // delays & timeouts
 // ---------------------------------------------------------------------------------------
@@ -4544,17 +4589,6 @@ export const labelMetrics: {
   <R, E, A>(self: Effect<R, E, A>, labels: Iterable<MetricLabel.MetricLabel>): Effect<R, E, A>
 } = effect.labelMetrics
 
-/**
- * Tags each metric in this effect with the specific tag.
- *
- * @since 2.0.0
- * @category metrics
- */
-export const labelMetricsSet: {
-  (labels: HashSet.HashSet<MetricLabel.MetricLabel>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
-  <R, E, A>(self: Effect<R, E, A>, labels: HashSet.HashSet<MetricLabel.MetricLabel>): Effect<R, E, A>
-} = effect.labelMetricsSet
-
 /**
  * Tags each metric in a scope with a the specific tag.
  *
@@ -4574,23 +4608,13 @@ export const labelMetricsScoped: (
   labels: ReadonlyArray<MetricLabel.MetricLabel>
 ) => Effect<Scope.Scope, never, void> = fiberRuntime.labelMetricsScoped
 
-/**
- * Tags each metric in a scope with a the specific tag.
- *
- * @since 2.0.0
- * @category metrics
- */
-export const labelMetricsScopedSet: (
-  labels: HashSet.HashSet<MetricLabel.MetricLabel>
-) => Effect<Scope.Scope, never, void> = fiberRuntime.labelMetricsScopedSet
-
 /**
  * Retrieves the metric labels associated with the current scope.
  *
  * @since 2.0.0
  * @category metrics
  */
-export const metricLabels: Effect<never, never, HashSet.HashSet<MetricLabel.MetricLabel>> = core.metricLabels
+export const metricLabels: Effect<never, never, ReadonlyArray<MetricLabel.MetricLabel>> = core.metricLabels
 
 /**
  * @since 2.0.0

package/src/FiberRef.ts

@@ -371,7 +371,7 @@ export const currentSupervisor: FiberRef<Supervisor.Supervisor<any>> = fiberRunt
  * @since 2.0.0
  * @category fiberRefs
  */
-export const currentMetricLabels: FiberRef<HashSet.HashSet<MetricLabel.MetricLabel>> = core.currentMetricLabels
+export const currentMetricLabels: FiberRef<ReadonlyArray<MetricLabel.MetricLabel>> = core.currentMetricLabels
 
 /**
  * @since 2.0.0

package/src/FiberRefs.ts

@@ -123,7 +123,7 @@ export const setAll: (self: FiberRefs) => Effect.Effect<never, never, void> = in
  * @since 2.0.0
  * @category utils
  */
-export const updatedAs: {
+export const updateAs: {
   <A>(
     options: {
       readonly fiberId: FiberId.Runtime
@@ -139,7 +139,51 @@ export const updatedAs: {
       readonly value: A
     }
   ): FiberRefs
-} = internal.updatedAs
+} = internal.updateAs
+
+/**
+ * Updates the values of the specified `FiberRef` & value pairs using the provided `FiberId`
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateManyAs: {
+  (
+    options: {
+      readonly forkAs?: FiberId.Runtime | undefined
+      readonly entries: readonly [
+        readonly [
+          FiberRef.FiberRef<any>,
+          readonly [readonly [FiberId.Runtime, any], ...Array<readonly [FiberId.Runtime, any]>]
+        ],
+        ...Array<
+          readonly [
+            FiberRef.FiberRef<any>,
+            readonly [readonly [FiberId.Runtime, any], ...Array<readonly [FiberId.Runtime, any]>]
+          ]
+        >
+      ]
+    }
+  ): (self: FiberRefs) => FiberRefs
+  (
+    self: FiberRefs,
+    options: {
+      readonly forkAs?: FiberId.Runtime | undefined
+      readonly entries: readonly [
+        readonly [
+          FiberRef.FiberRef<any>,
+          readonly [readonly [FiberId.Runtime, any], ...Array<readonly [FiberId.Runtime, any]>]
+        ],
+        ...Array<
+          readonly [
+            FiberRef.FiberRef<any>,
+            readonly [readonly [FiberId.Runtime, any], ...Array<readonly [FiberId.Runtime, any]>]
+          ]
+        >
+      ]
+    }
+  ): FiberRefs
+} = internal.updateManyAs
 
 /**
  * Note: it will not copy the provided Map, make sure to provide a fresh one.

package/src/HashMap.ts

@@ -98,7 +98,7 @@ export const make: <Entries extends ReadonlyArray<readonly [any, any]>>(
 > = HM.make
 
 /**
- * Constructs a new `HashMap` from an iterable of key/value pairs.
+ * Creates a new `HashMap` from an iterable collection of key/value pairs.
  *
  * @since 2.0.0
  * @category constructors

package/src/HashSet.ts

@@ -42,7 +42,7 @@ export const isHashSet: {
 export const empty: <A = never>() => HashSet<A> = HS.empty
 
 /**
- * Construct a new `HashSet` from a `Collection` of values
+ * Creates a new `HashSet` from an iterable collection of values.
  *
  * @since 2.0.0
  * @category constructors

package/src/Inspectable.ts

@@ -41,5 +41,7 @@ export const toJSON = (x: unknown): unknown => {
   return x
 }
 
-/** @internal */
+/**
+ * @since 2.0.0
+ */
 export const format = (x: unknown): string => JSON.stringify(x, null, 2)

package/src/Layer.ts

@@ -93,6 +93,32 @@ export declare namespace Layer {
   export type Success<T extends Layer<any, any, never>> = [T] extends [Layer<infer _R, infer _E, infer _A>] ? _A : never
 }
 
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const MemoMapTypeId: unique symbol = internal.MemoMapTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type MemoMapTypeId = typeof MemoMapTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface MemoMap {
+  readonly [MemoMapTypeId]: MemoMapTypeId
+
+  /** @internal */
+  readonly getOrElseMemoize: <RIn, E, ROut>(
+    layer: Layer<RIn, E, ROut>,
+    scope: Scope.Scope
+  ) => Effect.Effect<RIn, E, Context.Context<ROut>>
+}
+
 /**
  * Returns `true` if the specified value is a `Layer`, `false` otherwise.
  *
@@ -984,3 +1010,34 @@ export const withParentSpan: {
   (span: Tracer.ParentSpan): <R, E, A>(self: Layer<R, E, A>) => Layer<Exclude<R, Tracer.ParentSpan>, E, A>
   <R, E, A>(self: Layer<R, E, A>, span: Tracer.ParentSpan): Layer<Exclude<R, Tracer.ParentSpan>, E, A>
 } = internal.withParentSpan
+
+// -----------------------------------------------------------------------------
+// memo map
+// -----------------------------------------------------------------------------
+
+/**
+ * Constructs a `MemoMap` that can be used to build additional layers.
+ *
+ * @since 2.0.0
+ * @category memo map
+ */
+export const makeMemoMap: Effect.Effect<never, never, MemoMap> = internal.makeMemoMap
+
+/**
+ * Builds a layer into an `Effect` value, using the specified `MemoMap` to memoize
+ * the layer construction.
+ *
+ * @since 2.0.0
+ * @category memo map
+ */
+export const buildWithMemoMap: {
+  (
+    memoMap: MemoMap,
+    scope: Scope.Scope
+  ): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Effect.Effect<RIn, E, Context.Context<ROut>>
+  <RIn, E, ROut>(
+    self: Layer<RIn, E, ROut>,
+    memoMap: MemoMap,
+    scope: Scope.Scope
+  ): Effect.Effect<RIn, E, Context.Context<ROut>>
+} = internal.buildWithMemoMap

package/src/List.ts

@@ -274,7 +274,7 @@ export const empty = nil
 export const of = <A>(value: A): Cons<A> => makeCons(value, _Nil)
 
 /**
- * Constructs a new `List<A>` from the specified `Iterable<A>`.
+ * Creates a new `List` from an iterable collection of values.
  *
  * @since 2.0.0
  * @category constructors
@@ -333,7 +333,7 @@ export const append: {
  * @since 2.0.0
  */
 export const appendAll: {
-  <S extends List<any>, T extends List<any>>(that: T): (self: S) => List.With2<S, T, List.Infer<S> | List.Infer<T>>
+  <S extends List<any>, T extends List<any>>(that: T): (self: S) => List.OrNonEmpty<S, T, List.Infer<S> | List.Infer<T>>
   <A, B>(self: List<A>, that: Cons<B>): Cons<A | B>
   <A, B>(self: Cons<A>, that: List<B>): Cons<A | B>
   <A, B>(self: List<A>, that: List<B>): List<A | B>
@@ -366,7 +366,7 @@ export const prepend: {
  * @since 2.0.0
  */
 export const prependAll: {
-  <S extends List<any>, T extends List<any>>(that: T): (self: S) => List.With2<S, T, List.Infer<S> | List.Infer<T>>
+  <S extends List<any>, T extends List<any>>(that: T): (self: S) => List.OrNonEmpty<S, T, List.Infer<S> | List.Infer<T>>
   <A, B>(self: List<A>, that: Cons<B>): Cons<A | B>
   <A, B>(self: Cons<A>, that: List<B>): Cons<A | B>
   <A, B>(self: List<A>, that: List<B>): List<A | B>
@@ -641,7 +641,7 @@ export const findFirst: {
 export const flatMap: {
   <S extends List<any>, T extends List<any>>(
     f: (a: List.Infer<S>, i: number) => T
-  ): (self: S) => List.With2<S, T, List.Infer<T>>
+  ): (self: S) => List.AndNonEmpty<S, T, List.Infer<T>>
   <A, B>(self: Cons<A>, f: (a: A, i: number) => Cons<B>): Cons<B>
   <A, B>(self: List<A>, f: (a: A, i: number) => List<B>): List<B>
 } = dual(2, <A, B>(self: List<A>, f: (a: A) => List<B>): List<B> => {
@@ -710,19 +710,27 @@ export declare namespace List {
   /**
    * @since 2.0.0
    */
-  export type Infer<T extends List<any>> = T extends List<infer A> ? A : never
+  export type Infer<S extends List<any>> = S 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>
+  export type With<S extends List<any>, A> = S extends Cons<any> ? Cons<A> : List<A>
 
   /**
    * @since 2.0.0
    */
-  export type With2<S extends List<any>, T extends List<any>, A> = S extends Cons<any> ? Cons<A>
+  export type OrNonEmpty<S extends List<any>, T extends List<any>, A> = S extends Cons<any> ? Cons<A>
     : T extends Cons<any> ? Cons<A>
     : List<A>
+
+  /**
+   * @since 2.0.0
+   */
+  export type AndNonEmpty<S extends List<any>, T extends List<any>, A> = S extends Cons<any> ?
+    T extends Cons<any> ? Cons<A>
+    : List<A> :
+    List<A>
 }
 
 /**
@@ -732,8 +740,8 @@ export declare namespace List {
  * @category mapping
  */
 export const map: {
-  <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>
+  <S extends List<any>, B>(f: (a: List.Infer<S>, i: number) => B): (self: S) => List.With<S, B>
+  <S extends List<any>, B>(self: S, f: (a: List.Infer<S>, i: number) => B): List.With<S, B>
 } = dual(2, <A, B>(self: List<A>, f: (a: A, i: number) => B): List<B> => {
   if (isNil(self)) {
     return self as unknown as List<B>