specs2-common/org.specs2.control.producer/Producers

Producers

trait Producers

List of common producers or functions creating producers

List of common producers or functions creating producers

Companion
object
class Object
trait Matchable
class Any
object Producer
object Producers

Value members

Concrete methods

def bracket1[F[_], A, B, C](open: F[A])(step: A => Producer[F, B])(close: A => Finalizer)(using `evidence$37`: Monad[F], `evidence$38`: Safe[F]): Producer[F, B]
def done[F[_], A](using `evidence$9`: Monad[F], `evidence$10`: Safe[F]): Producer[F, A]
def emit[F[_], A](elements: List[A])(using `evidence$23`: Monad[F], `evidence$24`: Safe[F]): Producer[F, A]
def emitAction[F[_], A](elements: F[List[A]])(using `evidence$33`: Monad[F], `evidence$34`: Safe[F]): Producer[F, A]
def emitAll[F[_], A](elements: A*)(using `evidence$27`: Monad[F], `evidence$28`: Safe[F]): Producer[F, A]
def emitAllAsync[A](elements: A*): Producer[[A] =>> Action[A], A]
def emitAllSync[A](elements: A*): Producer[[A] =>> Operation[A], A]
def emitAsync[A](elements: List[A]): Producer[[A] =>> Action[A], A]
def emitSeq[F[_], A](elements: Seq[A])(using `evidence$25`: Monad[F], `evidence$26`: Safe[F]): Producer[F, A]
def emitSeqAsync[A](elements: Seq[A]): Producer[[A] =>> Action[A], A]
def emitSeqSync[A](elements: Seq[A]): Producer[[A] =>> Operation[A], A]
def emitSync[A](elements: List[A]): Producer[[A] =>> Operation[A], A]
def empty[F[_], A](using `evidence$35`: Monad[F], `evidence$36`: Safe[F]): Producer[F, A]
def eval[F[_], A](a: F[A])(using `evidence$29`: Monad[F], `evidence$30`: Safe[F]): Producer[F, A]
def evalProducer[F[_], A](a: F[Producer[F, A]])(using `evidence$31`: Monad[F], `evidence$32`: Safe[F]): Producer[F, A]
def one[F[_], A](a: A)(using `evidence$11`: Monad[F], `evidence$12`: Safe[F]): Producer[F, A]
def oneAsync[A](a: A): Producer[[A] =>> Action[A], A]
def oneDelayed[F[_], A](e: => A)(using `evidence$13`: Monad[F], `evidence$14`: Safe[F]): Producer[F, A]
def oneDelayedAsync[A](e: => A): Producer[[A] =>> Action[A], A]
def oneDelayedSync[A](e: => A): Producer[[A] =>> Operation[A], A]
def oneEval[F[_], A](e: F[A])(using `evidence$15`: Monad[F], `evidence$16`: Safe[F]): Producer[F, A]
def oneOrMore[F[_], A](a: A, as: List[A])(using `evidence$17`: Monad[F], `evidence$18`: Safe[F]): Producer[F, A]
def oneSync[A](a: A): Producer[[A] =>> Operation[A], A]
def repeatEval[F[_], A](e: F[A])(using `evidence$21`: Monad[F], `evidence$22`: Safe[F]): Producer[F, A]
def repeatValue[F[_], A](a: A)(using `evidence$19`: Monad[F], `evidence$20`: Safe[F]): Producer[F, A]

Extensions

Extensions

extension (transducer: (F, A) => B)
def |>[F[_], A, B, C](other: (F, B) => C): (F, A) => C