Breaking Change: change type parameters of Either.left and Either.rig…

…ht, closes #543

dtslint/ts3.4/index.ts

@@ -290,8 +290,8 @@ R.sequence(O.option)(ro1) // $ExpectType Option<Record<"a" | "b", number>>
 
 R.record.compact(do1) // $ExpectType Record<string, number>
 
-R.partitionMapWithKey(d1, (_k: string, n) => E.right<string, number>(n)) // $ExpectType Separated<Record<string, string>, Record<string, number>>
-R.partitionMapWithKey(r1, (_k: 'a' | 'b', n) => E.right<string, number>(n)) // $ExpectType Separated<Record<string, string>, Record<string, number>>
+R.partitionMapWithKey(d1, (_k: string, n): E.Either<string, number> => E.right(n)) // $ExpectType Separated<Record<string, string>, Record<string, number>>
+R.partitionMapWithKey(r1, (_k: 'a' | 'b', n): E.Either<string, number> => E.right(n)) // $ExpectType Separated<Record<string, string>, Record<string, number>>
 
 R.partitionWithKey(d1, (_k: string, n) => n > 2) // $ExpectType Separated<Record<string, number>, Record<string, number>>
 R.partitionWithKey(r1, (_k: 'a' | 'b', n) => n > 2) // $ExpectType Separated<Record<string, number>, Record<string, number>>

src/Apply.ts

@@ -201,15 +201,15 @@ type EnforceNonEmptyRecord<R> = keyof R extends never ? never : R
  *
  * assert.deepStrictEqual(
  *   ado({
- *     a: right<string, number>(1),
- *     b: right<string, boolean>(true)
+ *     a: right(1),
+ *     b: right(true)
  *   }),
  *   right({ a: 1, b: true })
  * )
  * assert.deepStrictEqual(
  *   ado({
- *     a: right<string, number>(1),
- *     b: left<string, number>('error')
+ *     a: right(1),
+ *     b: left('error')
  *   }),
  *   left('error')
  * )

src/Either.ts

@@ -357,7 +357,7 @@ const sequence = <F>(F: Applicative<F>) => <L, A>(ta: Either<L, HKT<F, A>>): HKT
 const chainRec = <L, A, B>(a: A, f: (a: A) => Either<L, Either<A, B>>): Either<L, B> => {
   return tailRec(f(a), e => {
     if (e.isLeft()) {
-      return right(left(e.value))
+      return right<Either<L, B>>(left(e.value))
     } else {
       const r = e.value
       return r.isLeft() ? left(f(r.value)) : right(right(r.value))
@@ -371,7 +371,7 @@ const chainRec = <L, A, B>(a: A, f: (a: A) => Either<L, Either<A, B>>): Either<L
  *
  * @since 1.0.0
  */
-export const left = <L, A>(l: L): Either<L, A> => {
+export const left = <L>(l: L): Either<L, never> => {
   return new Left(l)
 }
 
@@ -381,8 +381,8 @@ export const left = <L, A>(l: L): Either<L, A> => {
  *
  * @since 1.0.0
  */
-export const right = <L, A>(a: A): Either<L, A> => {
-  return new Right<L, A>(a)
+export const right = <A>(a: A): Either<never, A> => {
+  return new Right(a)
 }
 
 const of = right

src/Exception.ts

@@ -69,5 +69,5 @@ export const catchError = <A>(ma: IO<A>, handler: (e: Error) => IO<A>): IO<A> =>
  * @since 1.0.0
  */
 export const tryCatch = <A>(ma: IO<A>): IO<Either<Error, A>> => {
-  return catchError(ma.map<Either<Error, A>>(right), e => io.of(left<Error, A>(e)))
+  return catchError(ma.map<Either<Error, A>>(right), e => io.of(left(e)))
 }

src/TaskEither.ts

@@ -361,8 +361,7 @@ export function taskify<L, R>(f: Function): () => TaskEither<L, R> {
       new Task(
         () =>
           new Promise(resolve => {
-            const cbResolver = (e: L, r: R) =>
-              e != null ? resolve(eitherLeft<L, R>(e)) : resolve(eitherRight<L, R>(r))
+            const cbResolver = (e: L, r: R) => (e != null ? resolve(eitherLeft(e)) : resolve(eitherRight(r)))
             f.apply(null, args.concat(cbResolver))
           })
       )

test/Apply.ts

@@ -9,10 +9,10 @@ import { catOptions, getSetoid } from '../src/Array'
 import { fromEquals } from '../src/Setoid'
 
 describe('Apply', () => {
-  const r1 = right<string, number>(1)
-  const r2 = right<string, number>(2)
-  const foo = left<string, number>('foo')
-  const bar = left<string, number>('bar')
+  const r1 = right(1)
+  const r2 = right(2)
+  const foo = left('foo')
+  const bar = left('bar')
 
   it('applyFirst', () => {
     assert.deepStrictEqual(applyFirst(option)(some(5), some(6)), some(5))