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

Producers

trait Producers

List of common producers or functions creating producers

Companion:
object
class Object
trait Matchable
class Any
object Producer.type
object Producers.type

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[Action, A]
def emitAllSync[A](elements: A*): Producer[Operation, A]
def emitAsync[A](elements: List[A]): Producer[Action, 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[Action, A]
def emitSeqSync[A](elements: Seq[A]): Producer[Operation, A]
def emitSync[A](elements: List[A]): Producer[Operation, 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[Action, 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[Action, A]
def oneDelayedSync[A](e: => A): Producer[Operation, 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[Operation, 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 [F[_], A, B, C](transducer: (F, A) => B)
def |>(other: (F, B) => C): (F, A) => C