libretto/libretto/CoreLib/LinearFunctionOps

LinearFunctionOps

class LinearFunctionOps[A, B](self: A -⚬ B)
class Object
trait Matchable
class Any

Value members

Methods

def <: FocusedContra[[x] =>> x -⚬ B, A]

Focuses on function's input.

def >: FocusedCo[[x] =>> A -⚬ x, B]

Focuses on function's output.

def as[C](ev: A -⚬ B =:= C): C

No-op used for documentation purposes: explicitly states the full type of this linear function.

def bimap[F[_, _]]: BimapSyntax[F, A, B]
def choice[C, D](f: B -⚬ C, g: B -⚬ D): A -⚬ C |&| D
def chooseL[B1, B2](ev: B =:= B1 |&| B2): A -⚬ B1
def chooseR[B1, B2](ev: B =:= B1 |&| B2): A -⚬ B2
def coDistributeL[B1, B2, B3](ev: B =:= B1 |*| B2 |&| B1 |*| B3): A -⚬ B1 |*| B2 |&| B3
def coDistributeR[B1, B2, B3](ev: B =:= B1 |*| B3 |&| B2 |*| B3): A -⚬ B1 |&| B2 |*| B3
def coFactorL[B1, B2, B3](ev: B =:= B1 |*| B2 |&| B3): A -⚬ B1 |*| B2 |&| B1 |*| B3
def coFactorR[B1, B2, B3](ev: B =:= B1 |&| B2 |*| B3): A -⚬ B1 |*| B3 |&| B2 |*| B3
def distributeL[B1, B2, B3](ev: B =:= B1 |*| B2 |+| B3): A -⚬ B1 |*| B2 |+| B1 |*| B3
def distributeR[B1, B2, B3](ev: B =:= B1 |+| B2 |*| B3): A -⚬ B1 |*| B3 |+| B2 |*| B3
def either[B1, B2, C](f: B1 -⚬ C, g: B2 -⚬ C)(ev: B =:= B1 |+| B2): A -⚬ C
def elimFst[B2](ev: B =:= One |*| B2): A -⚬ B2
def elimFst[B1, B2](f: B1 -⚬ One)(ev: B =:= B1 |*| B2): A -⚬ B2
def elimSnd[B1](ev: B =:= B1 |*| One): A -⚬ B1
def elimSnd[B1, B2](f: B2 -⚬ One)(ev: B =:= B1 |*| B2): A -⚬ B1
def factorL[C, D1, D2](ev: B =:= C |*| D1 |+| C |*| D2): A -⚬ C |*| D1 |+| D2
def factorR[C1, C2, D](ev: B =:= C1 |*| D |+| C2 |*| D): A -⚬ C1 |+| C2 |*| D
def from[Z](ev: A =:= Z): Z -⚬ B

No-op used for documentation purposes: explicitly states the input type of this linear function.

def injectL[C]: A -⚬ B |+| C
def injectR[C]: A -⚬ C |+| B
def introFst: A -⚬ One |*| B
def introFst[C](f: One -⚬ C): A -⚬ C |*| B
def introSnd: A -⚬ B |*| One
def introSnd[C](f: One -⚬ C): A -⚬ B |*| C
def pack[F[_]](ev: B =:= F[Rec[F]]): A -⚬ Rec[F]
def par[B1, B2, C, D](f: B1 -⚬ C, g: B2 -⚬ D)(ev: B =:= B1 |*| B2): A -⚬ C |*| D
def race[B1, B2, C](caseFstWins: B1 |*| B2 -⚬ C, caseSndWins: B1 |*| B2 -⚬ C)(`evidence$11`: Positive[B1], `evidence$12`: Positive[B2], ev: B =:= B1 |*| B2): A -⚬ C
def select[C1, C2](caseFstWins: B -⚬ C1 |*| C2, caseSndWins: B -⚬ C1 |*| C2)(`evidence$13`: Negative[C1], `evidence$14`: Negative[C2]): A -⚬ C1 |*| C2
def swap[B1, B2](ev: B =:= B1 |*| B2): A -⚬ B2 |*| B1
def to[C](ev: B =:= C): A -⚬ C

No-op used for documentation purposes: explicitly states the output type of this linear function.

def unpack[F[_]](ev: B =:= Rec[F]): A -⚬ F[Rec[F]]
def ∘[Z](g: Z -⚬ A): Z -⚬ B