libretto/libretto/AbstractStarterKit

AbstractStarterKit

abstract
class AbstractStarterKit(val dsl: ScalaDSL, val runner0: (ScheduledExecutorService, Executor) => ScalaRunner[ScalaDSL, Future])
class Object
trait Matchable
class Any
object StarterKit

Type members

Types

final
type $ >: ($) <: ($)
final
type $Ops >: $Ops <: $Ops
final
type - >: (-) <: (-)
final
type -⚬ >: (-⚬) <: (-⚬)
final
type =⚬ >: (=⚬) <: (=⚬)
final
type Affine >: (Affine) <: (Affine)
final
type BiExternalizer >: ([F[_, _]] =>> BiExternalizer[F]) <: ([F[_, _]] =>> BiExternalizer[F])
final
type Bifunctor >: ([F[_, _]] =>> Bifunctor[F]) <: ([F[_, _]] =>> Bifunctor[F])
final
type BimapSyntax >: ([F[_, _], A, B] =>> BimapSyntax[F, A, B]) <: ([F[_, _], A, B] =>> BimapSyntax[F, A, B])
final
type Bool >: Bool <: Bool
final
type Comonad >: ([F[_]] =>> Comonad[F]) <: ([F[_]] =>> Comonad[F])
final
type Comonoid >: (Comonoid) <: (Comonoid)
final
type Comparable >: (Comparable) <: (Comparable)
final
type Consumer >: (Consumer) <: (Consumer)
final
type ConsumerF >: (ConsumerF) <: (ConsumerF)
final
type ContraExternalizer >: ([F[_]] =>> ContraExternalizer[F]) <: ([F[_]] =>> ContraExternalizer[F])
final
type ContraFunctor >: ([F[_]] =>> ContraFunctor[F]) <: ([F[_]] =>> ContraFunctor[F])
final
type Cosemigroup >: (Cosemigroup) <: (Cosemigroup)
final
type Deferred >: (Deferred) <: (Deferred)
final
type Demanding >: (Demanding) <: (Demanding)
final
type Detained >: (Detained) <: (Detained)
final
type Done >: Done <: Done
final
type Dual >: (Dual) <: (Dual)
final
type Dual1 >: ([F[_], G[_]] =>> Dual1[F, G]) <: ([F[_], G[_]] =>> Dual1[F, G])
final
type Endless >: (Endless) <: (Endless)
final
type Externalizer >: ([F[_]] =>> Externalizer[F]) <: ([F[_]] =>> Externalizer[F])
final
type FocusedBi >: ([F[_, _], B1, B2] =>> FocusedBi[F, B1, B2]) <: ([F[_, _], B1, B2] =>> FocusedBi[F, B1, B2])
final
type FocusedCo >: ([F[_], B] =>> FocusedCo[F, B]) <: ([F[_], B] =>> FocusedCo[F, B])
final
type FocusedContra >: ([F[_], B] =>> FocusedContra[F, B]) <: ([F[_], B] =>> FocusedContra[F, B])
final
type FocusedOnChoiceCo >: ([F[_], B1, B2] =>> FocusedOnChoiceCo[F, B1, B2]) <: ([F[_], B1, B2] =>> FocusedOnChoiceCo[F, B1, B2])
final
type FocusedOnChoiceContra >: ([A, F[_], B1, B2] =>> FocusedOnChoiceContra[A, F, B1, B2]) <: ([A, F[_], B1, B2] =>> FocusedOnChoiceContra[A, F, B1, B2])
final
type FocusedOnDoneTimesCo >: ([F[_], B2] =>> FocusedOnDoneTimesCo[F, B2]) <: ([F[_], B2] =>> FocusedOnDoneTimesCo[F, B2])
final
type FocusedOnFunctionCo >: ([F[_], A, B] =>> FocusedOnFunctionCo[F, A, B]) <: ([F[_], A, B] =>> FocusedOnFunctionCo[F, A, B])
final
type FocusedOnFunctionContra >: ([F[_], A, B] =>> FocusedOnFunctionContra[F, A, B]) <: ([F[_], A, B] =>> FocusedOnFunctionContra[F, A, B])
final
type FocusedOnPairCo >: ([F[_], B1, B2] =>> FocusedOnPairCo[F, B1, B2]) <: ([F[_], B1, B2] =>> FocusedOnPairCo[F, B1, B2])
final
type FocusedOnPairContra >: ([A, F[_], B1, B2] =>> FocusedOnPairContra[A, F, B1, B2]) <: ([A, F[_], B1, B2] =>> FocusedOnPairContra[A, F, B1, B2])
final
type FocusedOnPlusCo >: ([F[_], B1, B2] =>> FocusedOnPlusCo[F, B1, B2]) <: ([F[_], B1, B2] =>> FocusedOnPlusCo[F, B1, B2])
final
type FocusedOnPlusContra >: ([A, F[_], B1, B2] =>> FocusedOnPlusContra[A, F, B1, B2]) <: ([A, F[_], B1, B2] =>> FocusedOnPlusContra[A, F, B1, B2])
final
type FocusedOnTimesDoneCo >: ([F[_], B1] =>> FocusedOnTimesDoneCo[F, B1]) <: ([F[_], B1] =>> FocusedOnTimesDoneCo[F, B1])
final
type Functor >: ([F[_]] =>> Functor[F]) <: ([F[_]] =>> Functor[F])
final
type Getter >: (Getter) <: (Getter)
final
type Id >: (Id) <: (Id)
final
type LDemanding >: (LDemanding) <: (LDemanding)
final
type LList >: (LList) <: (LList)
final
type LList1 >: (LList1) <: (LList1)
final
type LPollable >: (LPollable) <: (LPollable)
final
type LPollableF >: (LPollableF) <: (LPollableF)
final
type LPolled >: (LPolled) <: (LPolled)
final
type LSubscriber >: (LSubscriber) <: (LSubscriber)
final
type LTerminus >: LTerminus <: LTerminus
final
type Lens >: (Lens) <: (Lens)
final
type Lock >: Lock <: Lock
final
type Maybe >: (Maybe) <: (Maybe)
final
type Monad >: ([F[_]] =>> Monad[F]) <: ([F[_]] =>> Monad[F])
final
type Monoid >: (Monoid) <: (Monoid)
final
type Multiple >: (Multiple) <: (Multiple)
final
type NAffine >: (NAffine) <: (NAffine)
final
type NComonoid >: (NComonoid) <: (NComonoid)
final
type NMonoid >: (NMonoid) <: (NMonoid)
final
type Need >: Need <: Need
final
type Neg >: (Neg) <: (Neg)
final
type One >: One <: One
final
type Optionally >: (Optionally) <: (Optionally)
final
type PAffine >: (PAffine) <: (PAffine)
final
type PComonoid >: (PComonoid) <: (PComonoid)
final
type PMaybe >: (PMaybe) <: (PMaybe)
final
type PMonoid >: (PMonoid) <: (PMonoid)
final
type PUnlimited >: (PUnlimited) <: (PUnlimited)
final
type Ping >: Ping <: Ping
final
type Pollable >: (Pollable) <: (Pollable)
final
type PollableF >: (PollableF) <: (PollableF)
final
type Polled >: (Polled) <: (Polled)
final
type Pong >: Pong <: Pong
final
type Producing >: (Producing) <: (Producing)
final
type ProducingF >: (ProducingF) <: (ProducingF)
final
type RTerminus >: RTerminus <: RTerminus
final
type Rec >: ([F[_]] =>> Rec[F]) <: ([F[_]] =>> Rec[F])
final
type RefCounted >: (RefCounted) <: (RefCounted)
final
type Res >: (Res) <: (Res)
final
type Semigroup >: (Semigroup) <: (Semigroup)
final
type Subscriber >: (Subscriber) <: (Subscriber)
final
type SubscriberF >: (SubscriberF) <: (SubscriberF)
final
type Transportive >: ([F[_]] =>> Transportive[F]) <: ([F[_]] =>> Transportive[F])
final
type Unlimited >: (Unlimited) <: (Unlimited)
final
type Val >: (Val) <: (Val)
final
type ValMatcher >: ([U >: V, V, A, R] =>> ValMatcher[U, V, A, R]) <: ([U >: V, V, A, R] =>> ValMatcher[U, V, A, R])
final
type Zero >: Zero <: Zero
final
type |&| >: (|&|) <: (|&|)
final
type |*| >: (|*|) <: (|*|)
final
type |+| >: (|+|) <: (|+|)
final
type ⊕ >: (|+|) <: (|+|)
final
type ⊗ >: (|*|) <: (|*|)

Value members

Concrete methods

def runAsync(blueprint: Done -⚬ Done): Future[Unit]
def runScalaAsync[A](blueprint: Done -⚬ Val[A]): Future[A]
def runner(blockingExecutor: Executor)(implicit scheduler: ScheduledExecutorService): ScalaRunner[ScalaDSL, Future]

Concrete fields

val runner0: (ScheduledExecutorService, Executor) => ScalaRunner[ScalaDSL, Future]

Extensions

Extensions

extension [A](a: $[Detained[A]])
final
def releaseWhen(trigger: $[Done]): $[A]
extension [A](a: $[Val[A]])
final
def *[B](b: $[Val[B]]): $[Val[(A, B)]]
extension [A](a: $[Deferred[A]])
final
def resumeWhen(trigger: $[Ping]): $[A]
extension [A, B](a: $[A])
final
def blockUntil(b: $[Ping]): $[A]
final
def deferUntil(b: $[Ping])(implicit A: Positive[A]): $[A]
final
def sequence(f: Done -⚬ B)(implicit A: Positive[A]): $[A |*| B]
final
def sequence(b: $[B])(implicit A: Positive[A], B: Positive[B]): $[A |*| B]
final
def sequenceAfter(b: $[B])(implicit A: Positive[A], B: Positive[B]): $[A |*| B]
final
def waitFor(b: $[Done])(implicit A: Positive[A]): $[A]
extension (acquiredLock: $[AcquiredLock])
final
def deferReleaseUntil(ping: $[Ping]): $[AcquiredLock]
final
def detainReleaseUntil(done: $[Done]): $[AcquiredLock]
extension [A, C](f: A -⚬ C)
final
def \/[B](g: B -⚬ C)(using x$3: Semigroup[C]): A |*| B -⚬ C
extension [A, B](f: A -⚬ B)
final
def /\[C](g: A -⚬ C)(using x$3: Cosemigroup[A]): A -⚬ B |*| C

Implicits

Implicits

final implicit
def choiceBifunctor: Bifunctor[|&|]
final implicit
def consumerProducingDuality[A]: Dual[Consumer[A], Producing[A]]
Exported from instance.function
final implicit
def doneNeedDuality: Dual[Done, Need]
final implicit
def eitherBifunctor: Bifunctor[|+|]
final implicit
def fstFunctor[B]: Transportive[|*|]
Exported from instance.function
final implicit
def idFunctor: Transportive[Id]
Exported from coreLib.idFunctor
final implicit
def junctionNeg[A]: Negative[Neg[A]]
Exported from instance.function
final implicit
def junctionVal[A]: Positive[Val[A]]
Exported from instance.function
final implicit
def nMonoidNeg[A]: NMonoid[Neg[A]]
Exported from instance.function
final implicit
def negValDuality[A]: Dual[Neg[A], Val[A]]
Exported from instance.function
final implicit
def oneSelfDual: Dual[One, One]
Exported from coreLib.oneSelfDual
final implicit
def pComonoidVal[A]: PComonoid[Val[A]]
Exported from instance.function
final implicit
def producingConsumerDuality[A]: Dual[Producing[A], Consumer[A]]
Exported from instance.function
final implicit
def signalingJunctionNegativeNeg[A]: Negative[Neg[A]]
Exported from instance.function
final implicit
def signalingJunctionPositiveVal[A]: Positive[Val[A]]
Exported from instance.function
final implicit
def signalingNeg[A]: Negative[Neg[A]]
Exported from instance.function
final implicit
def signalingVal[A]: Positive[Val[A]]
Exported from instance.function
final implicit
def sndFunctor[A]: Transportive[[x] =>> A |*| x]
Exported from instance.function
final implicit
def valNegDuality[A]: Dual[Val[A], Neg[A]]
Exported from instance.function

Exports

Defined exports

final
def $: ClosureOps
Exported from ScalaDSL.$
final
def Affine: Affine
Exported from coreLib.Affine
final
def Bifunctor: Bifunctor
Exported from coreLib.Bifunctor
final
def Bool: Bool
Exported from coreLib.Bool
final
def Comonoid: Comonoid
Exported from coreLib.Comonoid
final
def Compared: Compared
Exported from coreLib.Compared
final
def Deferrable: Deferrable
Exported from coreLib.Deferrable
final
def Deferred: Deferred
Exported from coreLib.Deferred
final
def Detained: Detained
Exported from coreLib.Detained
final
def Dual: Dual
Exported from coreLib.Dual
final
def Endless: Endless
Exported from coreLib.Endless
final
def Functor: Functor
Exported from coreLib.Functor
final
def Getter: Getter
Exported from coreLib.Getter
final
def IX[A, B, C]: A |*| B |*| C -⚬ A |*| C |*| B
Exported from instance.function
final
def IXI[A, B, C, D]: A |*| B |*| C |*| D -⚬ A |*| C |*| B |*| D
Exported from instance.function
final
def Junction: Junction
Exported from coreLib.Junction
final
def LList: LList
Exported from coreLib.LList
final
def LList1: LList1
Exported from coreLib.LList1
final
def LPollable: LPollable
Exported from coreStreams.LPollable
final
def LPolled: LPolled
Exported from coreStreams.LPolled
final
def Lens: Lens
Exported from coreLib.Lens
final
def Lock: Lock
Exported from coreLib.Lock
final
def Maybe: Maybe
Exported from coreLib.Maybe
final
def Monoid: Monoid
Exported from coreLib.Monoid
final
def Multiple: Multiple
Exported from coreLib.Multiple
final
def NAffine: NAffine
Exported from coreLib.NAffine
final
def NMonoid: NMonoid
Exported from coreLib.NMonoid
final
def Optionally: Optionally
Exported from coreLib.Optionally
final
def PAffine: PAffine
Exported from coreLib.PAffine
final
def PComonoid: PComonoid
Exported from coreLib.PComonoid
final
def PMaybe: PMaybe
Exported from coreLib.PMaybe
final
def PUnlimited: PUnlimited
Exported from coreLib.PUnlimited
final
def Pollable: Pollable
Exported from scalaStreams.Pollable
final
def Polled: Polled
Exported from scalaStreams.Polled
final
def RefCounted: RefCounted
Exported from scalaLib.RefCounted
final
def Semigroup: Semigroup
Exported from coreLib.Semigroup
final
def Signaling: Signaling
Exported from coreLib.Signaling
final
def Unlimited: Unlimited
Exported from coreLib.Unlimited
final
def Val: Val
Exported from scalaLib.Val
final
def ValMatcher: ValMatcher
Exported from scalaLib.ValMatcher
final
def XI[A, B, C]: A |*| B |*| C -⚬ B |*| A |*| C
Exported from instance.function
final
def absorbR[A, B, C]: A =⚬ B |*| C -⚬ A =⚬ B |*| C
Exported from instance.function
final
def alsoPrintLine: Val[String] -⚬ Val[String]
final
def assocLR[A, B, C]: A |*| B |*| C -⚬ A |*| B |*| C
Exported from instance.function
final
def assocRL[A, B, C]: A |*| B |*| C -⚬ A |*| B |*| C
Exported from instance.function
final
def backvert[A]: A |*| -[A] -⚬ One
Exported from instance.function
final
def blockInportUntilPong[A]: A -⚬ Pong |*| A
Exported from instance.function
final
def blockOutportUntilPing[A]: Ping |*| A -⚬ A
Exported from instance.function
final
def chooseL[A, B]: A |&| B -⚬ A
Exported from instance.function
final
def chooseLOnPing[A, B]: Ping |*| A |&| B -⚬ A
Exported from instance.function
final
def chooseLOnPong[A, B]: A |&| B -⚬ Pong |*| A
Exported from instance.function
final
def chooseLWhenDone[A, B]: Done |*| A |&| B -⚬ Done |*| A
Exported from instance.function
final
def chooseLWhenNeed[A, B]: Need |*| A |&| B -⚬ Need |*| A
Exported from instance.function
final
def chooseR[A, B]: A |&| B -⚬ B
Exported from instance.function
final
def chooseROnPing[A, B]: Ping |*| A |&| B -⚬ B
Exported from instance.function
final
def chooseROnPong[A, B]: A |&| B -⚬ Pong |*| B
Exported from instance.function
final
def chooseRWhenDone[A, B]: Done |*| A |&| B -⚬ Done |*| B
Exported from instance.function
final
def chooseRWhenNeed[A, B]: A |&| Need |*| B -⚬ Need |*| B
Exported from instance.function
final
def coDistributeL[A, B, C]: A |*| B |&| A |*| C -⚬ A |*| B |&| C
Exported from instance.function
final
def coDistributeR[A, B, C]: A |*| C |&| B |*| C -⚬ A |&| B |*| C
Exported from instance.function
final
def coFactorL[A, B, C]: A |*| B |&| C -⚬ A |*| B |&| A |*| C
Exported from instance.function
final
def coFactorR[A, B, C]: A |&| B |*| C -⚬ A |*| C |&| B |*| C
Exported from instance.function
final
def crashd(msg: String): Done -⚬ Done
Exported from ScalaDSL.crashd
final
def crashn(msg: String): Need -⚬ Need
Exported from ScalaDSL.crashn
final
def debugPrint(msg: String): Ping -⚬ One
Exported from ScalaDSL.debugPrint
final
def delay(d: FiniteDuration): Done -⚬ Done
Exported from ScalaDSL.delay
final
def delay: Val[FiniteDuration] -⚬ Done
Exported from ScalaDSL.delay
final
def delayChoiceUntilDone[A, B]: Done |*| A |&| B -⚬ Done |*| A |&| Done |*| B
Exported from instance.function
final
def delayChoiceUntilNeed[A, B]: Need |*| A |&| Need |*| B -⚬ Need |*| A |&| B
Exported from instance.function
final
def delayChoiceUntilPing[A, B]: Ping |*| A |&| B -⚬ A |&| B
Exported from instance.function
final
def delayChoiceUntilPong[A, B]: A |&| B -⚬ Pong |*| A |&| B
Exported from instance.function
final
def delayEitherUntilDone[A, B]: Done |*| A |+| B -⚬ Done |*| A |+| Done |*| B
Exported from instance.function
final
def delayEitherUntilNeed[A, B]: Need |*| A |+| Need |*| B -⚬ Need |*| A |+| B
Exported from instance.function
final
def delayEitherUntilPing[A, B]: Ping |*| A |+| B -⚬ A |+| B
Exported from instance.function
final
def delayEitherUntilPong[A, B]: A |+| B -⚬ Pong |*| A |+| B
Exported from instance.function
final
def delayNeed: Need -⚬ Neg[FiniteDuration]
Exported from ScalaDSL.delayNeed
final
def delayNeed(d: FiniteDuration): Need -⚬ Need
Exported from ScalaDSL.delayNeed
final
def demand[A]: One -⚬ -[A] |*| A
Exported from instance.function
final
def demandChoice[A, B]: -[A] |+| -[B] -⚬ -[A |&| B]
Exported from instance.function
final
def demandChosen[A, B]: -[A |&| B] -⚬ -[A] |+| -[B]
Exported from instance.function
final
def demandEither[A, B]: -[A] |&| -[B] -⚬ -[A |+| B]
Exported from instance.function
final
def demandSeparately[A, B]: -[A |*| B] -⚬ -[A] |*| -[B]
Exported from instance.function
final
def demandTogether[A, B]: -[A] |*| -[B] -⚬ -[A |*| B]
Exported from instance.function
final
def die[A]: -[-[A]] -⚬ A
Exported from instance.function
final
def dii[A]: A -⚬ -[-[A]]
Exported from instance.function
final
def dismissPing: Ping -⚬ One
Exported from ScalaDSL.dismissPing
final
def dismissPong: One -⚬ Pong
Exported from ScalaDSL.dismissPong
final
def distributeInversion[A, B]: -[A |*| B] -⚬ -[A] |*| -[B]
Exported from instance.function
final
def distributeInversionInto_|&|[A, B]: -[A |&| B] -⚬ -[A] |+| -[B]
Exported from instance.function
final
def distributeInversionInto_|+|[A, B]: -[A |+| B] -⚬ -[A] |&| -[B]
Exported from instance.function
final
def distributeL[A, B, C]: A |*| B |+| C -⚬ A |*| B |+| A |*| C
Exported from instance.function
final
def distributeR[A, B, C]: A |+| B |*| C -⚬ A |*| C |+| B |*| C
Exported from instance.function
final
def done: One -⚬ Done
Exported from ScalaDSL.done
final
def doubleDemandElimination[A]: -[-[A]] -⚬ A
Exported from instance.function
final
def doubleDemandIntroduction[A]: A -⚬ -[-[A]]
Exported from instance.function
final
def dup[A]: Val[A] -⚬ Val[A] |*| Val[A]
Exported from instance.function
final
def dupNeg[A]: Neg[A] |*| Neg[A] -⚬ Neg[A]
Exported from instance.function
final
def elimFst[B]: One |*| B -⚬ B
Exported from instance.function
final
def elimSnd[A]: A |*| One -⚬ A
Exported from instance.function
final
def eval[A, B]: A =⚬ B |*| A -⚬ B
Exported from instance.function
final
def factorInversionOutOf_|&|[A, B]: -[A] |&| -[B] -⚬ -[A |+| B]
Exported from instance.function
final
def factorInversionOutOf_|+|[A, B]: -[A] |+| -[B] -⚬ -[A |&| B]
Exported from instance.function
final
def factorL[A, B, C]: A |*| B |+| A |*| C -⚬ A |*| B |+| C
Exported from instance.function
final
def factorOutInversion[A, B]: -[A] |*| -[B] -⚬ -[A |*| B]
Exported from instance.function
final
def factorR[A, B, C]: A |*| C |+| B |*| C -⚬ A |+| B |*| C
Exported from instance.function
final
def forevert[A]: One -⚬ -[A] |*| A
Exported from instance.function
final
def fork: Done -⚬ Done |*| Done
Exported from ScalaDSL.fork
final
def forkNeed: Need |*| Need -⚬ Need
Exported from ScalaDSL.forkNeed
final
def forkPing: Ping -⚬ Ping |*| Ping
Exported from ScalaDSL.forkPing
final
def forkPong: Pong |*| Pong -⚬ Pong
Exported from ScalaDSL.forkPong
final
def fulfill[A]: Val[A] |*| Neg[A] -⚬ One
Exported from instance.function
final
def id[A]: A -⚬ A
Exported from instance.function
final
def inflate[A]: Need -⚬ Neg[A]
Exported from instance.function
final
def injectL[A, B]: A -⚬ A |+| B
Exported from instance.function
final
def injectLOnPing[A, B]: Ping |*| A -⚬ A |+| B
Exported from instance.function
final
def injectLOnPong[A, B]: A -⚬ Pong |*| A |+| B
Exported from instance.function
final
def injectLWhenDone[A, B]: Done |*| A -⚬ Done |*| A |+| B
Exported from instance.function
final
def injectLWhenNeed[A, B]: Need |*| A -⚬ Need |*| A |+| B
Exported from instance.function
final
def injectR[A, B]: B -⚬ A |+| B
Exported from instance.function
final
def injectROnPing[A, B]: Ping |*| B -⚬ A |+| B
Exported from instance.function
final
def injectROnPong[A, B]: B -⚬ Pong |*| A |+| B
Exported from instance.function
final
def injectRWhenDone[A, B]: Done |*| B -⚬ A |+| Done |*| B
Exported from instance.function
final
def injectRWhenNeed[A, B]: Need |*| B -⚬ Need |*| A |+| B
Exported from instance.function
final
def input[C]: ContraFunctor[=⚬]
Exported from instance.function
final
def introFst[B]: B -⚬ One |*| B
Exported from instance.function
final
def introSnd[A]: A -⚬ A |*| One
Exported from instance.function
final
def invertClosure[A, B]: -[A =⚬ B] -⚬ B =⚬ A
Exported from instance.function
final
def join: Done |*| Done -⚬ Done
Exported from ScalaDSL.join
final
def joinNeed: Need -⚬ Need |*| Need
Exported from ScalaDSL.joinNeed
final
def joinPing: Ping |*| Ping -⚬ Ping
Exported from ScalaDSL.joinPing
final
def joinPong: Pong -⚬ Pong |*| Pong
Exported from ScalaDSL.joinPong
final
def lInvertPollable[A]: One -⚬ Pollable[A] |*| Subscriber[A]
Exported from instance.function
final
def lib: Lib & CoreLib[DSL]
Exported from coreStreams.lib
final
def liftBoolean: Val[Boolean] -⚬ Bool
Exported from scalaLib.liftBoolean
final
def liftEither[A, B]: Val[Either[A, B]] -⚬ Val[A] |+| Val[B]
Exported from instance.function
final
def liftNegPair[A, B]: Neg[(A, B)] -⚬ Neg[A] |*| Neg[B]
Exported from instance.function
final
def liftPair[A, B]: Val[(A, B)] -⚬ Val[A] |*| Val[B]
Exported from instance.function
final
def matchingChoiceLR[A, B, C, D]: A |+| B |*| C |&| D -⚬ A |*| C |+| B |*| D
Exported from instance.function
final
def matchingChoiceRL[A, B, C, D]: A |&| B |*| C |+| D -⚬ A |*| C |+| B |*| D
Exported from instance.function
final
def maybeToOption[A]: Maybe[Val[A]] -⚬ Val[Option[A]]
Exported from instance.function
final
def mergeDemands[A]: Neg[A] |*| Neg[A] -⚬ Neg[A]
Exported from instance.function
final
def need: Need -⚬ One
Exported from ScalaDSL.need
final
def neglect[A]: Val[A] -⚬ Done
Exported from instance.function
final
def notifyChoice[A, B]: Pong |*| A |&| B -⚬ A |&| B
Exported from instance.function
final
def notifyEither[A, B]: A |+| B -⚬ Ping |*| A |+| B
Exported from instance.function
final
def notifyNeg[A]: Pong |*| Neg[A] -⚬ Neg[A]
Exported from instance.function
final
def notifyVal[A]: Val[A] -⚬ Ping |*| Val[A]
Exported from instance.function
final
def optionToPMaybe[A]: Val[Option[A]] -⚬ PMaybe[Val[A]]
Exported from instance.function
final
def output[A]: Functor[[x] =>> A =⚬ x]
Exported from instance.function
final
def pMaybeToOption[A]: PMaybe[Val[A]] -⚬ Val[Option[A]]
Exported from instance.function
final
def pack[F[_]]: F[Rec[F]] -⚬ Rec[F]
Exported from instance.function
final
def packDemand[F[_]]: -[F[Rec[F]]] -⚬ -[Rec[F]]
Exported from instance.function
final
def ping: One -⚬ Ping
Exported from ScalaDSL.ping
final
def pong: Pong -⚬ One
Exported from ScalaDSL.pong
final
def printLine(s: String): Done -⚬ Done
Exported from scalaLib.printLine
final
def printLine: Val[String] -⚬ Done
Exported from scalaLib.printLine
final
def promise[A]: One -⚬ Neg[A] |*| Val[A]
Exported from instance.function
final
def putStr(s: String): Done -⚬ Done
Exported from scalaLib.putStr
final
def putStr: Val[String] -⚬ Done
Exported from scalaLib.putStr
final
def rInvertSubscriber[A]: Subscriber[A] |*| Pollable[A] -⚬ One
Exported from instance.function
final
def readLine: Done -⚬ Val[String]
Exported from scalaLib.readLine
final
def relayCompletion[A, B]: Pollable[A] |*| Subscriber[B] -⚬ One |+| Val[A] |*| Pollable[A] |*| Neg[B] |*| Subscriber[B]
Exported from instance.function
final
def release[R]: Res[R] -⚬ Done
Exported from instance.function
final
def subordinateFst[A, B, C, D]: A |*| B |&| C |*| D -⚬ A |+| C |*| B |&| D
Exported from instance.function
final
def subordinateSnd[A, B, C, D]: A |*| B |&| C |*| D -⚬ A |&| C |*| B |+| D
Exported from instance.function
final
def supply[A]: A |*| -[A] -⚬ One
Exported from instance.function
final
def swap[A, B]: A |*| B -⚬ B |*| A
Exported from instance.function
final
def toChoiceOfDemands[A, B]: -[A |+| B] -⚬ -[A] |&| -[B]
Exported from instance.function
final
def toScalaList[A]: LList[Val[A]] -⚬ Val[List[A]]
Exported from instance.function
final
def unInvertClosure[A, B]: A =⚬ B -⚬ -[B =⚬ A]
Exported from instance.function
final
def unliftBoolean: Bool -⚬ Val[Boolean]
final
def unliftEither[A, B]: Val[A] |+| Val[B] -⚬ Val[Either[A, B]]
Exported from instance.function
final
def unliftNegPair[A, B]: Neg[A] |*| Neg[B] -⚬ Neg[(A, B)]
Exported from instance.function
final
def unliftPair[A, B]: Val[A] |*| Val[B] -⚬ Val[(A, B)]
Exported from instance.function
final
def unpack[F[_]]: Rec[F] -⚬ F[Rec[F]]
Exported from instance.function
final
def unpackDemand[F[_]]: -[Rec[F]] -⚬ -[F[Rec[F]]]
Exported from instance.function
final
def |&|: |&|
Exported from coreLib.|&|
final
def |+|: |+|
Exported from coreLib.|+|