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()
-
def
collect[B](f: PartialFunction[A, B])(implicit F: Functor[F]): OptionT[F, B]
Example:
Example:
scala> import cats.data.OptionT scala> val optionT: OptionT[List, Int] = OptionT(List(Some(2), None, Some(414), None, None)) scala> optionT.collect{ case i if i == 2 => i } res0: OptionT[List, Int] = OptionT(List(Some(2), None, None, None, None)) scala> optionT.collect{ case i: Int => i == 2 } res0: OptionT[List, Boolean] = OptionT(List(Some(true), None, Some(false), None, None))
-
def
compare(that: OptionT[F, A])(implicit o: Order[F[Option[A]]]): Int
Example:
Example:
scala> import cats.data.OptionT scala> val optionT: OptionT[List, Int] = OptionT(List(Some(2), None, Some(414), None, None)) scala> optionT.compare(OptionT[List, Int](List(Some(2)))) res0: Int = 1 scala> optionT.compare(OptionT[List, Int](List(Some(2), None, Some(414), None, None))) res0: Int = 0
- 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]
Example:
Example:
scala> import cats.data.OptionT scala> val optionT: OptionT[List, Int] = OptionT(List(Some(2), None, Some(414), None, None)) scala> optionT.filter(el => (el % 2 == 0)) res0: OptionT[List, Int] = OptionT(List(Some(2), None, Some(414), None, None)) scala> optionT.filter(el => (el % 3 == 0)) res1: OptionT[List, Int] = OptionT(List(None, None, Some(414), None, None))
-
def
filterNot(p: (A) ⇒ Boolean)(implicit F: Functor[F]): OptionT[F, A]
Example:
Example:
scala> import cats.data.OptionT scala> val optionT: OptionT[List, Int] = OptionT(List(Some(2), None, Some(414), None, None)) scala> optionT.filterNot(el => (el % 2 == 0)) res0: OptionT[List, Int] = OptionT(List(None, None, None, None, None)) scala> optionT.filterNot(el => (el % 3 == 0)) res1: OptionT[List, Int] = OptionT(List(Some(2), None, None, None, None))
-
def
finalize(): Unit
- Attributes
- protected[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
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]
-
def
foreachF(f: (A) ⇒ F[Unit])(implicit F: Monad[F]): F[Unit]
Transform this
OptionT[F, A]
into aF[Unit]
.Transform this
OptionT[F, A]
into aF[Unit]
. This is identical tofoldF(F.unit)(f)
. -
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
getOrRaise[E](e: ⇒ E)(implicit F: MonadError[F, _ >: E]): F[A]
Like getOrElseF but accept an error
E
and raise it when the innerOption
isNone
Like getOrElseF but accept an error
E
and raise it when the innerOption
isNone
Equivalent to
getOrElseF(F.raiseError(e)))
scala> import cats.data.OptionT scala> import cats.implicits._ scala> import scala.util.{Success, Failure, Try} scala> val optionT: OptionT[Try, Int] = OptionT[Try, Int](Success(None)) scala> optionT.getOrRaise(new RuntimeException("ERROR!")) res0: Try[Int] = Failure(java.lang.RuntimeException: ERROR!)
- def imap[B](f: (A) ⇒ B)(g: (B) ⇒ A)(implicit F: Invariant[F]): OptionT[F, B]
-
def
isDefined(implicit F: Functor[F]): F[Boolean]
Example:
Example:
scala> import cats.data.OptionT scala> val optionT: OptionT[List, Int] = OptionT(List(Some(2), None, Some(414), None, None)) scala> optionT.isDefined res0: List[Boolean] = List(true, false, true, false, false)
-
def
isEmpty(implicit F: Functor[F]): F[Boolean]
Example:
Example:
scala> import cats.data.OptionT scala> val optionT: OptionT[List, Int] = OptionT(List(Some(2), None, Some(414), None, None)) scala> optionT.isEmpty res0: List[Boolean] = List(false, true, false, true, true)
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
map[B](f: (A) ⇒ B)(implicit F: Functor[F]): OptionT[F, B]
Example:
Example:
scala> import cats.data.OptionT scala> val optionT: OptionT[List, Int] = OptionT(List(Some(2), None, Some(414), None, None)) scala> optionT.map(_.toString + "!") res0: OptionT[List, String] = OptionT(List(Some(2!), None, Some(414!), None, None))
- def mapAccumulate[S, B](init: S)(f: (S, A) ⇒ (S, B))(implicit traverseF: Traverse[F]): (S, 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]
Example:
Example:
scala> import cats.data.OptionT scala> val optionT: OptionT[List, Int] = OptionT(List(Some(2), None, Some(414), None, None)) scala> optionT.orElseF(List[Option[Int]](Some(-1))) res0: OptionT[List, Int] = OptionT(List(Some(2), Some(-1), Some(414), Some(-1), Some(-1)))
- 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
Example:
Example:
scala> import cats.data.OptionT scala> val optionT: OptionT[List, Int] = OptionT(List(Some(2), None, Some(414), None, None)) scala> optionT.show res0: String = List(Some(2), None, Some(414), None, None)
- 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(): 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
- @throws( ... ) @native()
-
def
withFilter(p: (A) ⇒ Boolean)(implicit F: Functor[F]): OptionT[F, A]
It is used for desugaring 'for comprehensions'.
It is used for desugaring 'for comprehensions'. OptionT wouldn't work in 'for-comprehensions' without this method. Example:
scala> import cats.data.OptionT scala> val optionT: OptionT[List, Int] = OptionT(List(Some(2), None, Some(414), None, None)) scala> optionT.withFilter(el => (el % 2 == 0)) res0: OptionT[List, Int] = OptionT(List(Some(2), None, Some(414), None, None)) scala> optionT.withFilter(el => (el % 3 == 0)) res1: OptionT[List, Int] = OptionT(List(None, None, Some(414), None, None))