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

ShuffledModule

libretto.lambda.ShuffledModule
See theShuffledModule companion object
trait ShuffledModule[->[_, _], **[_, _]]

Attributes

Companion
object
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Shuffled[->, |*|]
Self type
ShuffledModule[->, **]

Members list

Type members

Classlikes

object ChaseBwRes

Attributes

Companion
trait
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
ChaseBwRes.type
sealed trait ChaseBwRes[A, G[_], X]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Blocked[A, G, X]
class OriginatesFrom[A, F, V, W, X, G]
class Split[A, G, X, X1, X2]
class Transported[A, F, G, X]
object ChaseFwRes

Attributes

Companion
trait
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
ChaseFwRes.type
sealed trait ChaseFwRes[F[_], X, B]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Blocked[F, X, B]
class FedTo[F, X, V, W, G, B]
class Split[F, X, X1, X2, B]
class Transported[F, X, G, B]
enum ProjectRes[A, C]

Attributes

Companion
object
Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
Known subtypes
class Projected[A0, A, C]
object ProjectRes

Attributes

Companion
enum
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
ProjectRes.type
trait PunchedCompanion

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Punched
object given_SymmetricSemigroupalCategory_Shuffled_** extends SymmetricSemigroupalCategory[Shuffled, **]

Attributes

Supertypes
class Object
trait Matchable
class Any
Show all
Self type

Types

type Punched[F[_], G[_]]

A Shuffled with a hole through it.

A Shuffled with a hole through it.

Attributes

type Shuffled[A, B]

Value members

Abstract methods

def andThen[A, B, C](f: Shuffled[A, B], g: Shuffled[B, C]): Shuffled[A, C]
def assocLR[A, B, C]: Shuffled[A ** B ** C, A ** (B ** C)]
def assocRL[A, B, C]: Shuffled[A ** (B ** C), A ** B ** C]
def fst[A, B, C](f: Shuffled[A, B]): Shuffled[A ** C, B ** C]
def id[A]: Shuffled[A, A]
def ix[A, B, C]: Shuffled[A ** B ** C, A ** C ** B]
def ixi[A, B, C, D]: Shuffled[A ** B ** (C ** D), A ** C ** (B ** D)]
def lift[X, Y](f: X -> Y): Shuffled[X, Y]
def par[A1, A2, B1, B2](f1: Shuffled[A1, B1], f2: Shuffled[A2, B2]): Shuffled[A1 ** A2, B1 ** B2]
def pure[A, B](f: A shuffle.~⚬ B): Shuffled[A, B]
def snd[A, B, C](f: Shuffled[B, C]): Shuffled[A ** B, A ** C]
def swap[A, B]: Shuffled[A ** B, B ** A]
def xi[A, B, C]: Shuffled[A ** (B ** C), B ** (A ** C)]

Abstract fields

val shuffle: Shuffle[**]

Givens

Givens

Extensions

Extensions

extension [A, B](f: Shuffled[A, B])
def chaseBw[G[_], X](i: Focus[**, G])(using B =:= G[X]): ChaseBwRes[A, G, X]
def chaseFw[F[_], X](i: Focus[**, F])(using A =:= F[X]): ChaseFwRes[F, X, B]
def fold(using SymmetricSemigroupalCategory[->, **]): A -> B
def foldMap[->>[_, _]](h: [x, y] => (x -> y) => ->>[x, y])(using SymmetricSemigroupalCategory[->>, **]): A ->> B
def foldMapA[G[_], ->>[_, _]](h: [t, u] => (t -> u) => G[->>[t, u]])(using G: Applicative[G], cat: SymmetricSemigroupalCategory[->>, **]): G[A ->> B]
def project[C](p: Projection[**, B, C], h: [X, Y, Z] => (x$1: X -> Y, x$2: Projection[**, Y, Z]) => ProjectRes[X, Z]): ProjectRes[A, C]
def takeLeadingForestAt[F[_], X](pos: Focus[**, F])(using ev: A =:= F[X]): Exists[[Y] =>> (AForest[->, **, X, Y], Shuffled[F[Y], B])]

Extracts the maximum forest-shaped prefix at the given position.

Extracts the maximum forest-shaped prefix at the given position.

Attributes

def takeLeadingForestAtWhile[F[_], X, ->>[_, _]](pos: Focus[**, F], pred: [x, y] => (x -> y) => Option[->>[x, y]])(using ev: A =:= F[X]): Exists[[Y] =>> (AForest[->>, **, X, Y], Shuffled[F[Y], B])]

Extracts the maximum forest-shaped prefix at the given position satisfying the given predicate.

Extracts the maximum forest-shaped prefix at the given position satisfying the given predicate.

Attributes

extension [F[_], G[_]](p: Punched[F, G])
def >[H[_]](that: Punched[G, H]): Punched[F, H]
def after[H[_]](H: Focus[**, H], h: [x] => DummyImplicit ?=> Shuffled[H[x], F[x]]): Punched[H, G]
def andThen[H[_]](H: Focus[**, H], h: [x] => DummyImplicit ?=> Shuffled[G[x], H[x]]): Punched[F, H]
def focusIn: Focus[**, F]
def focusOut: Focus[**, G]
def inFst[P, Q](g: Shuffled[P, Q]): Punched[[x] =>> F[x] ** P, [x] =>> G[x] ** Q]
def inFst[P]: Punched[[x] =>> F[x] ** P, [x] =>> G[x] ** P]
def inSnd[P, Q](f: Shuffled[P, Q]): Punched[[x] =>> P ** F[x], [x] =>> Q ** G[x]]
def inSnd[P]: Punched[[x] =>> P ** F[x], [x] =>> P ** G[x]]
def knitBw(k: Knit[**, G]): Exists[[F0] =>> (Knitted[**, F, F0], Shuffled[F0, k.Res])]
def plug[X]: Shuffled[F[X], G[X]]
Generated with