effect 2.3.8 → 2.4.1

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "2.3.8";
+let moduleVersion = "2.4.1";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "2.3.8",
+  "version": "2.4.1",
   "description": "Functional programming in TypeScript",
   "license": "MIT",
   "repository": {

package/src/BigInt.ts

@@ -545,3 +545,16 @@ export const multiplyAll = (collection: Iterable<bigint>): bigint => {
   }
   return out
 }
+
+/**
+ * Convers a bigint into a number
+ *
+ * @since 2.0.0
+ * @category conversions
+ */
+export const toNumber = (b: bigint): Option.Option<number> => {
+  if (b > BigInt(Number.MAX_SAFE_INTEGER) || b < BigInt(Number.MIN_SAFE_INTEGER)) {
+    return Option.none()
+  }
+  return Option.some(Number(b))
+}

package/src/Brand.ts

@@ -102,7 +102,7 @@ export declare namespace Brand {
      * Constructs a branded type from a value of type `A`, returning `Right<A>`
      * if the provided `A` is valid, `Left<BrandError>` otherwise.
      */
-    either(args: Brand.Unbranded<A>): Either.Either<Brand.BrandErrors, A>
+    either(args: Brand.Unbranded<A>): Either.Either<A, Brand.BrandErrors>
     /**
      * Attempts to refine the provided value of type `A`, returning `true` if
      * the provided `A` is valid, `false` otherwise.
@@ -218,7 +218,7 @@ export const refined: <A extends Brand<any>>(
   refinement: Predicate<Brand.Unbranded<A>>,
   onFailure: (a: Brand.Unbranded<A>) => Brand.BrandErrors
 ): Brand.Constructor<A> => {
-  const either = (args: Brand.Unbranded<A>): Either.Either<Brand.BrandErrors, A> =>
+  const either = (args: Brand.Unbranded<A>): Either.Either<A, Brand.BrandErrors> =>
     refinement(args) ? Either.right(args as A) : Either.left(onFailure(args))
   // @ts-expect-error
   return Object.assign((args) =>
@@ -305,8 +305,8 @@ export const all: <Brands extends readonly [Brand.Constructor<any>, ...Array<Bra
     }[number]
   > extends infer X extends Brand<any> ? X : Brand<any>
 > => {
-  const either = (args: any): Either.Either<Brand.BrandErrors, any> => {
-    let result: Either.Either<Brand.BrandErrors, any> = Either.right(args)
+  const either = (args: any): Either.Either<any, Brand.BrandErrors> => {
+    let result: Either.Either<any, Brand.BrandErrors> = Either.right(args)
     for (const brand of brands) {
       const nextResult = brand.either(args)
       if (Either.isLeft(result) && Either.isLeft(nextResult)) {

package/src/Cause.ts

@@ -577,7 +577,7 @@ export const failureOption: <E>(self: Cause<E>) => Option.Option<E> = internal.f
  * @since 2.0.0
  * @category getters
  */
-export const failureOrCause: <E>(self: Cause<E>) => Either.Either<E, Cause<never>> = internal.failureOrCause
+export const failureOrCause: <E>(self: Cause<E>) => Either.Either<Cause<never>, E> = internal.failureOrCause
 
 /**
  * Converts the specified `Cause<Option<E>>` to an `Option<Cause<E>>` by

package/src/Channel.ts

@@ -388,14 +388,14 @@ export const concatAllWith: <
  * @category utils
  */
 export const concatMap: {
-  <OutElem, OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>(
-    f: (o: OutElem) => Channel<OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>
+  <OutElem, OutElem2, InElem2, OutErr2, InErr2, X, InDone2, Env2>(
+    f: (o: OutElem) => Channel<OutElem2, InElem2, OutErr2, InErr2, X, InDone2, Env2>
   ): <Env, InErr, InElem, InDone, OutErr, OutDone>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<OutElem2, InElem & InElem2, OutErr2 | OutErr, InErr & InErr2, unknown, InDone & InDone2, Env2 | Env>
-  <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, OutElem2, Env2, InErr2, InElem2, InDone2, OutErr2, _>(
+  <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, OutElem2, Env2, InErr2, InElem2, InDone2, OutErr2, X>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (o: OutElem) => Channel<OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>
+    f: (o: OutElem) => Channel<OutElem2, InElem2, OutErr2, InErr2, X, InDone2, Env2>
   ): Channel<OutElem2, InElem & InElem2, OutErr | OutErr2, InErr & InErr2, unknown, InDone & InDone2, Env | Env2>
 } = channel.concatMap
 
@@ -1077,7 +1077,7 @@ export const fromEffect: <A, E, R>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromEither: <E, A>(either: Either.Either<E, A>) => Channel<never, unknown, E, unknown, A, unknown> =
+export const fromEither: <R, L>(either: Either.Either<R, L>) => Channel<never, unknown, L, unknown, R, unknown> =
   channel.fromEither
 
 /**
@@ -1097,7 +1097,7 @@ export const fromInput: <Err, Elem, Done>(
  * @category constructors
  */
 export const fromPubSub: <Done, Err, Elem>(
-  pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
+  pubsub: PubSub.PubSub<Either.Either<Elem, Exit.Exit<Done, Err>>>
 ) => Channel<Elem, unknown, Err, unknown, Done, unknown> = channel.fromPubSub
 
 /**
@@ -1107,7 +1107,7 @@ export const fromPubSub: <Done, Err, Elem>(
  * @category constructors
  */
 export const fromPubSubScoped: <Done, Err, Elem>(
-  pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
+  pubsub: PubSub.PubSub<Either.Either<Elem, Exit.Exit<Done, Err>>>
 ) => Effect.Effect<Channel<Elem, unknown, Err, unknown, Done, unknown>, never, Scope.Scope> = channel.fromPubSubScoped
 
 /**
@@ -1127,7 +1127,7 @@ export const fromOption: <A>(
  * @category constructors
  */
 export const fromQueue: <Done, Err, Elem>(
-  queue: Queue.Dequeue<Either.Either<Exit.Exit<Done, Err>, Elem>>
+  queue: Queue.Dequeue<Either.Either<Elem, Exit.Exit<Done, Err>>>
 ) => Channel<Elem, unknown, Err, unknown, Done, unknown> = channel.fromQueue
 
 /**
@@ -1782,15 +1782,15 @@ export const mapInputContext: {
  * @category context
  */
 export const provideSomeLayer: {
-  <Env2, OutErr2, Env0>(
-    layer: Layer.Layer<Env2, OutErr2, Env0>
+  <R2, OutErr2, Env0>(
+    layer: Layer.Layer<R2, OutErr2, Env0>
   ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, R>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R>
-  ) => Channel<OutElem, InElem, OutErr2 | OutErr, InErr, OutDone, InDone, Env0 | Exclude<R, Env2>>
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, R, Env2, OutErr2, Env0>(
+  ) => Channel<OutElem, InElem, OutErr2 | OutErr, InErr, OutDone, InDone, Env0 | Exclude<R, R2>>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, R, R2, OutErr2, Env0>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R>,
-    layer: Layer.Layer<Env2, OutErr2, Env0>
-  ): Channel<OutElem, InElem, OutErr | OutErr2, InErr, OutDone, InDone, Env0 | Exclude<R, Env2>>
+    layer: Layer.Layer<R2, OutErr2, Env0>
+  ): Channel<OutElem, InElem, OutErr | OutErr2, InErr, OutDone, InDone, Env0 | Exclude<R, R2>>
 } = channel.provideSomeLayer
 
 /**
@@ -1986,7 +1986,7 @@ export const sync: <OutDone>(
  * @category destructors
  */
 export const toPubSub: <Done, Err, Elem>(
-  pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
+  pubsub: PubSub.PubSub<Either.Either<Elem, Exit.Exit<Done, Err>>>
 ) => Channel<never, Elem, never, Err, unknown, Done> = channel.toPubSub
 
 /**
@@ -2000,7 +2000,7 @@ export const toPubSub: <Done, Err, Elem>(
  */
 export const toPull: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
   self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-) => Effect.Effect<Effect.Effect<Either.Either<OutDone, OutElem>, OutErr, Env>, never, Scope.Scope | Env> =
+) => Effect.Effect<Effect.Effect<Either.Either<OutElem, OutDone>, OutErr, Env>, never, Scope.Scope | Env> =
   channel.toPull
 
 /**
@@ -2010,7 +2010,7 @@ export const toPull: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
  * @category destructors
  */
 export const toQueue: <Done, Err, Elem>(
-  queue: Queue.Enqueue<Either.Either<Exit.Exit<Done, Err>, Elem>>
+  queue: Queue.Enqueue<Either.Either<Elem, Exit.Exit<Done, Err>>>
 ) => Channel<never, Elem, never, Err, unknown, Done> = channel.toQueue
 
 /** Converts this channel to a `Sink`.

package/src/Chunk.ts

@@ -934,9 +934,9 @@ export const partition: {
  * @since 2.0.0
  */
 export const partitionMap: {
-  <A, B, C>(f: (a: A) => Either<B, C>): (self: Chunk<A>) => [left: Chunk<B>, right: Chunk<C>]
-  <A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>): [left: Chunk<B>, right: Chunk<C>]
-} = dual(2, <A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>): [left: Chunk<B>, right: Chunk<C>] =>
+  <A, B, C>(f: (a: A) => Either<C, B>): (self: Chunk<A>) => [left: Chunk<B>, right: Chunk<C>]
+  <A, B, C>(self: Chunk<A>, f: (a: A) => Either<C, B>): [left: Chunk<B>, right: Chunk<C>]
+} = dual(2, <A, B, C>(self: Chunk<A>, f: (a: A) => Either<C, B>): [left: Chunk<B>, right: Chunk<C>] =>
   pipe(
     RA.partitionMap(toReadonlyArray(self), f),
     ([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)]
@@ -948,7 +948,7 @@ export const partitionMap: {
  * @category filtering
  * @since 2.0.0
  */
-export const separate = <A, B>(self: Chunk<Either<A, B>>): [Chunk<A>, Chunk<B>] =>
+export const separate = <A, B>(self: Chunk<Either<B, A>>): [Chunk<A>, Chunk<B>] =>
   pipe(
     RA.separate(toReadonlyArray(self)),
     ([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)]

package/src/Config.ts

@@ -55,7 +55,7 @@ export declare namespace Config {
    */
   export interface Primitive<out A> extends Config<A> {
     readonly description: string
-    parse(text: string): Either.Either<ConfigError.ConfigError, A>
+    parse(text: string): Either.Either<A, ConfigError.ConfigError>
   }
 
   /**
@@ -233,8 +233,8 @@ export const mapAttempt: {
  * @category utils
  */
 export const mapOrFail: {
-  <A, B>(f: (a: A) => Either.Either<ConfigError.ConfigError, B>): (self: Config<A>) => Config<B>
-  <A, B>(self: Config<A>, f: (a: A) => Either.Either<ConfigError.ConfigError, B>): Config<B>
+  <A, B>(f: (a: A) => Either.Either<B, ConfigError.ConfigError>): (self: Config<A>) => Config<B>
+  <A, B>(self: Config<A>, f: (a: A) => Either.Either<B, ConfigError.ConfigError>): Config<B>
 } = internal.mapOrFail
 
 /**
@@ -303,7 +303,7 @@ export const option: <A>(self: Config<A>) => Config<Option.Option<A>> = internal
  */
 export const primitive: <A>(
   description: string,
-  parse: (text: string) => Either.Either<ConfigError.ConfigError, A>
+  parse: (text: string) => Either.Either<A, ConfigError.ConfigError>
 ) => Config<A> = internal.primitive
 
 /**

package/src/Cron.ts

@@ -185,7 +185,7 @@ export const isParseError = (u: unknown): u is ParseError => hasProperty(u, Pars
  * @since 2.0.0
  * @category constructors
  */
-export const parse = (cron: string): Either.Either<ParseError, Cron> => {
+export const parse = (cron: string): Either.Either<Cron, ParseError> => {
   const segments = cron.split(" ").filter(String.isNonEmpty)
   if (segments.length !== 5) {
     return Either.left(ParseError(`Invalid number of segments in cron expression`, cron))
@@ -440,7 +440,7 @@ const weekdayOptions: SegmentOptions = {
 const parseSegment = (
   input: string,
   options: SegmentOptions
-): Either.Either<ParseError, ReadonlySet<number>> => {
+): Either.Either<ReadonlySet<number>, ParseError> => {
   const capacity = options.max - options.min + 1
   const values = new Set<number>()
   const fields = input.split(",")

package/src/Differ.ts

@@ -366,14 +366,14 @@ export const orElseEither: {
   <Value2, Patch2>(that: Differ<Value2, Patch2>): <Value, Patch>(
     self: Differ<Value, Patch>
   ) => Differ<
-    Either<Value, Value2>,
+    Either<Value2, Value>,
     Differ.Or.Patch<Value, Value2, Patch, Patch2>
   >
   <Value, Patch, Value2, Patch2>(
     self: Differ<Value, Patch>,
     that: Differ<Value2, Patch2>
   ): Differ<
-    Either<Value, Value2>,
+    Either<Value2, Value>,
     Differ.Or.Patch<Value, Value2, Patch, Patch2>
   >
 } = internal.orElseEither