CoreDSL

trait CoreDSL
class Object
trait Matchable
class Any
trait ClosedDSL
trait InvertDSL
trait ScalaDSL
trait CrashDSL
trait TimerDSL

Type members

Types

type -⚬[A, B]

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

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.

type Done

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.)

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.)

type LTerminus

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

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

type Need

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.)

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.)

type One

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

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

type Ping

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 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.

type Pong

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.

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.

type RTerminus

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

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

type Rec[F[_]]
type Zero

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

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

type |&|[A, B]

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.

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.

type |*|[A, B]

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

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

type |+|[A, B]

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.

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.

type [A, B] = A |+| B

Alias for |+|.

Alias for |+|.

type [A, B] = A |*| B

Alias for |*|.

Alias for |*|.

Value members

Abstract methods

def andThen[A, B, C](f: A -⚬ B, g: B -⚬ C): A -⚬ C
def assocLR[A, B, C]: A |*| B |*| C -⚬ A |*| B |*| C
def assocRL[A, B, C]: A |*| B |*| C -⚬ A |*| B |*| C
def choice[A, B, C](f: A -⚬ B, g: A -⚬ C): A -⚬ B |&| C
def chooseL[A, B]: A |&| B -⚬ A
def chooseLOnPong[A, B]: A |&| B -⚬ Pong |*| A
def chooseR[A, B]: A |&| B -⚬ B
def coDistributeL[A, B, C]: A |*| B |&| A |*| C -⚬ A |*| B |&| C

Inverse of coFactorL.

Inverse of coFactorL.

def distributeL[A, B, C]: A |*| B |+| C -⚬ A |*| B |+| A |*| C

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

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

def either[A, B, C](f: A -⚬ C, g: B -⚬ C): A |+| B -⚬ C
def elimFst[B]: One |*| B -⚬ B
def elimSnd[A]: A |*| One -⚬ A
def id[A]: A -⚬ A
def injectL[A, B]: A -⚬ A |+| B
def injectLOnPing[A, B]: Ping |*| A -⚬ A |+| B
def injectR[A, B]: B -⚬ A |+| B
def introFst[B]: B -⚬ One |*| B
def introSnd[A]: A -⚬ A |*| One

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).

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│
 ┃      ┟────┘
 ┗━━━━━━┛
def notifyChoice[A, B]: Pong |*| A |&| B -⚬ A |&| B

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

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

def notifyEither[A, B]: A |+| B -⚬ Ping |*| A |+| B

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

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

def pack[F[_]]: F[Rec[F]] -⚬ Rec[F]

Hides one level of a recursive type definition.

Hides one level of a recursive type definition.

def par[A, B, C, D](f: A -⚬ B, g: C -⚬ D): A |*| C -⚬ B |*| D

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).

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 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.

def rec[A, B](f: A -⚬ B => A -⚬ B): A -⚬ B

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.

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.

def swap[A, B]: A |*| B -⚬ B |*| A
def unpack[F[_]]: Rec[F] -⚬ F[Rec[F]]

Unpacks one level of a recursive type definition.

Unpacks one level of a recursive type definition.

Concrete methods

def chooseROnPong[A, B]: A |&| B -⚬ Pong |*| B
def coDistributeR[A, B, C]: A |*| C |&| B |*| C -⚬ A |&| B |*| C

Inverse of coFactorR.

Inverse of coFactorR.

def coFactorL[A, B, C]: A |*| B |&| C -⚬ A |*| B |&| A |*| C
def coFactorR[A, B, C]: A |&| B |*| C -⚬ A |*| C |&| B |*| C
def distributeR[A, B, C]: A |+| B |*| C -⚬ A |*| C |+| B |*| C

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

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

def elimFst[A, B](f: A -⚬ One): A |*| B -⚬ B
def elimSnd[A, B](f: B -⚬ One): A |*| B -⚬ A
def factorL[A, B, C]: A |*| B |+| A |*| C -⚬ A |*| B |+| C

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

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

def factorR[A, B, C]: A |*| C |+| B |*| C -⚬ A |+| B |*| C

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

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

def fork[A, B](f: Done -⚬ A, g: Done -⚬ B): Done -⚬ A |*| B
def forkNeed[A, B](f: A -⚬ Need, g: B -⚬ Need): A |*| B -⚬ Need
def injectROnPing[A, B]: Ping |*| B -⚬ A |+| B
def introFst[A, X](f: One -⚬ X): A -⚬ X |*| A
def introSnd[A, X](f: One -⚬ X): A -⚬ A |*| X
def join[A, B](f: A -⚬ Done, g: B -⚬ Done): A |*| B -⚬ Done
def joinNeed[A, B](f: Need -⚬ A, g: Need -⚬ B): Need -⚬ A |*| B