CoreDSL

libretto.CoreDSL
trait CoreDSL

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait ClosedDSL
trait InvertDSL
trait Scaletto
object FreeScaletto.type
trait CrashDSL
trait TimerDSL

Members list

Concise view

Type members

Classlikes

trait $Ops

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Affine

Attributes

Companion:
trait
Graph
Supertypes
class Object
trait Matchable
class Any
Self type
Affine.type
trait Affine[A]

Attributes

Companion:
object
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Comonoid[A]
object Comonoid

Attributes

Companion:
trait
Graph
Supertypes
class Object
trait Matchable
class Any
Self type
trait Comonoid[A] extends Cosemigroup[A] with Affine[A]

Attributes

Companion:
object
Graph
Supertypes
trait Affine[A]
trait Cosemigroup[A]
class Object
trait Matchable
class Any

Attributes

Companion:
trait
Graph
Supertypes
class Object
trait Matchable
class Any
Self type
trait Cosemigroup[A]

Attributes

Companion:
object
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Comonoid[A]
trait NComonoid[A]
trait PComonoid[A]
trait LambdaOps

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes

Types

type $[A]

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

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

Attributes

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.

Attributes

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

Attributes

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.

Attributes

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

Attributes

type NotLinearException <: Throwable
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.

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

type Rec[F[_]]
type UnboundVariablesException <: Throwable
type Zero

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

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

Attributes

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.

Attributes

type |*|[A, B]

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

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

Attributes

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.

Attributes

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

Alias for |+|.

Alias for |+|.

Attributes

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

Alias for |*|.

Alias for |*|.

Attributes

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](caseLeft: A -⚬ B, caseRight: 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.

Attributes

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.

Attributes

def either[A, B, C](caseLeft: A -⚬ C, caseRight: 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│
 ┃      ┟────┘
 ┗━━━━━━┛

Attributes

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.

Attributes

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.

Attributes

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

Hides one level of a recursive type definition.

Hides one level of a recursive type definition.

Attributes

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│←┄┘   ┃
 ┟────┘      ┃
 ┗━━━━━━━━━━━┛

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

def forkMap[A, B](f: Done -⚬ A, g: Done -⚬ B): Done -⚬ A |*| B
def forkMapNeed[A, B](f: A -⚬ Need, g: B -⚬ Need): A |*| B -⚬ Need
def fst[A, B, C](f: A -⚬ B): A |*| C -⚬ B |*| C
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 joinMap[A, B](f: A -⚬ Done, g: B -⚬ Done): A |*| B -⚬ Done
def joinMapNeed[A, B](f: Need -⚬ A, g: Need -⚬ B): Need -⚬ A |*| B
def snd[A, B, C](f: B -⚬ C): A |*| B -⚬ A |*| C

Abstract fields

val $: $Ops