libretto/libretto/StarterAppBase

StarterAppBase

abstract class StarterAppBase
class Object
trait Matchable
class Any

Type members

Types

final type - >: ([A] =>> -[A]) <: ([A] =>> -[A])
final type -⚬ >: ([A, B] =>> A -⚬ B) <: ([A, B] =>> A -⚬ B)
final type =⚬ >: ([A, B] =>> A =⚬ B) <: ([A, B] =>> A =⚬ B)
final type Affine >: ([A] =>> Affine[A]) <: ([A] =>> Affine[A])
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 ClosedLinearFunctionOps >: ([A, B] =>> ClosedLinearFunctionOps[A, B]) <: ([A, B] =>> ClosedLinearFunctionOps[A, B])
final type Comonad >: ([F[_]] =>> Comonad[F]) <: ([F[_]] =>> Comonad[F])
final type Comonoid >: ([A] =>> Comonoid[A]) <: ([A] =>> Comonoid[A])
final type Comparable >: ([A, B] =>> Comparable[A, B]) <: ([A, B] =>> Comparable[A, B])
final type Consumer >: ([A] =>> Consumer[A]) <: ([A] =>> Consumer[A])
final type ConsumerF >: ([A, X] =>> ConsumerF[A, X]) <: ([A, X] =>> ConsumerF[A, X])
final type ContraExternalizer >: ([F[_]] =>> ContraExternalizer[F]) <: ([F[_]] =>> ContraExternalizer[F])
final type ContraFunctor >: ([F[_]] =>> ContraFunctor[F]) <: ([F[_]] =>> ContraFunctor[F])
final type Cosemigroup >: ([A] =>> Cosemigroup[A]) <: ([A] =>> Cosemigroup[A])
final type Delayed >: ([A] =>> Delayed[A]) <: ([A] =>> Delayed[A])
final type Demanding >: ([A] =>> Demanding[A]) <: ([A] =>> Demanding[A])
final type Done >: Done <: Done
final type Dual >: ([A, B] =>> Dual[A, B]) <: ([A, B] =>> Dual[A, B])
final type Dual1 >: ([F[_], G[_]] =>> Dual1[F, G]) <: ([F[_], G[_]] =>> Dual1[F, G])
final type Endless >: ([A] =>> Endless[A]) <: ([A] =>> Endless[A])
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 >: ([S, A] =>> Getter[S, A]) <: ([S, A] =>> Getter[S, A])
final type Id >: ([A] =>> Id[A]) <: ([A] =>> Id[A])
final type LDemanding >: ([A] =>> LDemanding[A]) <: ([A] =>> LDemanding[A])
final type LList >: ([T] =>> LList[T]) <: ([T] =>> LList[T])
final type LList1 >: ([T] =>> LList1[T]) <: ([T] =>> LList1[T])
final type LPollable >: ([A] =>> LPollable[A]) <: ([A] =>> LPollable[A])
final type LPollableF >: ([A, X] =>> LPollableF[A, X]) <: ([A, X] =>> LPollableF[A, X])
final type LPolled >: ([A] =>> LPolled[A]) <: ([A] =>> LPolled[A])
final type LSubscriber >: ([A] =>> LSubscriber[A]) <: ([A] =>> LSubscriber[A])
final type LSubscriberF >: ([A, X] =>> LSubscriberF[A, X]) <: ([A, X] =>> LSubscriberF[A, X])
final type LTerminus >: LTerminus <: LTerminus
final type Lens >: ([S, A] =>> Lens[S, A]) <: ([S, A] =>> Lens[S, A])
final type LinearFunctionOps >: ([A, B] =>> LinearFunctionOps[A, B]) <: ([A, B] =>> LinearFunctionOps[A, B])
final type LinearFunctionToPairOps >: ([A, B1, B2] =>> LinearFunctionToPairOps[A, B1, B2]) <: ([A, B1, B2] =>> LinearFunctionToPairOps[A, B1, B2])
final type LinearFunctionToPlusOps >: ([A, B1, B2] =>> LinearFunctionToPlusOps[A, B1, B2]) <: ([A, B1, B2] =>> LinearFunctionToPlusOps[A, B1, B2])
final type Maybe >: ([A] =>> Maybe[A]) <: ([A] =>> Maybe[A])
final type Monad >: ([F[_]] =>> Monad[F]) <: ([F[_]] =>> Monad[F])
final type Monoid >: ([A] =>> Monoid[A]) <: ([A] =>> Monoid[A])
final type Multiple >: ([A] =>> Multiple[A]) <: ([A] =>> Multiple[A])
final type NAffine >: ([A] =>> NAffine[A]) <: ([A] =>> NAffine[A])
final type NComonoid >: ([A] =>> NComonoid[A]) <: ([A] =>> NComonoid[A])
final type NMonoid >: ([A] =>> NMonoid[A]) <: ([A] =>> NMonoid[A])
final type Need >: Need <: Need
final type Neg >: ([A] =>> Neg[A]) <: ([A] =>> Neg[A])
final type One >: One <: One
final type Optionally >: ([A] =>> Optionally[A]) <: ([A] =>> Optionally[A])
final type PAffine >: ([A] =>> PAffine[A]) <: ([A] =>> PAffine[A])
final type PComonoid >: ([A] =>> PComonoid[A]) <: ([A] =>> PComonoid[A])
final type PMaybe >: ([A] =>> PMaybe[A]) <: ([A] =>> PMaybe[A])
final type PMonoid >: ([A] =>> PMonoid[A]) <: ([A] =>> PMonoid[A])
final type PUnlimited >: ([A] =>> PUnlimited[A]) <: ([A] =>> PUnlimited[A])
final type Ping >: Ping <: Ping
final type Pollable >: ([A] =>> Pollable[A]) <: ([A] =>> Pollable[A])
final type PollableF >: ([A, X] =>> PollableF[A, X]) <: ([A, X] =>> PollableF[A, X])
final type Polled >: ([A] =>> Polled[A]) <: ([A] =>> Polled[A])
final type Pong >: Pong <: Pong
final type Producing >: ([A] =>> Producing[A]) <: ([A] =>> Producing[A])
final type ProducingF >: ([A, X] =>> ProducingF[A, X]) <: ([A, X] =>> ProducingF[A, X])
final type RTerminus >: RTerminus <: RTerminus
final type Rec >: ([F[_]] =>> Rec[F]) <: ([F[_]] =>> Rec[F])
final type RefCounted >: ([R] =>> RefCounted[R]) <: ([R] =>> RefCounted[R])
final type Res >: ([A] =>> Res[A]) <: ([A] =>> Res[A])
final type Semigroup >: ([A] =>> Semigroup[A]) <: ([A] =>> Semigroup[A])
final type Subscriber >: ([A] =>> Subscriber[A]) <: ([A] =>> Subscriber[A])
final type SubscriberF >: ([A, X] =>> SubscriberF[A, X]) <: ([A, X] =>> SubscriberF[A, X])
final type Transportive >: ([F[_]] =>> Transportive[F]) <: ([F[_]] =>> Transportive[F])
final type Unlimited >: ([A] =>> Unlimited[A]) <: ([A] =>> Unlimited[A])
final type Val >: ([A] =>> Val[A]) <: ([A] =>> Val[A])
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 |&| >: ([A, B] =>> A |&| B) <: ([A, B] =>> A |&| B)
final type |*| >: ([A, B] =>> A |*| B) <: ([A, B] =>> A |*| B)
final type |+| >: ([A, B] =>> A |+| B) <: ([A, B] =>> A |+| B)
final type ⊕ >: ([A, B] =>> A |+| B) <: ([A, B] =>> A |+| B)
final type ⊗ >: ([A, B] =>> A |*| B) <: ([A, B] =>> A |*| B)

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[[x] =>> x |*| B]
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 pairBifunctor: Bifunctor[|*|]
Exported from coreLib.pairBifunctor
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 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 Delayed: Delayed
Exported from coreLib.Delayed
final def Dual: Dual
Exported from coreLib.Dual
final def Endless: Endless
Exported from coreLib.Endless
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 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 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 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 coreLib: CoreLib & CoreLib[DSL]
Exported from scalaLib.coreLib
final def coreStreams: Streams & CoreStreams[DSL, Lib & CoreLib[DSL]]
final def crashd(msg: String): Done -⚬ Done
Exported from dsl.crashd
final def crashn(msg: String): Need -⚬ Need
Exported from dsl.crashn
final def delay(d: FiniteDuration): Done -⚬ Done
Exported from dsl.delay
final def delay: Val[FiniteDuration] -⚬ Done
Exported from dsl.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 dsl.delayNeed
final def delayNeed(d: FiniteDuration): Need -⚬ Need
Exported from dsl.delayNeed
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 dsl.done
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 factorL[A, B, C]: A |*| B |+| A |*| C -⚬ A |*| B |+| C
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 dsl.fork
final def forkNeed: Need |*| Need -⚬ Need
Exported from dsl.forkNeed
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[[x] =>> x =⚬ C]
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 join: Done |*| Done -⚬ Done
Exported from dsl.join
final def joinNeed: Need -⚬ Need |*| Need
Exported from dsl.joinNeed
final def joinPing: Ping |*| Ping -⚬ Ping
Exported from dsl.joinPing
final def joinPong: Pong -⚬ Pong |*| Pong
Exported from dsl.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 dsl.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 notifyDoneL: Done -⚬ Ping |*| Done
Exported from dsl.notifyDoneL
final def notifyDoneR: Done -⚬ Done |*| Ping
Exported from dsl.notifyDoneR
final def notifyEither[A, B]: A |+| B -⚬ Ping |*| A |+| B
Exported from instance.function
final def notifyNeedL: Pong |*| Need -⚬ Need
Exported from dsl.notifyNeedL
final def notifyNeedR: Need |*| Pong -⚬ Need
Exported from dsl.notifyNeedR
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 ping: One -⚬ Ping
Exported from dsl.ping
final def pong: Pong -⚬ One
Exported from dsl.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 racePair: Ping |*| Ping -⚬ One |+| One
Exported from dsl.racePair
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 scalaLib: SLib & ScalaLib[DSL, Lib & CoreLib[DSL]]
Exported from scalaStreams.scalaLib
final def selectPair: One |&| One -⚬ Pong |*| Pong
Exported from dsl.selectPair
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 swap[A, B]: A |*| B -⚬ B |*| A
Exported from instance.function
final def toScalaList[A]: LList[Val[A]] -⚬ Val[List[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 |&|: |&|
Exported from coreLib.|&|
final def |*|: |*|
Exported from coreLib.|*|
final def |+|: |+|
Exported from coreLib.|+|