specs2-common
API
Generated with
specs2-common/org.specs2/org.specs2.control/org.specs2.control.producer/Producers

Producers

org.specs2.control.producer.Producers
See theProducers companion object
trait Producers

List of common producers or functions creating producers

Attributes

Companion
object
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Producer.type
object Producers.type

Members list

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)(transducer: (F, A) => B)
def |>(other: (F, B) => C): (F, A) => C
Generated with