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

Tupled

libretto.lambda.Tupled$package.Tupled
object Tupled

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
Self type
Tupled.type

Members list

Type members

Classlikes

object <*>

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
<*>.type
object Atom

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Atom.type

Value members

Concrete methods

def atom[|*|[_, _], F[_], A](v: F[A]): Tupled[|*|, F, A]
def fromBin[|*|[_, _], F[_], A](value: Bin[|*|, [x] =>> x, F, A]): Tupled[|*|, F, A]
def unzip[|*|[_, _], F[_], A, B](ab: Tupled[|*|, F, |*|[A, B]])(using F: Unzippable[|*|, F]): (Tupled[|*|, F, A], Tupled[|*|, F, B])
def zip[|*|[_, _], F[_], X, Y](_1: Tupled[|*|, F, X], _2: Tupled[|*|, F, Y]): Tupled[|*|, F, X |*| Y]

Givens

Givens

given `given_Zippable_|*|_Tupled`[|*|[_, _], F[_]]: |*| `given_Zippable_|*|_Tupled` F

Extensions

Extensions

extension [|*|[_, _], F[_], A](a: Tupled[|*|, F, A])
def asBin: Bin[|*|, [x] =>> x, F, A]
def deduplicateLeafs[->[_, _]](dup: [x] => (x$1: F[x]) => ->[x, |*|[x, x]])(using F: UniqueTypeArg[F], shuffled: Shuffled[->, |*|]): Exists[[X] =>> (Tupled[|*|, F, X], shuffled.Shuffled[X, A])]
def fold(using F: Zippable[|*|, F]): F[A]
def foldMap[G[_]](map: [x] => (x$1: F[x]) => G[x])(using G: Zippable[|*|, G]): G[A]
def foldMap0[B](map: [x] => (x$1: F[x]) => B, reduce: (B, B) => B): B
def foldMapWith[G[_]](map: [x] => (x$1: F[x]) => G[x], zip: [x, y] => (x$1: G[x], x$2: G[y]) => G[|*|[x, y]]): G[A]
def foldWith(zip: [x, y] => (x$1: F[x], x$2: F[y]) => F[|*|[x, y]]): F[A]
def product[B, ->[_, _]](b: Tupled[|*|, F, B])(discardFst: [X, Y] => (x$1: F[X]) => ->[|*|[X, Y], Y])(using F: UniqueTypeArg[F], shuffled: Shuffled[->, |*|]): Exists[[P] =>> (Tupled[|*|, F, P], shuffled.Shuffled[P, A], shuffled.Shuffled[P, B])]
def trans[G[_]](f: [x] => (x$1: F[x]) => G[x]): Tupled[|*|, G, A]
def zip[B](b: Tupled[|*|, F, B]): Tupled[|*|, F, A |*| B]
Generated with