libretto-core
API
Generated with
libretto-core/libretto/CoreDSL

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
Show all

Members list

Type members

Classlikes

trait $Ops

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait FunExprOps
object *

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
*.type
object +

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
+.type
object ?

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
?.type
object Affine

Attributes

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

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Comonoid[A]
object comonoidNeed.type
object comonoidOne.type
object comonoidPing.type
object comonoidPong.type
object Comonoid

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Comonoid.type
trait Comonoid[A] extends Cosemigroup[A], Affine[A]

Attributes

Companion
object
Supertypes
trait Affine[A]
trait Cosemigroup[A]
class Object
trait Matchable
class Any
Known subtypes
object comonoidNeed.type
object comonoidOne.type
object comonoidPing.type
object comonoidPong.type
trait ConcurrentPairOps

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Cosemigroup

Attributes

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

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Comonoid[A]
object comonoidNeed.type
object comonoidOne.type
object comonoidPing.type
object comonoidPong.type
object cosemigroupDone.type
object cosemigroupNeed.type
object cosemigroupPing.type
object cosemigroupPong.type
trait NComonoid[A]
Show all
implicit class FunctorOps[F[_], A](fa: $[F[A]])

Attributes

Supertypes
class Object
trait Matchable
class Any
trait LambdaOps

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait UInt31s

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object UInt31.type

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

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.

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

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.

Attributes

type Rec[F[_]]
type UInt31

Unsigned (i.e. non-negative) integer up to 31 bits. Behavior on overflow is undefined.

Unsigned (i.e. non-negative) integer up to 31 bits. Behavior on overflow is undefined.

Attributes

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
def lInvertSignal: One -⚬ Need |*| Done

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
def ping: One -⚬ Ping
def pong: Pong -⚬ One
def rInvertSignal: Done |*| Need -⚬ One

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

def racePair: Ping |*| Ping -⚬ One |+| One

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
def selectPair: One |&| One -⚬ Pong |*| Pong

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 constant[A](f: One -⚬ A)(using SourcePos, LambdaContext): $[A]
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 done: One -⚬ Done
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 joinAll(a: $[Done], as: $[Done]*)(using pos: SourcePos, ctx: LambdaContext): $[Done]
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 need: Need -⚬ One
def returning[A](a: $[A], as: $[One]*)(using pos: SourcePos, ctx: LambdaContext): $[A]
def snd[A, B, C](f: B -⚬ C): A |*| B -⚬ A |*| C

Abstract fields

val $: $Ops
val λ: LambdaOps

Extensions

Extensions

extension [A](a: $[A])
def :>>[B](f: A -⚬ B)(using pos: SourcePos, ctx: LambdaContext): $[B]

Reverse application: pass this expression into the given function.

Reverse application: pass this expression into the given function.

Attributes

def >[B](f: A -⚬ B)(using pos: SourcePos, ctx: LambdaContext): $[B]

Alias for :&gt;&gt;

Alias for :&gt;&gt;

Attributes

def also[B](f: One -⚬ B)(using pos: SourcePos, ctx: LambdaContext): $[A |*| B]
def alsoElim(unit: $[One])(using pos: SourcePos, ctx: LambdaContext): $[A]
def alsoFst[X](f: One -⚬ X)(using pos: SourcePos, ctx: LambdaContext): $[X |*| A]
def |*|[B](b: $[B])(using pos: SourcePos, ctx: LambdaContext): $[A |*| B]
extension (d: $[Done])
def alsoJoin(others: $[Done]*)(using pos: SourcePos, ctx: LambdaContext): $[Done]
extension [A, B](f: A -⚬ B)
def apply(a: $[A])(using pos: SourcePos, ctx: LambdaContext): $[B]
extension [A, B](x: $[A |+| B])
def switch[C](f: LambdaContext ?=> Either[$[A], $[B]] => $[C])(using pos: SourcePos, ctx: LambdaContext): $[C]

Implicits

Implicits

final implicit def FunctorOps[F[_], A](fa: $[F[A]]): FunctorOps[F, A]
Generated with