libretto-lambda
API
Generated with
libretto-lambda/libretto.lambda/ParN

ParN

libretto.lambda.ParN
See theParN companion object
sealed trait ParN[∙[_, _], Nil, ->[_, _], A, B]

An n-ary tuple of arrows Ai -> Bi, such that A = Nil ∙ A1 ∙ ... ∙ An, B = Nil ∙ B1 ∙ ... ∙ Bn, where ∙ associates to the left.

An arrowized version of Items1.Product.

Attributes

Companion
object
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Single[∙, Nil, ->, A, B]
class Snoc[∙, Nil, ->, A1, A2, B1, B2]

Members list

Type members

Types

type ZippedWithIndex[X, Y] = (X -> Y, Member[∙, Nil, X, A], Member[∙, Nil, Y, B])

Value members

Abstract methods

def divide[F[_, _], G[_, _]](h: [X, Y] => (X -> Y) => Exists[[Q] =>> (F[X, Q], G[Q, Y])]): Exists[[Q] =>> (ParN[∙, Nil, F, A, Q], ParN[∙, Nil, G, Q, B])]
def flip: ParN[∙, Nil, [x, y] =>> y -> x, B, A]
def foldCrush[T](crush: [X, Y] => (X -> Y) => T, reduce: (T, T) => T): T
def foldL[G[_, _]](first: [x, y] => (x -> y) => G[Nil ∙ x, Nil ∙ y], snoc: [x1, x2, y1, y2] => (x$1: G[x1, y1], x$2: x2 -> y2) => G[x1 ∙ x2, y1 ∙ y2]): G[A, B]
def inputProjection[F[_]](f: [X, Y] => (X -> Y) => F[X]): Product[∙, Nil, F, A]
def nonEmpty[R](f: [a1, a2, b1, b2] => (x$1: A =:= (a1 ∙ a2), x$2: B =:= (b1 ∙ b2)) ?=> R): R
def nonEmptyIn(pairIsNotNil: [x, y] => ((x ∙ y) =:= Nil) => Nothing): (A =:= Nil) => Nothing
def nonEmptyOut(pairIsNotNil: [x, y] => ((x ∙ y) =:= Nil) => Nothing): (B =:= Nil) => Nothing
def outputProjection[G[_]](g: [X, Y] => (X -> Y) => G[Y]): Product[∙, Nil, G, B]
def size: Int
def translate[->>[_, _]](f: [X, Y] => (X -> Y) => ->>[X, Y]): ParN[∙, Nil, ->>, A, B]
def zipWithIndex: ParN[∙, Nil, ZippedWithIndex, A, B]

Concrete methods

def divide3[F[_, _], G[_, _], H[_, _]](h: [X, Y] => (X -> Y) => Exists[[P] =>> Exists[[Q] =>> (F[X, P], G[P, Q], H[Q, Y])]]): Exists[[P] =>> Exists[[Q] =>> (ParN[∙, Nil, F, A, P], ParN[∙, Nil, G, P, Q], ParN[∙, Nil, H, Q, B])]]
def exists(pred: [X, Y] => (X -> Y) => Boolean): Boolean
def toList[T](f: [X, Y] => (X -> Y) => T): List[T]
def ∙[C, D](f: C -> D): ParN[∙, Nil, ->, A ∙ C, B ∙ D]
Generated with