StarterAppScala

Λ is the uppercase Greek letter lambda.

Make a function A =⚬ B ''"absorb"'' a C and return it as part of its output, i.e. A =⚬ (B |*| C).

Acquires a resource of type R.

Variant of acquire that does not produce extra output in addition to the resource.

Variant of acquireAsync that does not produce extra output in addition to the resource.

Chooses the left alternative A of the choice A |&| B, but only after the Need signal from the first out-port arrives. Until then, the producer of A |&| B will see it as undecided. This is different from chooseL[A, B] > awaitNegFst[A], in which the producer of A |&| B knows immediately that the left side is chosen.

Analogous to awaitChooseL, but chooses the right side.

Injects A from the the second in-port to the left side of the |+| in the out-port, but only after the Done signal from the first in-port arrives. That means that the consumer of A |+| B will see it as undecided until the Done signal arrives. This is different from awaitPosFst[A] > injectL[A, B], in which the consumer of A |+| B knows immediately that it is the left case.

This is a convenience method on top of injectLWhenDone that which absorbs the Done signal using the given Junction.Positive.

Analogous to joinInjectL, but injects to the right.

Analogous to awaitChooseL, but awaits a positive (i.e. Done) signal.

Analogous to awaitChooseR, but awaits a positive (i.e. Done) signal.

Obstructs interaction on the in-port (i.e. from the left) until Pong is received.

Obstructs interaction on the out-port (i.e. from the right) until Ping is received.

Executes a potentially blocking operation. The implementation must ensure that the blocking operation does not impede any of the concurrently happening non-blocking computations.

Inverse of coFactorL.

Inverse of coFactorR.

Lifts an ordinary Scala function to a linear function on demands, in opposite direction.

Starts propagating an error downstream (which might be through both the in-port and the out-port).

Use only for irrecoverable errors. Recoverable errors should be expressed in function signature and handled appropriately.

Done on the in-port is the trigger to crash. A on the in-port allows to consume any unhandled resources. B on the out-port allows to fulfill any obligation to produce resources.