specs2-fp/org.specs2.fp/syntax

syntax

object syntax extends FunctorSyntax with ApplicativeSyntax with MonadSyntax with TraverseSyntax with FoldableSyntax with SemigroupSyntax with ShowSyntax with EitherSyntax with Identityx
trait Identityx
class Object
trait Matchable
class Any

Type members

Inherited classlikes

implicit
class MonadFlattenOps[F[_], A](fa: F[F[A]])(using evidence$2: Monad[F])
Inherited from
MonadSyntax
implicit
class MonadOps[F[_], A, B](fa: F[A])(using evidence$1: Monad[F])
Inherited from
MonadSyntax

Value members

Inherited methods

def unless[F[_], A](condition: Boolean)(fa: => F[A])(using evidence$10: Applicative[F]): F[Unit]
Inherited from
ApplicativeSyntax
def when[F[_], A](condition: Boolean)(fa: => F[A])(using evidence$9: Applicative[F]): F[Unit]
Inherited from
ApplicativeSyntax

Extensions

Inherited extensions

extension [M](a: M)
def append(b: => M)(using evidence$1: Semigroup[M]): M
Inherited from
SemigroupSyntax
def |+|(b: => M)(using evidence$2: Semigroup[M]): M
Inherited from
SemigroupSyntax
extension [A](a: A)
def show(using evidence$1: Show[A]): String
Inherited from
ShowSyntax
extension [A, B](eab: Either[A, B])
def exists(f: B => Boolean): Boolean
Inherited from
EitherSyntax
def forall(f: B => Boolean): Boolean
Inherited from
EitherSyntax
def foreach(f: B => Unit): Unit
Inherited from
EitherSyntax
def toList: List[B]
Inherited from
EitherSyntax
def toOption: Option[B]
Inherited from
EitherSyntax
extension [F[_], A, B, AA >: A, C](eab: Either[A, B])
def traverse(f: B => F[C])(using F: Applicative[F]): F[Either[AA, C]]
Inherited from
EitherSyntax
extension [A, B, C, D](eab: Either[A, B])
def bimap(fa: A => C, fb: B => D): Either[C, D]
Inherited from
EitherSyntax
extension [A, B, AA >: A, BB >: B, C](eab: Either[A, B])
def ap(that: Either[AA, BB => C]): Either[AA, C]
Inherited from
EitherSyntax
def append(that: Either[AA, BB])(using BB: Semigroup[BB]): Either[AA, BB]
Inherited from
EitherSyntax
def as(c: => C): Either[A, C]
Inherited from
EitherSyntax
def ensure(onFailure: => AA)(f: B => Boolean): Either[AA, B]
Inherited from
EitherSyntax
def flatMap(f: B => Either[AA, C]): Either[AA, C]
Inherited from
EitherSyntax
def foldLeft(c: C)(f: (C, B) => C): C
Inherited from
EitherSyntax
def getOrElse(default: => BB): BB
Inherited from
EitherSyntax
def leftMap(f: A => C): Either[C, B]
Inherited from
EitherSyntax
def map(f: B => C): Either[A, C]
Inherited from
EitherSyntax
def orElse(fallback: => Either[C, BB]): Either[C, BB]
Inherited from
EitherSyntax
def recover(pf: PartialFunction[A, BB]): Either[A, BB]
Inherited from
EitherSyntax
def recoverWith(pf: PartialFunction[A, Either[AA, BB]]): Either[AA, BB]
Inherited from
EitherSyntax
def show(using AA: Show[AA], BB: Show[BB]): String
Inherited from
EitherSyntax
def toTry(using ev: A <:< Throwable): Try[B]
Inherited from
EitherSyntax
def valueOr(f: A => BB): BB
Inherited from
EitherSyntax
extension [F[_], A](fa: F[A])
def sumAll(using evidence$15: Foldable[F], evidence$16: Monoid[A]): A
Inherited from
FoldableSyntax
extension [F[_], A, B, C](fa: F[A])
def |@|(fb: F[B])(f: (A, B) => C)(using evidence$2: Applicative[F]): F[C]
Inherited from
ApplicativeSyntax
extension [A, B, F[_], M[_]](fa: F[A])
def foldLeftM(z: B)(f: (B, A) => M[B])(using evidence$9: Foldable[F], evidence$10: Monad[M]): M[B]
Inherited from
FoldableSyntax
def foldRightM(z: B)(f: (A, => B) => M[B])(using evidence$11: Foldable[F], evidence$12: Monad[M]): M[B]
Inherited from
FoldableSyntax
extension [F[_], A, B](fa: F[A])
infix
def as(b: => B)(using evidence$2: Functor[F]): F[B]
Inherited from
FunctorSyntax
infix
def map(f: A => B)(using evidence$1: Functor[F]): F[B]
Inherited from
FunctorSyntax
extension [F[_], A, B](fa: F[A])
def *>(fb: F[B])(using evidence$5: Applicative[F]): F[B]
Inherited from
ApplicativeSyntax
def ap(f: F[A => B])(using evidence$3: Applicative[F]): F[B]
Inherited from
ApplicativeSyntax
def tuple2(fb: F[B])(using evidence$4: Applicative[F]): F[(A, B)]
Inherited from
ApplicativeSyntax
extension [F[_], G[_], A](fa: F[G[A]])
def sequence(using evidence$10: Traverse[F], evidence$11: Applicative[G]): G[F[A]]
Inherited from
TraverseSyntax
extension [F[_], A](fa: F[A])
def suml(using evidence$5: Foldable[F], evidence$6: Monoid[A]): A
Inherited from
FoldableSyntax
def sumr(using evidence$3: Foldable[F], evidence$4: Monoid[A]): A
Inherited from
FoldableSyntax
extension [F[_], A](fa: F[A])
def void(using evidence$3: Functor[F]): F[Unit]
Inherited from
FunctorSyntax
extension [F[_], A, G[_], B](fa: F[A])
def traverse(f: A => G[B])(using evidence$8: Traverse[F], evidence$9: Applicative[G]): G[F[B]]
Inherited from
TraverseSyntax
extension [F[_], A](fa: F[A])
def unless(condition: Boolean)(using evidence$7: Applicative[F]): F[Unit]
Inherited from
ApplicativeSyntax
def when(condition: Boolean)(using evidence$6: Applicative[F]): F[Unit]
Inherited from
ApplicativeSyntax
extension [F[_], M[_], A, B](fa: F[A])
def traverse_(f: A => M[B])(using evidence$7: Foldable[F], evidence$8: Applicative[M]): M[Unit]
Inherited from
FoldableSyntax
extension [F[_], A](fa: F[A])
def toList(using evidence$2: Foldable[F]): List[A]
Inherited from
FoldableSyntax
extension [F[_], A, B](fa: F[A])
def foldLeft(z: B)(f: (B, A) => B)(using evidence$14: Foldable[F]): B
Inherited from
FoldableSyntax
def foldMap(f: A => B)(using evidence$13: Foldable[F], Monoid[B]): B
Inherited from
FoldableSyntax
extension [F[_], A](fa: List[A])
def filterM(f: A => F[Boolean])(using evidence$8: Applicative[F]): F[List[A]]
Inherited from
ApplicativeSyntax
extension [S <: T, T](t: => S)
def orEmptyUnless(condition: Boolean)(using evidence$1: Monoid[T]): T
Inherited from
Identityx
def orEmptyWhen(condition: Boolean)(using evidence$2: Monoid[T]): T
Inherited from
Identityx
extension [T](t: => T)
def orWhen(condition: Boolean)(f: T => T): T

These extension methods provide the possibility to execute a function on an object if a condition is true If not, the object is returned

These extension methods provide the possibility to execute a function on an object if a condition is true If not, the object is returned

Inherited from
Identityx

Implicits

Inherited implicits

final implicit
def MonadFlattenOps[F[_], A](fa: F[F[A]])(using evidence$2: Monad[F]): MonadFlattenOps[F, A]
Inherited from
MonadSyntax
final implicit
def MonadOps[F[_], A, B](fa: F[A])(using evidence$1: Monad[F]): MonadOps[F, A, B]
Inherited from
MonadSyntax