libretto
API
Generated with
© 2002-2021 · LAMP/EPFL
© 2002-2021 · LAMP/EPFL
libretto/libretto.scaletto/Scaletto

Scaletto

libretto.scaletto.Scaletto
trait Scaletto extends TimerDSL with CrashDSL with InvertDSL

Supports manipulating Scala values via pure Scala functions. Also extends InvertDSL (and thus ClosedDSL), TimerDSL and CrashDSL, since these are expected to be possible on a target platform that already supports Scala functions.

Attributes

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

Members list

Concise view

Type members

Inherited classlikes

trait $Ops

Attributes

Inherited from:
CoreDSL
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Affine

Attributes

Inherited from:
CoreDSL
Graph
Supertypes
class Object
trait Matchable
class Any
trait Affine[A]

Attributes

Inherited from:
CoreDSL
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Comonoid[A]
trait ClosureOps

Attributes

Inherited from:
ClosedDSL
Graph
Supertypes
class Object
trait Matchable
class Any
object Comonoid

Attributes

Inherited from:
CoreDSL
Graph
Supertypes
class Object
trait Matchable
class Any
trait Comonoid[A] extends Cosemigroup[A] with Affine[A]

Attributes

Inherited from:
CoreDSL
Graph
Supertypes
trait Affine[A]
trait Cosemigroup[A]
class Object
trait Matchable
class Any
object Cosemigroup

Attributes

Inherited from:
CoreDSL
Graph
Supertypes
class Object
trait Matchable
class Any
trait Cosemigroup[A]

Attributes

Inherited from:
CoreDSL
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Comonoid[A]
trait NComonoid[A]
trait PComonoid[A]
implicit class DemandExprOps[B](expr: $[-[B]])

Attributes

Inherited from:
InvertDSL
Graph
Supertypes
class Object
trait Matchable
class Any
trait FunExprOps extends $Ops

Attributes

Inherited from:
ClosedDSL
Graph
Supertypes
trait $Ops
class Object
trait Matchable
class Any
trait LambdaOps

Attributes

Inherited from:
CoreDSL
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait LambdaOpsWithClosures extends LambdaOps

Attributes

Inherited from:
ClosedDSL
Graph
Supertypes
trait LambdaOps
class Object
trait Matchable
class Any

Types

type Neg[A] = -[Val[A]]

Demand for a Scala value of type A.

Demand for a Scala value of type A.

Somewhat analogous to scala.concurrent.Promise

Attributes

type Res[A]

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.

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]

Attributes

type Val[A]

Scala value of type A.

Scala value of type A.

Somewhat analogous to scala.concurrent.Future.

Attributes

Inherited 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

Inherited from:
CoreDSL
type -[A]

-[A] is a demand for A.

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

Attributes

Inherited from:
InvertDSL
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

Inherited from:
CoreDSL
override type =⚬[A, B] = -[A] |*| B

Linear function as data, that is, one that can be part of an input or output of a linear function (-⚬). While A -⚬ B is a morphism in a category, A =⚬ B is an object called the internal hom of A and B in a closed monoidal category.

Linear function as data, that is, one that can be part of an input or output of a linear function (-⚬). While A -⚬ B is a morphism in a category, A =⚬ B is an object called the internal hom of A and B in a closed monoidal category.

Attributes

Inherited from:
InvertDSL
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

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
type NoCaptureException <: Throwable

Attributes

Inherited from:
ClosedDSL
type NotLinearException <: Throwable

Attributes

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
type Rec[F[_]]

Attributes

Inherited from:
CoreDSL
type UnboundVariablesException <: Throwable

Attributes

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
type |*|[A, B]

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

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

Attributes

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
type ⊕[A, B] = A |+| B

Alias for |+|.

Alias for |+|.

Attributes

Inherited from:
CoreDSL
type ⊗[A, B] = A |*| B

Alias for |*|.

Alias for |*|.

Attributes

Inherited from:
CoreDSL

Value members

Abstract methods

def acquire[A, R, B](acquire: A => (R, B), release: Option[R => Unit]): Val[A] -⚬ Res[R] |*| Val[B]

Acquires a resource of type R.

Acquires a resource of type R.

Attributes

A

parameters of the acquire function

B

additional data produced by acquiring the resource

R

type of the resource

release

called to release the resource in case of a crash. None means no cleanup is needed

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

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

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

Attributes

def constNeg[A](a: A): Neg[A] -⚬ Need
def constVal[A](a: A): Done -⚬ Val[A]
def debugPrint(msg: String): Ping -⚬ One

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

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

Attributes

def delay: Val[FiniteDuration] -⚬ Done
def effectAsync[R, A, B](f: (R, A) => Async[B]): Res[R] |*| Val[A] -⚬ Res[R] |*| Val[B]
def effectWrAsync[R, A](f: (R, A) => Async[Unit]): Res[R] |*| Val[A] -⚬ Res[R]
def liftEither[A, B]: Val[Either[A, B]] -⚬ Val[A] |+| Val[B]
def liftPair[A, B]: Val[(A, B)] -⚬ Val[A] |*| Val[B]
def mapVal[A, B](f: A => B): Val[A] -⚬ Val[B]

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

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

Attributes

def neglect[A]: Val[A] -⚬ Done
def notifyNeg[A]: Pong |*| Neg[A] -⚬ Neg[A]
def notifyVal[A]: Val[A] -⚬ Ping |*| Val[A]
def release[R]: Res[R] -⚬ Done

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

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

Attributes

def releaseAsync[R, A, B](f: (R, A) => Async[B]): Res[R] |*| Val[A] -⚬ Val[B]
def tryAcquireAsync[A, R, B, E](acquire: A => Async[Either[E, (R, B)]], release: Option[R => Async[Unit]]): Val[A] -⚬ Val[E] |+| Res[R] |*| Val[B]
def trySplitResourceAsync[R, A, S, T, B, E](f: (R, A) => Async[Either[E, (S, T, B)]], release1: Option[S => Async[Unit]], release2: Option[T => Async[Unit]]): Res[R] |*| Val[A] -⚬ Val[E] |+| Res[S] |*| Res[T] |*| Val[B]
def tryTransformResourceAsync[R, A, S, B, E](f: (R, A) => Async[Either[E, (S, B)]], release: Option[S => Async[Unit]]): Res[R] |*| Val[A] -⚬ Val[E] |+| Res[S] |*| Val[B]
def unliftPair[A, B]: Val[A] |*| Val[B] -⚬ Val[(A, B)]

Concrete methods

def acquireAsync[A, R, B](acquire: A => Async[(R, B)], release: Option[R => Async[Unit]]): Val[A] -⚬ Res[R] |*| Val[B]
def contramapNeg[A, B](f: A => B): Neg[B] -⚬ Neg[A]

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

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

Attributes

override def delay(d: FiniteDuration): Done -⚬ Done

Attributes

Definition Classes
def delayNeed: Need -⚬ Neg[FiniteDuration]
def dup[A]: Val[A] -⚬ Val[A] |*| Val[A]
def dupNeg[A]: Neg[A] |*| Neg[A] -⚬ Neg[A]
def effect[R, A, B](f: (R, A) => B): Res[R] |*| Val[A] -⚬ Res[R] |*| Val[B]

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

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

Attributes

A

additional parameter of the operation

B

additional output of the operation

R

type of the resource

f

the effectful operation

def effectWr[R, A](f: (R, A) => Unit): Res[R] |*| Val[A] -⚬ Res[R]

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.

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.

Attributes

def fulfill[A]: Val[A] |*| Neg[A] -⚬ One

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

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

Attributes

def inflate[A]: Need -⚬ Neg[A]
def liftNegPair[A, B]: Neg[(A, B)] -⚬ Neg[A] |*| Neg[B]
def promise[A]: One -⚬ Neg[A] |*| Val[A]

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.

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.

Attributes

def release[R, A, B](f: (R, A) => B): Res[R] |*| Val[A] -⚬ Val[B]

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

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

Attributes

A

additional parameter of the release function

B

additional data produced by the release function

R

type of the resource

f

the release function

def splitResource[R, A, S, T, B](f: (R, A) => (S, T, B), release1: Option[S => Unit], release2: Option[T => Unit]): Res[R] |*| Val[A] -⚬ Res[S] |*| Res[T] |*| Val[B]
def splitResourceAsync[R, A, S, T, B](f: (R, A) => Async[(S, T, B)], release1: Option[S => Async[Unit]], release2: Option[T => Async[Unit]]): Res[R] |*| Val[A] -⚬ Res[S] |*| Res[T] |*| Val[B]
def transformResource[R, A, S, B](f: (R, A) => (S, B), release: Option[S => Unit]): Res[R] |*| Val[A] -⚬ Res[S] |*| Val[B]

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

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

Attributes

A

additional parameter of the transformation

B

additional output of the transformation

R

type of the input resource

S

type of the output resource

f

the transformation function. It receives the input resource and additional input of type A. It returns the new resource and additional output of type B.

release

called to release the new resource in case of a crash. None means no cleanup is needed

def transformResourceAsync[R, A, S, B](f: (R, A) => Async[(S, B)], release: Option[S => Async[Unit]]): Res[R] |*| Val[A] -⚬ Res[S] |*| Val[B]
def tryAcquire[A, R, B, E](acquire: A => Either[E, (R, B)], release: Option[R => Unit]): Val[A] -⚬ Val[E] |+| Res[R] |*| Val[B]

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

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

Attributes

A

parameters of the acquire function

B

additional data produced by acquiring the resource

E

type of the error

R

type of the resource

release

called to release the resource in case of a crash. None means no cleanup is needed

def trySplitResource[R, A, S, T, B, E](f: (R, A) => Either[E, (S, T, B)], release1: Option[S => Unit], release2: Option[T => Unit]): Res[R] |*| Val[A] -⚬ Val[E] |+| Res[S] |*| Res[T] |*| Val[B]
def tryTransformResource[R, A, S, B, E](f: (R, A) => Either[E, (S, B)], release: Option[S => Unit]): Res[R] |*| Val[A] -⚬ Val[E] |+| Res[S] |*| Val[B]

Transforms a resource into a resource of (possibly) different type. 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.

Attributes

A

additional parameter of the transformation

B

additional output of the transformation

E

type of the error

R

type of the input resource

S

type of the output resource

f

the transformation function. It receives the input resource and additional input of type A. It returns either an error of type E or the new resource and additional output of type B. In case the transformation results in an error, the original resource is ''not'' released automatically— the passing of the original resource R to the transformation function f indicates transfer of responsibility for the resource to the function f.

release

called to release the new resource in case of a crash. None means no cleanup is needed

def unliftEither[A, B]: Val[A] |+| Val[B] -⚬ Val[Either[A, B]]
def unliftNegPair[A, B]: Neg[A] |*| Neg[B] -⚬ Neg[(A, B)]

Inherited methods

def andThen[A, B, C](f: A -⚬ B, g: B -⚬ C): A -⚬ C

Attributes

Inherited from:
CoreDSL
def assocLR[A, B, C]: A |*| B |*| C -⚬ A |*| B |*| C

Attributes

Inherited from:
CoreDSL
def assocRL[A, B, C]: A |*| B |*| C -⚬ A |*| B |*| C

Attributes

Inherited from:
CoreDSL
def backvert[A]: A |*| -[A] -⚬ One
 ┏━━━━━━━━━━━┓
 ┞────┐      ┃
 ╎  A │┄┄┐   ┃
 ┟────┘  ┆   ┃
 ┃       ┆   ┃
 ┞────┐  ┆   ┃
 ╎-[A]│←┄┘   ┃
 ┟────┘      ┃
 ┗━━━━━━━━━━━┛

Attributes

Inherited from:
InvertDSL
def choice[A, B, C](caseLeft: A -⚬ B, caseRight: A -⚬ C): A -⚬ B |&| C

Attributes

Inherited from:
CoreDSL
def chooseL[A, B]: A |&| B -⚬ A

Attributes

Inherited from:
CoreDSL
def chooseLOnPong[A, B]: A |&| B -⚬ Pong |*| A

Attributes

Inherited from:
CoreDSL
def chooseR[A, B]: A |&| B -⚬ B

Attributes

Inherited from:
CoreDSL
def chooseROnPong[A, B]: A |&| B -⚬ Pong |*| B

Attributes

Inherited from:
CoreDSL
def coDistributeL[A, B, C]: A |*| B |&| A |*| C -⚬ A |*| B |&| C

Inverse of coFactorL.

Inverse of coFactorL.

Attributes

Inherited from:
CoreDSL
def coDistributeR[A, B, C]: A |*| C |&| B |*| C -⚬ A |&| B |*| C

Inverse of coFactorR.

Inverse of coFactorR.

Attributes

Inherited from:
CoreDSL
def coFactorL[A, B, C]: A |*| B |&| C -⚬ A |*| B |&| A |*| C

Attributes

Inherited from:
CoreDSL
def coFactorR[A, B, C]: A |&| B |*| C -⚬ A |*| C |&| B |*| C

Attributes

Inherited from:
CoreDSL
def contrapositive[A, B](f: A -⚬ B): -[B] -⚬ -[A]

Attributes

Inherited from:
InvertDSL
def crashNow[A, B](msg: String): A -⚬ B

Attributes

Inherited from:
CrashDSL
def crashWhenDone[A, B](msg: String): Done |*| A -⚬ B

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

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.

Attributes

Inherited from:
CrashDSL
def crashWhenNeed[A, B](msg: String): A -⚬ Need |*| B

Attributes

Inherited from:
CrashDSL
def crashd(msg: String): Done -⚬ Done

Attributes

Inherited from:
CrashDSL
def crashn(msg: String): Need -⚬ Need

Attributes

Inherited from:
CrashDSL
override def curry[A, B, C](f: A |*| B -⚬ C): A -⚬ B =⚬ C

Attributes

Definition Classes
Inherited from:
InvertDSL
def delayIndefinitely: Done -⚬ RTerminus

Attributes

Inherited from:
CoreDSL
def delayNeed(d: FiniteDuration): Need -⚬ Need

Attributes

Inherited from:
TimerDSL
def demand[A]: One -⚬ -[A] |*| A

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

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

Attributes

Inherited from:
InvertDSL
def demandChoice[A, B]: -[A] |+| -[B] -⚬ -[A |&| B]

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

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

Attributes

Inherited from:
InvertDSL
def demandChosen[A, B]: -[A |&| B] -⚬ -[A] |+| -[B]

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

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

Attributes

Inherited from:
InvertDSL
def demandEither[A, B]: -[A] |&| -[B] -⚬ -[A |+| B]

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

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

Attributes

Inherited from:
InvertDSL
def demandSeparately[A, B]: -[A |*| B] -⚬ -[A] |*| -[B]

Alias for distributeInversion

Alias for distributeInversion

Attributes

Inherited from:
InvertDSL
def demandTogether[A, B]: -[A] |*| -[B] -⚬ -[A |*| B]

Alias for factorOutInversion.

Alias for factorOutInversion.

Attributes

Inherited from:
InvertDSL
def die[A]: -[-[A]] -⚬ A

Double-inversion elimination.

Double-inversion elimination.

Attributes

Inherited from:
InvertDSL
def dii[A]: A -⚬ -[-[A]]

Double-inversion introduction.

Double-inversion introduction.

Attributes

Inherited from:
InvertDSL
def dismissPing: Ping -⚬ One

Attributes

Inherited from:
CoreDSL
def dismissPong: One -⚬ Pong

Attributes

Inherited from:
CoreDSL
def distributeInversion[A, B]: -[A |*| B] -⚬ -[A] |*| -[B]
 ┏━━━━━━━━━━━┓
 ┃           ┞────┐
 ┞────┐      ╎-[A]│
 ╎ ⎡A⎤│      ┟────┘
 ╎-⎢⊗⎥│      ┃
 ╎ ⎣B⎦│      ┞────┐
 ┟────┘      ╎-[B]│
 ┃           ┟────┘
 ┗━━━━━━━━━━━┛

Attributes

Inherited from:
InvertDSL
def distributeInversionInto_|&|[A, B]: -[A |&| B] -⚬ -[A] |+| -[B]

Attributes

Inherited from:
InvertDSL
def distributeInversionInto_|+|[A, B]: -[A |+| B] -⚬ -[A] |&| -[B]

Attributes

Inherited from:
InvertDSL
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

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
def done: One -⚬ Done

Attributes

Inherited from:
CoreDSL
def doneAsInvertedNeed: Done -⚬ -[Need]

Attributes

Inherited from:
InvertDSL
def doubleDemandElimination[A]: -[-[A]] -⚬ A

Alias for die.

Alias for die.

Attributes

Inherited from:
InvertDSL
def doubleDemandIntroduction[A]: A -⚬ -[-[A]]

Alias for dii.

Alias for dii.

Attributes

Inherited from:
InvertDSL
def either[A, B, C](caseLeft: A -⚬ C, caseRight: B -⚬ C): A |+| B -⚬ C

Attributes

Inherited from:
CoreDSL
def elimFst[A, B](f: A -⚬ One): A |*| B -⚬ B

Attributes

Inherited from:
CoreDSL
def elimFst[B]: One |*| B -⚬ B

Attributes

Inherited from:
CoreDSL
def elimSnd[A, B](f: B -⚬ One): A |*| B -⚬ A

Attributes

Inherited from:
CoreDSL
def elimSnd[A]: A |*| One -⚬ A

Attributes

Inherited from:
CoreDSL
override def eval[A, B]: A =⚬ B |*| A -⚬ B

Attributes

Definition Classes
Inherited from:
InvertDSL
def factorInversionOutOf_|&|[A, B]: -[A] |&| -[B] -⚬ -[A |+| B]

Attributes

Inherited from:
InvertDSL
def factorInversionOutOf_|+|[A, B]: -[A] |+| -[B] -⚬ -[A |&| B]

Attributes

Inherited from:
InvertDSL
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

Inherited from:
CoreDSL
def factorOutInversion[A, B]: -[A] |*| -[B] -⚬ -[A |*| B]
 ┏━━━━━━━━━━━┓
 ┞────┐      ┃
 ╎-[A]│      ┞────┐
 ┟────┘      ╎ ⎡A⎤│
 ┃           ╎-⎢⊗⎥│
 ┞────┐      ╎ ⎣B⎦│
 ╎-[B]│      ┟────┘
 ┟────┘      ┃
 ┗━━━━━━━━━━━┛

Attributes

Inherited from:
InvertDSL
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

Inherited from:
CoreDSL
def forevert[A]: One -⚬ -[A] |*| A
 ┏━━━━━━┓
 ┃      ┞────┐
 ┃   ┌┄┄╎-[A]│
 ┃   ┆  ┟────┘
 ┃   ┆  ┃
 ┃   ┆  ┞────┐
 ┃   └┄→╎  A │
 ┃      ┟────┘
 ┗━━━━━━┛

Attributes

Inherited from:
InvertDSL
def fork: Done -⚬ Done |*| Done

Attributes

Inherited from:
CoreDSL
def forkMap[A, B](f: Done -⚬ A, g: Done -⚬ B): Done -⚬ A |*| B

Attributes

Inherited from:
CoreDSL
def forkMapNeed[A, B](f: A -⚬ Need, g: B -⚬ Need): A |*| B -⚬ Need

Attributes

Inherited from:
CoreDSL
def forkNeed: Need |*| Need -⚬ Need

Attributes

Inherited from:
CoreDSL
def forkPing: Ping -⚬ Ping |*| Ping

Attributes

Inherited from:
CoreDSL
def forkPong: Pong |*| Pong -⚬ Pong

Attributes

Inherited from:
CoreDSL
def fst[A, B, C](f: A -⚬ B): A |*| C -⚬ B |*| C

Attributes

Inherited from:
CoreDSL
def id[A]: A -⚬ A

Attributes

Inherited from:
CoreDSL
def injectL[A, B]: A -⚬ A |+| B

Attributes

Inherited from:
CoreDSL
def injectLOnPing[A, B]: Ping |*| A -⚬ A |+| B

Attributes

Inherited from:
CoreDSL
def injectR[A, B]: B -⚬ A |+| B

Attributes

Inherited from:
CoreDSL
def injectROnPing[A, B]: Ping |*| B -⚬ A |+| B

Attributes

Inherited from:
CoreDSL
def introFst[A, X](f: One -⚬ X): A -⚬ X |*| A

Attributes

Inherited from:
CoreDSL
def introFst[B]: B -⚬ One |*| B

Attributes

Inherited from:
CoreDSL
def introSnd[A, X](f: One -⚬ X): A -⚬ A |*| X

Attributes

Inherited from:
CoreDSL
def introSnd[A]: A -⚬ A |*| One

Attributes

Inherited from:
CoreDSL
def invertClosure[A, B]: -[A =⚬ B] -⚬ B =⚬ A

Attributes

Inherited from:
InvertDSL
def invertedDoneAsNeed: -[Done] -⚬ Need

Attributes

Inherited from:
InvertDSL
def invertedNeedAsDone: -[Need] -⚬ Done

Attributes

Inherited from:
InvertDSL
def invertedPingAsPong: -[Ping] -⚬ Pong

Attributes

Inherited from:
InvertDSL
def invertedPongAsPing: -[Pong] -⚬ Ping

Attributes

Inherited from:
InvertDSL
def join: Done |*| Done -⚬ Done

Attributes

Inherited from:
CoreDSL
def joinMap[A, B](f: A -⚬ Done, g: B -⚬ Done): A |*| B -⚬ Done

Attributes

Inherited from:
CoreDSL
def joinMapNeed[A, B](f: Need -⚬ A, g: Need -⚬ B): Need -⚬ A |*| B

Attributes

Inherited from:
CoreDSL
def joinNeed: Need -⚬ Need |*| Need

Attributes

Inherited from:
CoreDSL
def joinPing: Ping |*| Ping -⚬ Ping

Attributes

Inherited from:
CoreDSL
def joinPong: Pong -⚬ Pong |*| Pong

Attributes

Inherited from:
CoreDSL
def lInvertPongPing: One -⚬ Pong |*| Ping

Attributes

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
def lInvertTerminus: One -⚬ LTerminus |*| RTerminus

Attributes

Inherited from:
CoreDSL
def need: Need -⚬ One

Attributes

Inherited from:
CoreDSL
def needAsInvertedDone: Need -⚬ -[Done]

Attributes

Inherited from:
InvertDSL
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

Inherited from:
CoreDSL
def notifyDoneL: Done -⚬ Ping |*| Done

Attributes

Inherited from:
CoreDSL
def notifyDoneR: Done -⚬ Done |*| Ping

Attributes

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
def notifyNeedL: Pong |*| Need -⚬ Need

Attributes

Inherited from:
CoreDSL
def notifyNeedR: Need |*| Pong -⚬ Need

Attributes

Inherited from:
CoreDSL
def obj[A, B](f: A -⚬ B): One -⚬ A =⚬ B

Turn a function into a function object.

Turn a function into a function object.

Attributes

Inherited from:
ClosedDSL
override def out[A, B, C](f: B -⚬ C): A =⚬ B -⚬ A =⚬ C

Map the output of a function object.

Map the output of a function object.

Attributes

Definition Classes
Inherited from:
InvertDSL
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

Inherited from:
CoreDSL
def packDemand[F[_]]: -[F[Rec[F]]] -⚬ -[Rec[F]]

Attributes

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

Attributes

Inherited from:
CoreDSL
def ping: One -⚬ Ping

Attributes

Inherited from:
CoreDSL
def pingAsInvertedPong: Ping -⚬ -[Pong]

Attributes

Inherited from:
InvertDSL
def pong: Pong -⚬ One

Attributes

Inherited from:
CoreDSL
def pongAsInvertedPing: Pong -⚬ -[Ping]

Attributes

Inherited from:
InvertDSL
def rInvertPingPong: Ping |*| Pong -⚬ One

Attributes

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
def rInvertTerminus: RTerminus |*| LTerminus -⚬ One

Attributes

Inherited from:
CoreDSL
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

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

Attributes

Inherited from:
CoreDSL
def regressInfinitely: LTerminus -⚬ Need

Attributes

Inherited from:
CoreDSL
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

Inherited from:
CoreDSL
def snd[A, B, C](f: B -⚬ C): A |*| B -⚬ A |*| C

Attributes

Inherited from:
CoreDSL
def strengthenPing: Ping -⚬ Done

Attributes

Inherited from:
CoreDSL
def strengthenPong: Need -⚬ Pong

Attributes

Inherited from:
CoreDSL
def supply[A]: A |*| -[A] -⚬ One

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

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

Attributes

Inherited from:
InvertDSL
def swap[A, B]: A |*| B -⚬ B |*| A

Attributes

Inherited from:
CoreDSL
def toChoiceOfDemands[A, B]: -[A |+| B] -⚬ -[A] |&| -[B]

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

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

Attributes

Inherited from:
InvertDSL
def unContrapositive[A, B](f: -[A] -⚬ -[B]): B -⚬ A

Attributes

Inherited from:
InvertDSL
def unInvertClosure[A, B]: A =⚬ B -⚬ -[B =⚬ A]

Attributes

Inherited from:
InvertDSL
def uncurry[A, B, C](f: A -⚬ B =⚬ C): A |*| B -⚬ C

Attributes

Inherited from:
ClosedDSL
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

Inherited from:
CoreDSL
def unpackDemand[F[_]]: -[Rec[F]] -⚬ -[F[Rec[F]]]

Attributes

Inherited from:
InvertDSL
def Λ[A, B](using SourcePos)(f: $[A] => $[B]): $[A =⚬ B]

Alias for λ.closure.apply.

Alias for λ.closure.apply.

Attributes

Inherited from:
ClosedDSL

Inherited fields

override val $: FunExprOps

Attributes

Inherited from:
ClosedDSL
override val λ: LambdaOpsWithClosures

Attributes

Inherited from:
ClosedDSL

Implicits

Inherited implicits

final implicit def DemandExprOps[B](expr: $[-[B]]): DemandExprOps[B]

Attributes

Inherited from:
InvertDSL
Generated with
© 2002-2021 · LAMP/EPFL
© 2002-2021 · LAMP/EPFL