libretto/libretto/ClosedLib

ClosedLib

class ClosedLib[DSL <: ClosedDSL, CLib <: CoreLib[DSL]](val dsl: DSL, val coreLib: CLib & CoreLib[DSL])
Companion
object
class Object
trait Matchable
class Any
ClosedLib[DSL, CLib]

Type members

Classlikes

implicit
class ClosedLinearFunctionOps[A, B](self: A -⚬ B)
implicit
class FocusedOnFunctionCo[F[_], A, B](f: FocusedCo[F, A =⚬ B])
implicit
class FocusedOnFunctionContra[F[_], A, B](f: FocusedContra[F, A =⚬ B])

Value members

Concrete methods

def absorbR[A, B, C]: A =⚬ B |*| C -⚬ A =⚬ B |*| C

Make a function A =⚬ B ''"absorb"'' a C and return it as part of its output, i.e. A =⚬ (B |*| C).

Make a function A =⚬ B ''"absorb"'' a C and return it as part of its output, i.e. A =⚬ (B |*| C).

def input[C]: ContraFunctor[=⚬]

Function object (internal hom) is contravariant in the input type.

Function object (internal hom) is contravariant in the input type.

def output[A]: Functor[[x] =>> A =⚬ x]

Function object (internal hom) is covariant in the output type.

Function object (internal hom) is covariant in the output type.

def unveilSequentially[A, Ā, B](implicit ev: Dual[A, Ā]): A |*| B -⚬ Ā =⚬ B

Given A and B concurrently (A |*| B), we can suggest that A be consumed before B by turning it into Ā =⚬ B, where Ā is the dual of A.

Given A and B concurrently (A |*| B), we can suggest that A be consumed before B by turning it into Ā =⚬ B, where Ā is the dual of A.

def zapPremises[A, Ā, B, C](implicit ev: Dual[A, Ā]): A =⚬ B |*| Ā =⚬ C -⚬ B |*| C

Concrete fields

val coreLib: CLib & CoreLib[DSL]
val dsl: DSL

Implicits

Implicits

final implicit
def ClosedLinearFunctionOps[A, B](self: A -⚬ B): ClosedLinearFunctionOps[A, B]
final implicit
def FocusedOnFunctionCo[F[_], A, B](f: FocusedCo[F, A =⚬ B]): FocusedOnFunctionCo[F, A, B]
final implicit
def FocusedOnFunctionContra[F[_], A, B](f: FocusedContra[F, A =⚬ B]): FocusedOnFunctionContra[F, A, B]