ClosedLib

libretto.ClosedLib
See theClosedLib companion object
class ClosedLib[DSL <: ClosedDSL, CLib <: CoreLib[DSL]](val dsl: DSL, val coreLib: CLib & CoreLib[DSL])

Attributes

Companion:
object
Graph
Supertypes
class Object
trait Matchable
class Any
Self type
ClosedLib[DSL, CLib]

Members list

Concise view

Type members

Classlikes

implicit class ClosedLinearFunctionOps[A, B](self: A -⚬ B)

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
implicit class FocusedOnFunctionCo[F[_], A, B](f: FocusedCo[F, A =⚬ B])

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
implicit class FocusedOnFunctionContra[F[_], A, B](f: FocusedContra[F, A =⚬ B])

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any

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

Attributes

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

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

Attributes

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.

Attributes

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.

Attributes

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]