final case class OptionT[F[_], A](value: F[Option[A]]) extends Product with Serializable
OptionT[F[_], A]
is a light wrapper on an F[Option[A]]
with some
convenient methods for working with this nested structure.
It may also be said that OptionT
is a monad transformer for Option
.
For more information, see the documentation.
- Alphabetic
- By Inheritance
- OptionT
- Serializable
- Serializable
- Product
- Equals
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def ===(that: OptionT[F, A])(implicit eq: Eq[F[Option[A]]]): Boolean
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
cata[B](default: ⇒ B, f: (A) ⇒ B)(implicit F: Functor[F]): F[B]
Catamorphism on the Option.
Catamorphism on the Option. This is identical to fold, but it only has one parameter list, which can result in better type inference in some contexts.
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
- def collect[B](f: PartialFunction[A, B])(implicit F: Functor[F]): OptionT[F, B]
- def compare(that: OptionT[F, A])(implicit o: Order[F[Option[A]]]): Int
- def contramap[B](f: (B) ⇒ A)(implicit F: Contravariant[F]): OptionT[F, B]
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def exists(f: (A) ⇒ Boolean)(implicit F: Functor[F]): F[Boolean]
- def filter(p: (A) ⇒ Boolean)(implicit F: Functor[F]): OptionT[F, A]
- def filterNot(p: (A) ⇒ Boolean)(implicit F: Functor[F]): OptionT[F, A]
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- def flatMap[B](f: (A) ⇒ OptionT[F, B])(implicit F: Monad[F]): OptionT[F, B]
- def flatMapF[B](f: (A) ⇒ F[Option[B]])(implicit F: Monad[F]): OptionT[F, B]
- def flatTransform[B](f: (Option[A]) ⇒ F[Option[B]])(implicit F: Monad[F]): OptionT[F, B]
- def fold[B](default: ⇒ B)(f: (A) ⇒ B)(implicit F: Functor[F]): F[B]
- def foldLeft[B](b: B)(f: (B, A) ⇒ B)(implicit F: Foldable[F]): B
- def foldRight[B](lb: Eval[B])(f: (A, Eval[B]) ⇒ Eval[B])(implicit F: Foldable[F]): Eval[B]
- def forall(f: (A) ⇒ Boolean)(implicit F: Functor[F]): F[Boolean]
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def getOrElse[B >: A](default: ⇒ B)(implicit F: Functor[F]): F[B]
- def getOrElseF[B >: A](default: ⇒ F[B])(implicit F: Monad[F]): F[B]
- def imap[B](f: (A) ⇒ B)(g: (B) ⇒ A)(implicit F: Invariant[F]): OptionT[F, B]
- def isDefined(implicit F: Functor[F]): F[Boolean]
- def isEmpty(implicit F: Functor[F]): F[Boolean]
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def map[B](f: (A) ⇒ B)(implicit F: Functor[F]): OptionT[F, B]
- def mapFilter[B](f: (A) ⇒ Option[B])(implicit F: Functor[F]): OptionT[F, B]
-
def
mapK[G[_]](f: ~>[F, G]): OptionT[G, A]
Modify the context
F
using transformationf
. -
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def orElse(default: ⇒ OptionT[F, A])(implicit F: Monad[F]): OptionT[F, A]
- def orElseF(default: ⇒ F[Option[A]])(implicit F: Monad[F]): OptionT[F, A]
- def partialCompare(that: OptionT[F, A])(implicit p: PartialOrder[F[Option[A]]]): Double
- def semiflatMap[B](f: (A) ⇒ F[B])(implicit F: Monad[F]): OptionT[F, B]
- def show(implicit F: Show[F[Option[A]]]): String
- def subflatMap[B](f: (A) ⇒ Option[B])(implicit F: Functor[F]): OptionT[F, B]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
- def toLeft[R](right: ⇒ R)(implicit F: Functor[F]): EitherT[F, A, R]
-
def
toNested: Nested[F, Option, A]
Transform this
OptionT[F, A]
into aNested[F, Option, A]
.Transform this
OptionT[F, A]
into aNested[F, Option, A]
.An example where
toNested
can be used, is to get theApply.ap
function with the behavior from the composedApply
instances fromF
andOption
, which is inconsistent with the behavior of theap
fromMonad
ofOptionT
.scala> import cats.implicits._ scala> import cats.data.OptionT scala> val ff: OptionT[List, Int => String] = | OptionT(List(Option(_.toString), None)) scala> val fa: OptionT[List, Int] = OptionT(List(Option(1), Option(2))) scala> ff.ap(fa) res0: OptionT[List,String] = OptionT(List(Some(1), Some(2), None)) scala> OptionT(ff.toNested.ap(fa.toNested).value) res1: OptionT[List,String] = OptionT(List(Some(1), Some(2), None, None))
- def toRight[L](left: ⇒ L)(implicit F: Functor[F]): EitherT[F, L, A]
- def transform[B](f: (Option[A]) ⇒ Option[B])(implicit F: Functor[F]): OptionT[F, B]
- def traverse[G[_], B](f: (A) ⇒ G[B])(implicit F: Traverse[F], G: Applicative[G]): G[OptionT[F, B]]
- val value: F[Option[A]]
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
- def withFilter(p: (A) ⇒ Boolean)(implicit F: Functor[F]): OptionT[F, A]