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

package/src/Predicate.ts

@@ -8,7 +8,7 @@ import type { TypeLambda } from "./HKT.js"
  * @category models
  * @since 2.0.0
  */
-export interface Predicate<A> {
+export interface Predicate<in A> {
   (a: A): boolean
 }
 
@@ -24,7 +24,7 @@ export interface PredicateTypeLambda extends TypeLambda {
  * @category models
  * @since 2.0.0
  */
-export interface Refinement<A, B extends A> {
+export interface Refinement<in A, out B extends A> {
   (a: A): a is B
 }
 
@@ -487,6 +487,25 @@ export const isReadonlyRecord: (
   input: unknown
 ) => input is { readonly [x: string | symbol]: unknown } = isRecord
 
+/**
+ * A guard that succeeds when the input is a Promise.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isPromise } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isPromise({}), false)
+ * assert.deepStrictEqual(isPromise(Promise.resolve("hello")), true)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const isPromise = (
+  input: unknown
+): input is Promise<unknown> =>
+  hasProperty(input, "then") && "catch" in input && isFunction(input.then) && isFunction(input.catch)
+
 /**
  * @since 2.0.0
  */

package/src/PrimaryKey.ts

@@ -0,0 +1,23 @@
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const symbol: unique symbol = Symbol.for("effect/PrimaryKey")
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface PrimaryKey {
+  [symbol](): string
+}
+
+/**
+ * @since 2.0.0
+ * @category accessors
+ */
+export const value = (self: PrimaryKey): string => self[symbol]()

package/src/PubSub.ts

@@ -15,18 +15,18 @@ import type * as Scope from "./Scope.js"
  * @since 2.0.0
  * @category models
  */
-export interface PubSub<A> extends Queue.Enqueue<A>, Pipeable {
+export interface PubSub<in out A> extends Queue.Enqueue<A>, Pipeable {
   /**
    * Publishes a message to the `PubSub`, returning whether the message was published
    * to the `PubSub`.
    */
-  readonly publish: (value: A) => Effect.Effect<never, never, boolean>
+  publish(value: A): Effect.Effect<never, never, boolean>
 
   /**
    * Publishes all of the specified messages to the `PubSub`, returning whether they
    * were published to the `PubSub`.
    */
-  readonly publishAll: (elements: Iterable<A>) => Effect.Effect<never, never, boolean>
+  publishAll(elements: Iterable<A>): Effect.Effect<never, never, boolean>
 
   /**
    * Subscribes to receive messages from the `PubSub`. The resulting subscription can

package/src/Queue.ts

@@ -9,6 +9,7 @@ import type * as MutableQueue from "./MutableQueue.js"
 import type * as MutableRef from "./MutableRef.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -46,11 +47,23 @@ export const QueueStrategyTypeId: unique symbol = internal.QueueStrategyTypeId
  */
 export type QueueStrategyTypeId = typeof QueueStrategyTypeId
 
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const BackingQueueTypeId: unique symbol = internal.BackingQueueTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type BackingQueueTypeId = typeof BackingQueueTypeId
+
 /**
  * @since 2.0.0
  * @category models
  */
-export interface Queue<A> extends Enqueue<A>, Dequeue<A>, Pipeable {
+export interface Queue<in out A> extends Enqueue<A>, Dequeue<A>, Pipeable {
   /** @internal */
   readonly queue: BackingQueue<A>
   /** @internal */
@@ -67,16 +80,16 @@ export interface Queue<A> extends Enqueue<A>, Dequeue<A>, Pipeable {
  * @since 2.0.0
  * @category models
  */
-export interface Enqueue<A> extends Queue.EnqueueVariance<A>, BaseQueue, Pipeable {
+export interface Enqueue<in A> extends Queue.EnqueueVariance<A>, BaseQueue, Pipeable {
   /**
    * Places one value in the queue.
    */
-  readonly offer: (value: A) => Effect.Effect<never, never, boolean>
+  offer(value: A): Effect.Effect<never, never, boolean>
 
   /**
    * Places one value in the queue when possible without needing the fiber runtime.
    */
-  readonly unsafeOffer: (value: A) => boolean
+  unsafeOffer(value: A): boolean
 
   /**
    * For Bounded Queue: uses the `BackPressure` Strategy, places the values in
@@ -93,14 +106,14 @@ export interface Enqueue<A> extends Queue.EnqueueVariance<A>, BaseQueue, Pipeabl
    * For Dropping Queue: uses `Dropping` Strategy, It places the values in the
    * queue but if there is no room it will not enqueue them and return false.
    */
-  readonly offerAll: (iterable: Iterable<A>) => Effect.Effect<never, never, boolean>
+  offerAll(iterable: Iterable<A>): Effect.Effect<never, never, boolean>
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface Dequeue<A> extends Queue.DequeueVariance<A>, BaseQueue, Pipeable {
+export interface Dequeue<out A> extends Queue.DequeueVariance<A>, BaseQueue, Pipeable {
   /**
    * Takes the oldest value in the queue. If the queue is empty, this will return
    * a computation that resumes when an item has been added to the queue.
@@ -116,14 +129,14 @@ export interface Dequeue<A> extends Queue.DequeueVariance<A>, BaseQueue, Pipeabl
   /**
    * Takes up to max number of values from the queue.
    */
-  readonly takeUpTo: (max: number) => Effect.Effect<never, never, Chunk.Chunk<A>>
+  takeUpTo(max: number): Effect.Effect<never, never, Chunk.Chunk<A>>
 
   /**
    * Takes a number of elements from the queue between the specified minimum and
    * maximum. If there are fewer than the minimum number of elements available,
    * suspends until at least the minimum number of elements have been collected.
    */
-  readonly takeBetween: (min: number, max: number) => Effect.Effect<never, never, Chunk.Chunk<A>>
+  takeBetween(min: number, max: number): Effect.Effect<never, never, Chunk.Chunk<A>>
 }
 
 /**
@@ -136,12 +149,12 @@ export interface BaseQueue {
   /**
    * Returns the number of elements the queue can hold.
    */
-  readonly capacity: () => number
+  capacity(): number
 
   /**
    * Returns false if shutdown has been called.
    */
-  readonly isActive: () => boolean
+  isActive(): boolean
 
   /**
    * Retrieves the size of the queue, which is equal to the number of elements
@@ -155,7 +168,7 @@ export interface BaseQueue {
    * in the queue. This may be negative if fibers are suspended waiting for
    * elements to be added to the queue. Returns None if shutdown has been called
    */
-  readonly unsafeSize: () => Option.Option<number>
+  unsafeSize(): Option.Option<number>
 
   /**
    * Returns `true` if the `Queue` contains at least one element, `false`
@@ -191,12 +204,12 @@ export interface BaseQueue {
  * @since 2.0.0
  * @category models
  */
-export interface Strategy<A> extends Queue.StrategyVariance<A> {
+export interface Strategy<in out A> extends Queue.StrategyVariance<A> {
   /**
    * Returns the number of surplus values that were unable to be added to the
    * `Queue`
    */
-  readonly surplusSize: () => number
+  surplusSize(): number
 
   /**
    * Determines how the `Queue.Strategy` should shut down when the `Queue` is
@@ -209,68 +222,68 @@ export interface Strategy<A> extends Queue.StrategyVariance<A> {
    * values that could not be added to the `Queue` following an `offer`
    * operation.
    */
-  readonly handleSurplus: (
+  handleSurplus(
     iterable: Iterable<A>,
     queue: BackingQueue<A>,
     takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>,
     isShutdown: MutableRef.MutableRef<boolean>
-  ) => Effect.Effect<never, never, boolean>
+  ): Effect.Effect<never, never, boolean>
 
   /**
    * It is called when the backing queue is empty but there are some
    * takers that can be completed
    */
-  readonly onCompleteTakersWithEmptyQueue: (
+  onCompleteTakersWithEmptyQueue(
     takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
-  ) => void
+  ): void
 
   /**
    * Determines the behavior of the `Queue.Strategy` when the `Queue` has empty
    * slots following a `take` operation.
    */
-  readonly unsafeOnQueueEmptySpace: (
+  unsafeOnQueueEmptySpace(
     queue: BackingQueue<A>,
     takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
-  ) => void
+  ): void
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface BackingQueue<A> {
+export interface BackingQueue<in out A> extends Queue.BackingQueueVariance<A> {
   /**
    * Dequeues an element from the queue.
    * Returns either an element from the queue, or the `def` param.
    */
-  readonly poll: <Def>(def: Def) => A | Def
+  poll<Def>(def: Def): A | Def
   /**
    * Dequeues up to `limit` elements from the queue.
    */
-  readonly pollUpTo: (limit: number) => Chunk.Chunk<A>
+  pollUpTo(limit: number): Chunk.Chunk<A>
   /**
    * Enqueues a collection of values into the queue.
    *
    * Returns a `Chunk` of the values that were **not** able to be enqueued.
    */
-  readonly offerAll: (elements: Iterable<A>) => Chunk.Chunk<A>
+  offerAll(elements: Iterable<A>): Chunk.Chunk<A>
   /**
    * Offers an element to the queue.
    *
    * Returns whether the enqueue was successful or not.
    */
-  readonly offer: (element: A) => boolean
+  offer(element: A): boolean
   /**
    * The **maximum** number of elements that a queue can hold.
    *
    * **Note**: unbounded queues can still implement this interface with
    * `capacity = Infinity`.
    */
-  readonly capacity: () => number
+  capacity(): number
   /**
    * Returns the number of elements currently in the queue
    */
-  readonly length: () => number
+  length(): number
 }
 
 /**
@@ -281,9 +294,9 @@ export declare namespace Queue {
    * @since 2.0.0
    * @category models
    */
-  export interface EnqueueVariance<A> {
+  export interface EnqueueVariance<in A> {
     readonly [EnqueueTypeId]: {
-      readonly _In: (_: A) => void
+      readonly _In: Types.Contravariant<A>
     }
   }
 
@@ -291,9 +304,9 @@ export declare namespace Queue {
    * @since 2.0.0
    * @category models
    */
-  export interface DequeueVariance<A> {
+  export interface DequeueVariance<out A> {
     readonly [DequeueTypeId]: {
-      readonly _Out: (_: never) => A
+      readonly _Out: Types.Covariant<A>
     }
   }
 
@@ -301,9 +314,19 @@ export declare namespace Queue {
    * @since 2.0.0
    * @category models
    */
-  export interface StrategyVariance<A> {
+  export interface StrategyVariance<in out A> {
     readonly [QueueStrategyTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: Types.Invariant<A>
+    }
+  }
+
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface BackingQueueVariance<in out A> {
+    readonly [BackingQueueTypeId]: {
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/Random.ts

@@ -40,16 +40,16 @@ export interface Random {
    * Returns the next numeric value in the specified range from the
    * pseudo-random number generator.
    */
-  readonly nextRange: (min: number, max: number) => Effect.Effect<never, never, number>
+  nextRange(min: number, max: number): Effect.Effect<never, never, number>
   /**
    * Returns the next integer value in the specified range from the
    * pseudo-random number generator.
    */
-  readonly nextIntBetween: (min: number, max: number) => Effect.Effect<never, never, number>
+  nextIntBetween(min: number, max: number): Effect.Effect<never, never, number>
   /**
    * Uses the pseudo-random number generator to shuffle the specified iterable.
    */
-  readonly shuffle: <A>(elements: Iterable<A>) => Effect.Effect<never, never, Chunk.Chunk<A>>
+  shuffle<A>(elements: Iterable<A>): Effect.Effect<never, never, Chunk.Chunk<A>>
 }
 
 /**