ScalaDSL

Demand for a Scala value of type A.

Somewhat analogous to scala.concurrent.Promise

Resource that is a Scala object of type A. Unlike Val, a resource can be mutable, cannot in general be neglected or duplicated, and is automatically cleaned-up in case of crash.

It is recommended to define custom opaque type aliases of resources, such as

opaque type Input = Res[java.io.InputStream]

Scala value of type A.

Somewhat analogous to scala.concurrent.Future.

The type of auxiliary placeholder variables used in construction of λ-expressions.

-[A] is a demand for A.

Inverts the flow of information: whatever travels through A in one direction, travels through -[A] in the opposite direction.

Libretto arrow, also called a ''component'' or a ''linear function''.

┏━━━━━━━━━━┓
┞───┐      ┞───┐
╎ A │      ╎ B │
┟───┘      ┟───┘
┗━━━━━━━━━━┛

In A -⚬ B, we say that the ''in-port'' is of type A and the ''out-port'' is of type B. Note that the distinction between the in-port and the out-port is only formal. Information or resources may flow in and out through both the in-port and the out-port.

"Linear" means that each input is ''consumed'' exactly once, in particular, it cannot be ignored or used twice.

Signal that travels in the direction of -⚬, i.e. the positive direction. It may signal completion of a (potentially effectful) computation. It cannot be ignored. (If this signal was the only handle to an (effectful) computation, ignoring it would mean losing track of that computation, which is considered to be a resource leak.)

A black hole that can absorb (i.e. take over the responsibility to await) Need signals, but from which there is no escape.

Signal that travels in the direction opposite to -⚬, i.e. the negative direction. It may signal completion of a (potentially effectful) computation. It cannot be ignored. (If this signal was the only handle to an (effectful) computation, ignoring it would mean losing track of that computation, which is considered to be a resource leak.)

No resource. It is the identity element for |*|. There is no flow of information through a One-typed port.

Signal that travels in the direction of -⚬, i.e. the positive direction. [Unlike Done, it cannot be the only handle to an effectful computation. As such, it can be ignored, e.g. as the losing contestant in racePair.

Signal that travels in the direction opposite to -⚬, i.e. the negative direction. Unlike Need, it cannot be the only handle to an effectful computation. As such, it can be ignored, e.g. as the losing contestant in selectPair.

A black hole that can absorb (i.e. take over the responsibility to await) Done signals, but from which there is no escape.

Impossible resource. Analogous to Nothing. It is the identity element for |+|.

Choice between A and B. The consumer chooses whether to get A or B (but can get only one of them). The producer has to be ready to provide either of them.

Concurrent pair. Also called a ''tensor product'' or simply ''times''.

Either A or B. Analogous to scala.Either. Whether it is going to be A or B is decided by the producer. The consumer has to be ready to handle either of the two cases.

Alias for |+|.

Alias for |*|.

Acquires a resource of type R.

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

Prints the given message to the console, without creating an obligation to await.

Lifts an ordinary Scala function to a linear function on Vals.

Releases a resource using the release function registered during resource acquisition.

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

Performs a (potentially) effectful operation on a resource, producing some output.

Variant of effect that does not produce output in addition to performing the effect. Can be viewed as ''wr''iting an A into the resource.

Uses the value (eventually) produced by Val to satisfy the demand of Neg.

Creates an entangled pair of demand (Neg) and supply (Val) such that when the demand is fulfilled with a value, that value will be produced by the supply.

Releases a resource using the given function. The release function previously registered during resource acquisition is not used.

Transforms a resource into a resource of (possibly) different type.

Acquires a resource of type R. Might fail with an error of type E.

Transforms a resource into a resource of (possibly) different type. Might fail with an error of type E.

Inverse of coFactorL.

Inverse of coFactorR.

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.

Creates a demand on the first out-port, channeling the provided resource to the second out-port. Alias for forevert.

Converts an obligation to handle either demand to an obligation to supply a choice. Alias for factorInversionOutOf_|+|.

Converts a demand for choice to a demand of the chosen side. Alias for distributeInversionInto_|&|.

Converts choice of demands to demand of either. Alias for factorInversionOutOf_|&|.

Alias for distributeInversion

Alias for factorOutInversion.

Double-inversion elimination.

Double-inversion introduction.

Distribute the factor on the left into the summands on the right. Inverse of factorL.

Distribute the factor on the right into the summands on the left. Inverse of factorR.

Alias for die.

Alias for dii.

Factor out the factor A on the left of both summands.

Factor out the factor C on the right of both summands.

Reverses the Need signal (flowing in the negative direciton, i.e. against the -⚬ arrow) into a Done signal (flowing in the positive direction, i.e. along the -⚬ arrow).

 ┏━━━━━━┓
 ┃      ┞────┐
 ┃   ┌┄┄╎Need│
 ┃   ┆  ┟────┘
 ┃   ┆  ┃
 ┃   ┆  ┞────┐
 ┃   └┄→╎Done│
 ┃      ┟────┘
 ┗━━━━━━┛

Signals (in the negative direction) when it is known which side of the choice (A |&| B) has been chosen.

Signals when it is decided whether A |+| B actually contains the left side or the right side.

Turn a function into a function object.

Hides one level of a recursive type definition.

Reverses the Done signal (flowing in the positive direction, i.e. along the -⚬ arrow) into a Need signal (flowing in the negative direciton, i.e. against the -⚬ arrow).

 ┏━━━━━━━━━━━┓
 ┞────┐      ┃
 ╎Done│┄┄┐   ┃
 ┟────┘  ┆   ┃
 ┃       ┆   ┃
 ┞────┐  ┆   ┃
 ╎Need│←┄┘   ┃
 ┟────┘      ┃
 ┗━━━━━━━━━━━┛

Races the two Ping signals. Produces left if the first signal wins and right if the second signal wins. It is biased to the left: if both signals have arrived by the time of inquiry, returns left.

Races the two Pong signals (traveling from right to left). Chooses left if the first signal wins and right if the second signal wins. It is biased to the left: if both signals have arrived by the time of inquiry, chooses left.

Uses the resource from the first in-port to satisfy the demand from the second in-port. Alias for backvert.

Converts demand for either to a choice of which side to supply. Alias for distributeInversionInto_|+|.

Unpacks one level of a recursive type definition.

Creates a closure (A =⚬ B), i.e. a function that captures variables from the outer scope, as an expression ($[A =⚬ B]) that can be used in outer λ or Λ.

Used to define a linear function A -⚬ B in a point-full style, i.e. as a lambda expression.

Recall that when defining A -⚬ B, we never get a hold of a: A as a Scala value. However, by using this method we get a hold of a: $[A], a placeholder variable, and construct the result expression $[B]. This method then inspects how the input variable a: $[A] is used in the result $[B] and infers a (point-free) construction of A -⚬ B.