Swap Either type params (#2102)

Co-authored-by: Maxwell Brown <maxwellbrown1990@gmail.com>

.changeset/olive-pants-sparkle.md

@@ -0,0 +1,17 @@
+---
+"@effect/platform-node-shared": minor
+"@effect/typeclass": minor
+"effect": minor
+"@effect/schema": minor
+"@effect/cli": minor
+---
+
+Swap type params of Either from `Either<E, A>` to `Either<R, L = never>`.
+
+Along the same line of the other changes this allows to shorten the most common types such as:
+
+```ts
+import { Either } from "effect";
+
+const right: Either.Either<string> = Either.right("ok");
+```

packages/cli/src/Options.ts

@@ -419,8 +419,8 @@ export const orElse: {
  * @category combinators
  */
 export const orElseEither: {
-  <A>(that: Options<A>): <B>(self: Options<B>) => Options<Either<B, A>>
-  <A, B>(self: Options<A>, that: Options<B>): Options<Either<B, A>>
+  <A>(that: Options<A>): <B>(self: Options<B>) => Options<Either<A, B>>
+  <A, B>(self: Options<A>, that: Options<B>): Options<Either<A, B>>
 } = InternalOptions.orElseEither
 
 /**

packages/cli/src/internal/options.ts

@@ -505,8 +505,8 @@ export const orElse = dual<
 export const orElseEither = dual<
   <B>(
     that: Options.Options<B>
-  ) => <A>(self: Options.Options<A>) => Options.Options<Either.Either<A, B>>,
-  <A, B>(self: Options.Options<A>, that: Options.Options<B>) => Options.Options<Either.Either<A, B>>
+  ) => <A>(self: Options.Options<A>) => Options.Options<Either.Either<B, A>>,
+  <A, B>(self: Options.Options<A>, that: Options.Options<B>) => Options.Options<Either.Either<B, A>>
 >(2, (self, that) => makeOrElse(self, that))
 
 /** @internal */
@@ -980,7 +980,7 @@ const makeMap = <A, B>(
 const makeOrElse = <A, B>(
   left: Options.Options<A>,
   right: Options.Options<B>
-): Options.Options<Either.Either<A, B>> => {
+): Options.Options<Either.Either<B, A>> => {
   const op = Object.create(proto)
   op._tag = "OrElse"
   op.left = left

packages/effect/dtslint/Effect.ts

@@ -84,7 +84,7 @@ Effect.all([string, number], { mode: "validate" })
 // $ExpectType Effect<void, [Option<"err-1">, Option<"err-2">], "dep-1" | "dep-2">
 Effect.all([string, number], { mode: "validate", discard: true })
 
-// $ExpectType Effect<[Either<"err-1", string>, Either<"err-2", number>], never, "dep-1" | "dep-2">
+// $ExpectType Effect<[Either<string, "err-1">, Either<number, "err-2">], never, "dep-1" | "dep-2">
 Effect.all([string, number], { mode: "either" })
 
 // $ExpectType Effect<void, never, "dep-1" | "dep-2">
@@ -118,7 +118,7 @@ Effect.all({ a: string, b: number }, { mode: "validate" })
 // $ExpectType Effect<void, { a: Option<"err-1">; b: Option<"err-2">; }, "dep-1" | "dep-2">
 Effect.all({ a: string, b: number }, { mode: "validate", discard: true })
 
-// $ExpectType Effect<{ a: Either<"err-1", string>; b: Either<"err-2", number>; }, never, "dep-1" | "dep-2">
+// $ExpectType Effect<{ a: Either<string, "err-1">; b: Either<number, "err-2">; }, never, "dep-1" | "dep-2">
 Effect.all({ a: string, b: number }, { mode: "either" })
 
 // $ExpectType Effect<void, never, "dep-1" | "dep-2">
@@ -152,7 +152,7 @@ Effect.all(stringArray, { mode: "validate" })
 // $ExpectType Effect<void, Option<"err-3">[], "dep-3">
 Effect.all(stringArray, { mode: "validate", discard: true })
 
-// $ExpectType Effect<Either<"err-3", string>[], never, "dep-3">
+// $ExpectType Effect<Either<string, "err-3">[], never, "dep-3">
 Effect.all(stringArray, { mode: "either" })
 
 // $ExpectType Effect<void, never, "dep-3">
@@ -186,7 +186,7 @@ Effect.all(numberRecord, { mode: "validate" })
 // $ExpectType Effect<void, { [x: string]: Option<"err-4">; }, "dep-4">
 Effect.all(numberRecord, { mode: "validate", discard: true })
 
-// $ExpectType Effect<{ [x: string]: Either<"err-4", number>; }, never, "dep-4">
+// $ExpectType Effect<{ [x: string]: Either<number, "err-4">; }, never, "dep-4">
 Effect.all(numberRecord, { mode: "either" })
 
 // $ExpectType Effect<void, never, "dep-4">
@@ -220,7 +220,7 @@ pipe([string, number] as const, Effect.allWith({ mode: "validate" }))
 // $ExpectType Effect<void, [Option<"err-1">, Option<"err-2">], "dep-1" | "dep-2">
 pipe([string, number] as const, Effect.allWith({ mode: "validate", discard: true }))
 
-// $ExpectType Effect<[Either<"err-1", string>, Either<"err-2", number>], never, "dep-1" | "dep-2">
+// $ExpectType Effect<[Either<string, "err-1">, Either<number, "err-2">], never, "dep-1" | "dep-2">
 pipe([string, number] as const, Effect.allWith({ mode: "either" }))
 
 // $ExpectType Effect<void, never, "dep-1" | "dep-2">
@@ -254,7 +254,7 @@ pipe({ a: string, b: number }, Effect.allWith({ mode: "validate" }))
 // $ExpectType Effect<void, { a: Option<"err-1">; b: Option<"err-2">; }, "dep-1" | "dep-2">
 pipe({ a: string, b: number }, Effect.allWith({ mode: "validate", discard: true }))
 
-// $ExpectType Effect<{ a: Either<"err-1", string>; b: Either<"err-2", number>; }, never, "dep-1" | "dep-2">
+// $ExpectType Effect<{ a: Either<string, "err-1">; b: Either<number, "err-2">; }, never, "dep-1" | "dep-2">
 pipe({ a: string, b: number }, Effect.allWith({ mode: "either" }))
 
 // $ExpectType Effect<void, never, "dep-1" | "dep-2">
@@ -288,7 +288,7 @@ pipe(stringArray, Effect.allWith({ mode: "validate" }))
 // $ExpectType Effect<void, Option<"err-3">[], "dep-3">
 pipe(stringArray, Effect.allWith({ mode: "validate", discard: true }))
 
-// $ExpectType Effect<Either<"err-3", string>[], never, "dep-3">
+// $ExpectType Effect<Either<string, "err-3">[], never, "dep-3">
 pipe(stringArray, Effect.allWith({ mode: "either" }))
 
 // $ExpectType Effect<void, never, "dep-3">
@@ -322,7 +322,7 @@ pipe(numberRecord, Effect.allWith({ mode: "validate" }))
 // $ExpectType Effect<void, { [x: string]: Option<"err-4">; }, "dep-4">
 pipe(numberRecord, Effect.allWith({ mode: "validate", discard: true }))
 
-// $ExpectType Effect<{ [x: string]: Either<"err-4", number>; }, never, "dep-4">
+// $ExpectType Effect<{ [x: string]: Either<number, "err-4">; }, never, "dep-4">
 pipe(numberRecord, Effect.allWith({ mode: "either" }))
 
 // $ExpectType Effect<void, never, "dep-4">

packages/effect/dtslint/Either.ts

@@ -4,161 +4,161 @@ import * as Predicate from "effect/Predicate"
 import * as ReadonlyArray from "effect/ReadonlyArray"
 
 declare const string$string: Either.Either<string, string>
-declare const string$number: Either.Either<string, number>
-declare const string$boolean: Either.Either<string, boolean>
-declare const error$boolean: Either.Either<Error, boolean>
+declare const string$number: Either.Either<number, string>
+declare const string$boolean: Either.Either<boolean, string>
+declare const error$boolean: Either.Either<boolean, Error>
 
-declare const error$a: Either.Either<Error, "a">
+declare const error$a: Either.Either<"a", Error>
 
 declare const predicateUnknown: Predicate.Predicate<unknown>
 
 // -------------------------------------------------------------------------------------
 // flip
 // -------------------------------------------------------------------------------------
 
-// $ExpectType Either<number, string>
+// $ExpectType Either<string, number>
 Either.flip(string$number)
 
 // -------------------------------------------------------------------------------------
 // try
 // -------------------------------------------------------------------------------------
 
-// $ExpectType Either<unknown, number>
+// $ExpectType Either<number, unknown>
 Either.try(() => 1)
 
-// $ExpectType Either<Error, number>
+// $ExpectType Either<number, Error>
 Either.try({ try: () => 1, catch: () => new Error() })
 
 // -------------------------------------------------------------------------------------
 // all - tuple
 // -------------------------------------------------------------------------------------
 
-// $ExpectType Either<never, []>
+// $ExpectType Either<[], never>
 Either.all([])
 
-// $ExpectType Either<string, [number]>
+// $ExpectType Either<[number], string>
 Either.all([string$number])
 
-// $ExpectType Either<string, [number, boolean]>
+// $ExpectType Either<[number, boolean], string>
 Either.all([string$number, string$boolean])
 
-// $ExpectType Either<string | Error, [number, boolean]>
+// $ExpectType Either<[number, boolean], string | Error>
 Either.all([string$number, error$boolean])
 
-// $ExpectType Either<string, [number, boolean]>
+// $ExpectType Either<[number, boolean], string>
 pipe([string$number, string$boolean] as const, Either.all)
 
-// $ExpectType Either<string | Error, [number, boolean]>
+// $ExpectType Either<[number, boolean], string | Error>
 pipe([string$number, error$boolean] as const, Either.all)
 
 // -------------------------------------------------------------------------------------
 // all - struct
 // -------------------------------------------------------------------------------------
 
-// $ExpectType Either<never, {}>
+// $ExpectType Either<{}, never>
 Either.all({})
 
-// $ExpectType Either<string, { a: number; }>
+// $ExpectType Either<{ a: number; }, string>
 Either.all({ a: string$number })
 
-// $ExpectType Either<string, { a: number; b: boolean; }>
+// $ExpectType Either<{ a: number; b: boolean; }, string>
 Either.all({ a: string$number, b: string$boolean })
 
-// $ExpectType Either<string | Error, { a: number; b: boolean; }>
+// $ExpectType Either<{ a: number; b: boolean; }, string | Error>
 Either.all({ a: string$number, b: error$boolean })
 
-// $ExpectType Either<string, { a: number; b: boolean; }>
+// $ExpectType Either<{ a: number; b: boolean; }, string>
 pipe({ a: string$number, b: string$boolean }, Either.all)
 
-// $ExpectType Either<string | Error, { a: number; b: boolean; }>
+// $ExpectType Either<{ a: number; b: boolean; }, string | Error>
 pipe({ a: string$number, b: error$boolean }, Either.all)
 
 // -------------------------------------------------------------------------------------
 // all - array
 // -------------------------------------------------------------------------------------
 
-declare const eitherArray: Array<Either.Either<string, number>>
+declare const eitherArray: Array<Either.Either<number, string>>
 
-// $ExpectType Either<string, number[]>
+// $ExpectType Either<number[], string>
 Either.all(eitherArray)
 
-// $ExpectType Either<string, number[]>
+// $ExpectType Either<number[], string>
 pipe(eitherArray, Either.all)
 
 // -------------------------------------------------------------------------------------
 // all - record
 // -------------------------------------------------------------------------------------
 
-declare const eitherRecord: Record<string, Either.Either<string, number>>
+declare const eitherRecord: Record<string, Either.Either<number, string>>
 
-// $ExpectType Either<string, { [x: string]: number; }>
+// $ExpectType Either<{ [x: string]: number; }, string>
 Either.all(eitherRecord)
 
 // -------------------------------------------------------------------------------------
 // andThen
 // -------------------------------------------------------------------------------------
 
-// $ExpectType Either<string, number>
+// $ExpectType Either<number, string>
 Either.andThen(string$string, string$number)
 
-// $ExpectType Either<string, number>
+// $ExpectType Either<number, string>
 Either.andThen(string$string, () => string$number)
 
-// $ExpectType Either<string, number>
+// $ExpectType Either<number, string>
 string$string.pipe(Either.andThen(string$number))
 
-// $ExpectType Either<string, number>
+// $ExpectType Either<number, string>
 string$string.pipe(Either.andThen(() => string$number))
 
 // -------------------------------------------------------------------------------------
 // filterOrLeft
 // -------------------------------------------------------------------------------------
 
-declare const error$arrayOfStrings: Either.Either<Error, Array<string>>
+declare const error$arrayOfStrings: Either.Either<Array<string>, Error>
 
-// $ExpectType Either<"b" | Error, [string, ...string[]]>
+// $ExpectType Either<[string, ...string[]], "b" | Error>
 pipe(
   error$arrayOfStrings,
   Either.filterOrLeft(ReadonlyArray.isNonEmptyArray, (
     _s // $ExpectType string[]
   ) => "b" as const)
 )
 
-declare const error$readonlyArrayOfStrings: Either.Either<Error, ReadonlyArray<string>>
+declare const error$readonlyArrayOfStrings: Either.Either<ReadonlyArray<string>, Error>
 
-// $ExpectType Either<"b" | Error, readonly [string, ...string[]]>
+// $ExpectType Either<readonly [string, ...string[]], "b" | Error>
 pipe(
   error$readonlyArrayOfStrings,
   Either.filterOrLeft(ReadonlyArray.isNonEmptyReadonlyArray, (
     _s // $ExpectType readonly string[]
   ) => "b" as const)
 )
 
-// $ExpectType Either<"b" | Error, "a">
+// $ExpectType Either<"a", "b" | Error>
 pipe(
   error$a,
   Either.filterOrLeft(Predicate.isString, (
     _s // $ExpectType "a"
   ) => "b" as const)
 )
 
-// $ExpectType Either<"b" | Error, "a">
+// $ExpectType Either<"a", "b" | Error>
 pipe(
   error$a,
   Either.filterOrLeft(Predicate.isString, (
     _s: string
   ) => "b" as const)
 )
 
-// $ExpectType Either<"b" | Error, "a">
+// $ExpectType Either<"a", "b" | Error>
 pipe(
   error$a,
   Either.filterOrLeft(predicateUnknown, (
     _s // $ExpectType "a"
   ) => "b" as const)
 )
 
-// $ExpectType Either<"b" | Error, "a">
+// $ExpectType Either<"a", "b" | Error>
 pipe(
   error$a,
   Either.filterOrLeft(predicateUnknown, (

packages/effect/dtslint/ReadonlyRecord.ts

@@ -132,10 +132,10 @@ ReadonlyRecord.toEntries(brandedRecord)
 // collect
 // -------------------------------------------------------------------------------------
 
-// $ExpectType Either<never, number>[]
+// $ExpectType Either<number, never>[]
 ReadonlyRecord.collect({ a: Either.right(1), b: Either.right(2), c: Either.right(3) }, (_, n) => n)
 
-// $ExpectType Either<never, number>[]
+// $ExpectType Either<number, never>[]
 pipe({ a: Either.right(1), b: Either.right(2), c: Either.right(3) }, ReadonlyRecord.collect((_, n) => n))
 
 // $ExpectType number[]

packages/effect/dtslint/Unify.ts

@@ -5,19 +5,19 @@ import * as Unify from "effect/Unify"
 // $ExpectType Option<string | number>
 export type option = Unify.Unify<Option.Option<number> | Option.Option<string>>
 
-// $ExpectType Either<"LA" | "LB", "RA" | "RB">
-export type either = Unify.Unify<Either.Either<"LA", "RA"> | Either.Either<"LB", "RB">>
+// $ExpectType Either<"RA" | "RB", "LA" | "LB">
+export type either = Unify.Unify<Either.Either<"RA", "LA"> | Either.Either<"RB", "LB">>
 
-// $ExpectType 0 | Option<string | number> | Either<"LA" | "LB", "RA" | "RB">
+// $ExpectType 0 | Option<string | number> | Either<"RA" | "RB", "LA" | "LB">
 export type both = Unify.Unify<
-  Either.Either<"LA", "RA"> | Either.Either<"LB", "RB"> | Option.Option<number> | Option.Option<string> | 0
+  Either.Either<"RA", "LA"> | Either.Either<"RB", "LB"> | Option.Option<number> | Option.Option<string> | 0
 >
 
 // $ExpectType { [k: string]: string; }
 export type obj = Unify.Unify<{ [k: string]: string }>
 
-// $ExpectType <N>(n: N) => Either<string, N>
+// $ExpectType <N>(n: N) => Either<N, string>
 Unify.unify(<N>(n: N) => Math.random() > 0 ? Either.right(n) : Either.left("ok"))
 
-// $ExpectType Either<string, number>
+// $ExpectType Either<number, string>
 Unify.unify(Math.random() > 0 ? Either.right(10) : Either.left("ok"))

packages/effect/mod.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-dirs=(../platform-node-shared/src)
+dirs=(../typeclass/src ../typeclass/test ../typeclass/dtslint)
 for dir in ${dirs[@]};
 do
 echo Refactoring $dir