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.
- Source
- OptionT.scala
- 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
cataF[B](default: ⇒ F[B], f: (A) ⇒ F[B])(implicit F: FlatMap[F]): F[B]
Effectful catamorphism on the Option.
Effectful catamorphism on the Option. This is identical to foldF, but it only has one parameter list, which can result in better type inference in some contexts.
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native() @IntrinsicCandidate()
- 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 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
flatTapNone[B](ifNone: ⇒ F[B])(implicit F: Monad[F]): OptionT[F, A]
Perform an effect if the value inside the is a
None
, leaving the value untouched.Perform an effect if the value inside the is a
None
, leaving the value untouched. Equivalent to orElseF with an effect returningNone
as argument. - 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
foldF[B](default: ⇒ F[B])(f: (A) ⇒ F[B])(implicit F: FlatMap[F]): F[B]
Transform this
OptionT[F, A]
into aF[B]
.Transform this
OptionT[F, A]
into aF[B]
.Example:
scala> import cats.implicits._ scala> import cats.data.OptionT scala> val optionT: OptionT[List, Int] = OptionT[List, Int](List(Some(23), None)) scala> optionT.foldF(Nil)(v => List(v, v * 2)) res0: List[Int] = List(23, 46)
- 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() @IntrinsicCandidate()
- 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() @IntrinsicCandidate()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
- 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 semiflatTap[B](f: (A) ⇒ F[B])(implicit F: Monad[F]): OptionT[F, A]
- 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 toLeftF[R](right: ⇒ F[R])(implicit F: Monad[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 toRightF[L](left: ⇒ F[L])(implicit F: Monad[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(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
- def withFilter(p: (A) ⇒ Boolean)(implicit F: Functor[F]): OptionT[F, A]