diff --git a/packages/effect/src/Either.ts b/packages/effect/src/Either.ts
index 65767ae951f..cf82f645599 100644
--- a/packages/effect/src/Either.ts
+++ b/packages/effect/src/Either.ts
@@ -315,9 +315,9 @@ export const getEquivalence = <A, E>({ left, right }: {
   left: Equivalence.Equivalence<E>
 }): Equivalence.Equivalence<Either<A, E>> =>
   Equivalence.make((x, y) =>
-    isLeft(x) ?
-      isLeft(y) && left(x.left, y.left) :
-      isRight(y) && right(x.right, y.right)
+    isRight(x) ?
+      isRight(y) && right(x.right, y.right) :
+      isLeft(y) && left(x.left, y.left)
   )
 
 /**
@@ -338,7 +338,7 @@ export const mapBoth: {
   <A, E, E2, A2>(self: Either<A, E>, { onLeft, onRight }: {
     readonly onLeft: (left: E) => E2
     readonly onRight: (right: A) => A2
-  }): Either<A2, E2> => isLeft(self) ? left(onLeft(self.left)) : right(onRight(self.right))
+  }): Either<A2, E2> => isRight(self) ? right(onRight(self.right)) : left(onLeft(self.left))
 )
 
 /**
@@ -353,7 +353,7 @@ export const mapLeft: {
 } = dual(
   2,
   <A, E, E2>(self: Either<A, E>, f: (left: E) => E2): Either<A, E2> =>
-    isLeft(self) ? left(f(self.left)) : right(self.right)
+    isRight(self) ? right(self.right) : left(f(self.left))
 )
 
 /**
@@ -408,7 +408,7 @@ export const match: {
   <A, E, B, C = B>(self: Either<A, E>, { onLeft, onRight }: {
     readonly onLeft: (left: E) => B
     readonly onRight: (right: A) => C
-  }): B | C => isLeft(self) ? onLeft(self.left) : onRight(self.right)
+  }): B | C => isRight(self) ? onRight(self.right) : onLeft(self.left)
 )
 
 /**
@@ -538,7 +538,7 @@ export const getOrElse: {
   <A, E, A2>(self: Either<A, E>, onLeft: (left: E) => A2): A | A2
 } = dual(
   2,
-  <A, E, A2>(self: Either<A, E>, onLeft: (left: E) => A2): A | A2 => isLeft(self) ? onLeft(self.left) : self.right
+  <A, E, A2>(self: Either<A, E>, onLeft: (left: E) => A2): A | A2 => isRight(self) ? self.right : onLeft(self.left)
 )
 
 /**
@@ -637,7 +637,7 @@ export const orElse: {
 } = dual(
   2,
   <A, E, A2, E2>(self: Either<A, E>, that: (left: E) => Either<A2, E2>): Either<A | A2, E2> =>
-    isLeft(self) ? that(self.left) : right(self.right)
+    isRight(self) ? right(self.right) : that(self.left)
 )
 
 /**
@@ -650,7 +650,7 @@ export const flatMap: {
 } = dual(
   2,
   <A, E, A2, E2>(self: Either<A, E>, f: (right: A) => Either<A2, E2>): Either<A2, E | E2> =>
-    isLeft(self) ? left(self.left) : f(self.right)
+    isRight(self) ? f(self.right) : left(self.left)
 )
 
 /**
@@ -773,7 +773,7 @@ export const all: <const I extends Iterable<Either<any, any>> | Record<string, E
  * @since 2.0.0
  * @category mapping
  */
-export const flip = <A, E>(self: Either<A, E>): Either<E, A> => isLeft(self) ? right(self.left) : left(self.right)
+export const flip = <A, E>(self: Either<A, E>): Either<E, A> => isRight(self) ? left(self.right) : right(self.left)
 
 const adapter = Gen.adapter<EitherTypeLambda>()
 
diff --git a/packages/effect/src/Option.ts b/packages/effect/src/Option.ts
index 9edcb23869f..1772ddeb479 100644
--- a/packages/effect/src/Option.ts
+++ b/packages/effect/src/Option.ts
@@ -310,7 +310,7 @@ export const match: {
   <A, B, C = B>(self: Option<A>, { onNone, onSome }: {
     readonly onNone: LazyArg<B>
     readonly onSome: (a: A) => C
-  }): B | C => isNone(self) ? onNone() : onSome(self.value)
+  }): B | C => isSome(self) ? onSome(self.value) : onNone()
 )
 
 /**
@@ -502,7 +502,7 @@ export const getOrElse: {
   <A, B>(self: Option<A>, onNone: LazyArg<B>): A | B
 } = dual(
   2,
-  <A, B>(self: Option<A>, onNone: LazyArg<B>): A | B => isNone(self) ? onNone() : self.value
+  <A, B>(self: Option<A>, onNone: LazyArg<B>): A | B => isSome(self) ? self.value : onNone()
 )
 
 /**
@@ -546,7 +546,7 @@ export const orElse: {
   <A, B>(self: Option<A>, that: LazyArg<Option<B>>): Option<A | B>
 } = dual(
   2,
-  <A, B>(self: Option<A>, that: LazyArg<Option<B>>): Option<A | B> => isNone(self) ? that() : self
+  <A, B>(self: Option<A>, that: LazyArg<Option<B>>): Option<A | B> => isSome(self) ? self : that()
 )
 
 /**
@@ -583,7 +583,7 @@ export const orElseSome: {
   <A, B>(self: Option<A>, onNone: LazyArg<B>): Option<A | B>
 } = dual(
   2,
-  <A, B>(self: Option<A>, onNone: LazyArg<B>): Option<A | B> => isNone(self) ? some(onNone()) : self
+  <A, B>(self: Option<A>, onNone: LazyArg<B>): Option<A | B> => isSome(self) ? self : some(onNone())
 )
 
 /**
@@ -615,7 +615,7 @@ export const orElseEither: {
 } = dual(
   2,
   <A, B>(self: Option<A>, that: LazyArg<Option<B>>): Option<Either<B, A>> =>
-    isNone(self) ? map(that(), either.right) : map(self, either.left)
+    isSome(self) ? map(self, either.left) : map(that(), either.right)
 )
 
 /**
@@ -925,7 +925,7 @@ export const map: {
   <A, B>(self: Option<A>, f: (a: A) => B): Option<B>
 } = dual(
   2,
-  <A, B>(self: Option<A>, f: (a: A) => B): Option<B> => isNone(self) ? none() : some(f(self.value))
+  <A, B>(self: Option<A>, f: (a: A) => B): Option<B> => isSome(self) ? some(f(self.value)) : none()
 )
 
 /**
@@ -1049,7 +1049,7 @@ export const flatMap: {
   <A, B>(self: Option<A>, f: (a: A) => Option<B>): Option<B>
 } = dual(
   2,
-  <A, B>(self: Option<A>, f: (a: A) => Option<B>): Option<B> => isNone(self) ? none() : f(self.value)
+  <A, B>(self: Option<A>, f: (a: A) => Option<B>): Option<B> => isSome(self) ? f(self.value) : none()
 )
 
 /**
@@ -1148,7 +1148,7 @@ export const flatMapNullable: {
 } = dual(
   2,
   <A, B>(self: Option<A>, f: (a: A) => B | null | undefined): Option<NonNullable<B>> =>
-    isNone(self) ? none() : fromNullable(f(self.value))
+    isSome(self) ? fromNullable(f(self.value)) : none()
 )
 
 /**
@@ -1542,7 +1542,7 @@ export const reduceCompact: {
  * @category Conversions
  * @since 2.0.0
  */
-export const toArray = <A>(self: Option<A>): Array<A> => isNone(self) ? [] : [self.value]
+export const toArray = <A>(self: Option<A>): Array<A> => isSome(self) ? [self.value] : []
 
 /**
  * Splits an `Option` into two `Option`s based on the result of a mapping
@@ -1854,7 +1854,7 @@ export const liftPredicate: { // Note: I intentionally avoid using the NoInfer p
 export const containsWith = <A>(isEquivalent: (self: A, that: A) => boolean): {
   (a: A): (self: Option<A>) => boolean
   (self: Option<A>, a: A): boolean
-} => dual(2, (self: Option<A>, a: A): boolean => isNone(self) ? false : isEquivalent(self.value, a))
+} => dual(2, (self: Option<A>, a: A): boolean => isSome(self) ? isEquivalent(self.value, a) : false)
 
 const _equivalence = Equal.equivalence()
 
@@ -1934,7 +1934,7 @@ export const exists: {
 } = dual(
   2,
   <A, B extends A>(self: Option<A>, refinement: Refinement<A, B>): self is Option<B> =>
-    isNone(self) ? false : refinement(self.value)
+    isSome(self) ? refinement(self.value) : false
 )
 
 // -------------------------------------------------------------------------------------