Add all the typeclasses instance for the zio.prelude.data.Optional type (copied from the Option instances)

core/shared/src/main/scala/zio/prelude/AssociativeBoth.scala

@@ -18,6 +18,7 @@ package zio.prelude
 
 import zio._
 import zio.prelude.coherent.CovariantIdentityBoth
+import zio.prelude.data.Optional
 import zio.prelude.newtypes.{AndF, Failure, OrF}
 import zio.stm.ZSTM
 import zio.stream.{ZSink, ZStream}
@@ -1185,9 +1186,31 @@ object AssociativeBoth extends AssociativeBothLowPriority {
         Some(())
 
       def both[A, B](fa: => Option[A], fb: => Option[B]): Option[(A, B)] =
-        (fa, fb) match {
-          case (Some(a), Some(b)) => Some((a, b))
-          case _                  => None
+        fa match {
+          case Some(a) =>
+            fb match {
+              case Some(b) => Some((a, b))
+              case None    => None
+            }
+          case None    => None
+        }
+    }
+
+  /**
+   * The [[IdentityBoth]] (with [[AssociativeBoth]]) instance for [[Optional]].
+   */
+  implicit val OptionalIdentityBoth: IdentityBoth[Optional] =
+    new IdentityBoth[Optional] {
+      val any: Optional[Any] = Optional.Present(())
+
+      def both[A, B](fa: => Optional[A], fb: => Optional[B]): Optional[(A, B)] =
+        fa match {
+          case Optional.Present(a) =>
+            fb match {
+              case Optional.Present(b) => Optional.Present((a, b))
+              case Optional.Absent     => Optional.Absent
+            }
+          case Optional.Absent     => Optional.Absent
         }
     }
 

core/shared/src/main/scala/zio/prelude/AssociativeEither.scala

@@ -17,6 +17,7 @@
 package zio.prelude
 
 import zio._
+import zio.prelude.data.Optional
 import zio.prelude.newtypes.Failure
 import zio.stream.ZStream
 
@@ -157,6 +158,17 @@ object AssociativeEither {
         None
     }
 
+  /**
+   * The [[IdentityEither]] (and [[AssociativeEither]]) instance for [[Optional]].
+   */
+  implicit val OptionalIdentityEither: IdentityEither[Optional] =
+    new IdentityEither[Optional] {
+      def either[A, B](fa: => Optional[A], fb: => Optional[B]): Optional[Either[A, B]] =
+        fa.map(Left(_)) orElse fb.map(Right(_))
+
+      val none: Optional[Nothing] = Optional.Absent
+    }
+
   /**
    * The `AssociativeEither` instance for `Schedule`.
    */

core/shared/src/main/scala/zio/prelude/AssociativeFlatten.scala

@@ -17,6 +17,7 @@
 package zio.prelude
 
 import zio._
+import zio.prelude.data.Optional
 import zio.stm.ZSTM
 import zio.stream.ZStream
 
@@ -162,6 +163,16 @@ object AssociativeFlatten {
       def flatten[A](ffa: Option[Option[A]]): Option[A] = ffa.flatten
     }
 
+  /**
+   * The [[AssociativeFlatten]] and [[IdentityFlatten]] instance for [[Optional]].
+   */
+  implicit val OptionalIdentityFlatten: IdentityFlatten[Optional] =
+    new IdentityFlatten[Optional] {
+      def any: Optional[Any] = Optional.Present(())
+
+      def flatten[A](ffa: Optional[Optional[A]]): Optional[A] = ffa.flatten
+    }
+
   /**
    * The `AssociativeFlatten` and `IdentityFlatten` instance for `Try`.
    */

core/shared/src/main/scala/zio/prelude/CommutativeBoth.scala

@@ -17,6 +17,7 @@
 package zio.prelude
 
 import zio._
+import zio.prelude.data.Optional
 import zio.prelude.newtypes.{AndF, Failure, OrF}
 import zio.stream.{ZSink, ZStream}
 
@@ -84,9 +85,29 @@ object CommutativeBoth {
   implicit val OptionCommutativeBoth: CommutativeBoth[Option] =
     new CommutativeBoth[Option] {
       def both[A, B](fa: => Option[A], fb: => Option[B]): Option[(A, B)] =
-        (fa, fb) match {
-          case (Some(a), Some(b)) => Some((a, b))
-          case _                  => None
+        fa match {
+          case Some(a) =>
+            fb match {
+              case Some(b) => Some((a, b))
+              case None    => None
+            }
+          case None    => None
+        }
+    }
+
+  /**
+   * The [[CommutativeBoth]] instance for [[Optional]].
+   */
+  implicit val OptionalCommutativeBoth: CommutativeBoth[Optional] =
+    new CommutativeBoth[Optional] {
+      def both[A, B](fa: => Optional[A], fb: => Optional[B]): Optional[(A, B)] =
+        fa match {
+          case Optional.Present(a) =>
+            fb match {
+              case Optional.Present(b) => Optional.Present((a, b))
+              case Optional.Absent     => Optional.Absent
+            }
+          case Optional.Absent     => Optional.Absent
         }
     }
 

core/shared/src/main/scala/zio/prelude/Derive.scala

@@ -16,6 +16,7 @@
 
 package zio.prelude
 
+import zio.prelude.data.Optional
 import zio.{Cause, Chunk, Exit, NonEmptyChunk}
 
 import scala.util.Try
@@ -100,6 +101,15 @@ object Derive {
         Equal.OptionEqual
     }
 
+  /**
+   * The [[DeriveEqual]] instance for [[Optional]].
+   */
+  implicit val OptionalDeriveEqual: DeriveEqual[Optional] =
+    new DeriveEqual[Optional] {
+      def derive[A: Equal]: Equal[Optional[A]] =
+        Equal.OptionalEqual
+    }
+
   /**
    * The `DeriveEqual` instance for `ParSeq`.
    */

core/shared/src/main/scala/zio/prelude/Equal.scala

@@ -18,7 +18,8 @@ package zio.prelude
 
 import zio.Exit.{Failure, Success}
 import zio.prelude.coherent.{HashOrd, HashPartialOrd}
-import zio.{Cause, Chunk, Duration => ZIODuration, Exit, FiberId, NonEmptyChunk, StackTrace}
+import zio.prelude.data.Optional
+import zio.{Cause, Chunk, Exit, FiberId, NonEmptyChunk, StackTrace, Duration => ZIODuration}
 
 import scala.annotation.{implicitNotFound, nowarn}
 import scala.concurrent.duration.{Duration => ScalaDuration}
@@ -353,6 +354,16 @@ object Equal extends EqualVersionSpecific {
       case _                    => false
     }
 
+  /**
+   * Derives an `Equal[Optional[A]]` given an `Equal[A]`.
+   */
+  implicit def OptionalEqual[A: Equal]: Equal[Optional[A]] =
+    make {
+      case (Optional.Absent, Optional.Absent)           => true
+      case (Optional.Present(a1), Optional.Present(a2)) => a1 === a2
+      case _                                            => false
+    }
+
   /**
    * `PartialOrd` and `Hash` (and thus also `Equal`) instance for `Set[A]` values.
    * Due to the limitations of Scala's `Set`,

core/shared/src/main/scala/zio/prelude/Invariant.scala

@@ -18,6 +18,7 @@ package zio.prelude
 
 import zio._
 import zio.prelude.coherent.CovariantIdentityBoth
+import zio.prelude.data.Optional
 import zio.prelude.newtypes.Failure
 import zio.stm.ZSTM
 import zio.stream.{ZSink, ZStream}
@@ -751,6 +752,15 @@ object Invariant extends LowPriorityInvariantImplicits with InvariantVersionSpec
         option.fold[G[Option[B]]](Option.empty.succeed)(a => f(a).map(Some(_)))
     }
 
+  /**
+   * The [[ForEach]] (and thus [[Covariant]] and [[Invariant]]) instance for [[Optional]].
+   */
+  implicit val OptionalForEach: ForEach[Optional] =
+    new ForEach[Optional] {
+      def forEach[G[+_]: IdentityBoth: Covariant, A, B](option: Optional[A])(f: A => G[B]): G[Optional[B]] =
+        option.fold[G[Optional[B]]](Optional.Absent.succeed)(a => f(a).map(Optional.Present(_)))
+    }
+
   /**
    * The `Covariant` (and thus `Invariant`) instance for `Schedule`
    */

core/shared/src/main/scala/zio/prelude/data/Optional.scala

@@ -50,7 +50,7 @@ sealed trait Optional[+A] { self =>
       case Optional.Absent       => ifEmpty
     }
 
-  final def flatten[B](implicit ev: A <:< Option[B]): Option[B] =
+  final def flatten[B](implicit ev: A <:< Optional[B]): Optional[B] =
     self match {
       case Optional.Present(get) => ev(get)
       case Optional.Absent       => None
@@ -119,11 +119,8 @@ sealed trait Optional[+A] { self =>
       case Optional.Absent       => Optional.Absent
     }
 
-  final def orElse[B >: A](other: Optional[B]): Optional[B] =
-    self match {
-      case Optional.Present(_) => self
-      case Optional.Absent     => other
-    }
+  final def orElse[B >: A](alternative: => Optional[B]): Optional[B] =
+    if (isEmpty) alternative else this
 
   final def iterator: Iterator[A] =
     self match {