Uses of Class
com.jnape.palatable.lambda.adt.hlist.Tuple2

Packages that use Tuple2

Package	Description
com.jnape.palatable.lambda.adt
com.jnape.palatable.lambda.adt.choice
com.jnape.palatable.lambda.adt.hlist
com.jnape.palatable.lambda.adt.hmap
com.jnape.palatable.lambda.functions
com.jnape.palatable.lambda.functions.builtin.fn1
com.jnape.palatable.lambda.functions.builtin.fn2
com.jnape.palatable.lambda.functor
com.jnape.palatable.lambda.functor.builtin
com.jnape.palatable.lambda.internal.iteration
com.jnape.palatable.lambda.monad
com.jnape.palatable.lambda.monad.transformer.builtin
com.jnape.palatable.lambda.monoid.builtin
com.jnape.palatable.lambda.optics
com.jnape.palatable.lambda.semigroup.builtin

Uses of Tuple2 in com.jnape.palatable.lambda.adt

Classes in com.jnape.palatable.lambda.adt that implement interfaces with type arguments of type Tuple2

Modifier and Type	Class	Description
class	These<A,B>	The coproduct of a coproduct (CoProduct2<A, B>) and its product (Tuple2<A, B>), represented as a CoProduct3<A, B, Tuple2<A, B>>.

Fields in com.jnape.palatable.lambda.adt declared as Tuple2

Modifier and Type	Field	Description
private final Tuple2<A,B>	These.Both.both

Methods in com.jnape.palatable.lambda.adt that return Tuple2

Modifier and Type	Method	Description
Tuple2<Maybe<Unit>, Maybe<A>>	Maybe.project()	Project this coproduct onto a product, such that the index in the product that corresponds to this coproduct's value is present, while the other indices are absent.

Constructors in com.jnape.palatable.lambda.adt with parameters of type Tuple2

Modifier	Constructor	Description
private	Both(Tuple2<A,B> tuple)

Uses of Tuple2 in com.jnape.palatable.lambda.adt.choice

Methods in com.jnape.palatable.lambda.adt.choice that return Tuple2

Modifier and Type	Method	Description
Tuple2<Maybe<A>,Maybe<B>>	Choice2.project()	Specialize this choice's projection to a Tuple2.

Uses of Tuple2 in com.jnape.palatable.lambda.adt.hlist

Subclasses with type arguments of type Tuple2 in com.jnape.palatable.lambda.adt.hlist

Modifier and Type	Class	Description
class	Tuple3<_1,_2,_3>	A 3-element tuple product type, implemented as a specialized HList.

Classes in com.jnape.palatable.lambda.adt.hlist that implement interfaces with type arguments of type Tuple2

Modifier and Type	Class	Description
class	Tuple2<_1,_2>	A 2-element tuple product type, implemented as a specialized HList.
class	Tuple2<_1,_2>	A 2-element tuple product type, implemented as a specialized HList.
class	Tuple2<_1,_2>	A 2-element tuple product type, implemented as a specialized HList.
class	Tuple2<_1,_2>	A 2-element tuple product type, implemented as a specialized HList.

Methods in com.jnape.palatable.lambda.adt.hlist with type parameters of type Tuple2

Modifier and Type	Method	Description
<_2Prime, App extends Applicative<?,App>, TravB extends Traversable<_2Prime, Tuple2<_1,?>>, AppTrav extends Applicative<TravB,App>> AppTrav	Tuple2.traverse(Fn1<? super _2, ? extends Applicative<_2Prime,App>> fn, Fn1<? super TravB, ? extends AppTrav> pure)	Apply fn to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.

Methods in com.jnape.palatable.lambda.adt.hlist that return Tuple2

Modifier and Type	Method	Description
<_1Prime,_2Prime> Tuple2<_1Prime,_2Prime>	Tuple2.biMap(Fn1<? super _1, ? extends _1Prime> lFn, Fn1<? super _2, ? extends _2Prime> rFn)	Dually map covariantly over both the left and right parameters.
<_1Prime> Tuple2<_1Prime,_2>	Tuple2.biMapL(Fn1<? super _1, ? extends _1Prime> fn)	Covariantly map over the left parameter.
<_2Prime> Tuple2<_1,_2Prime>	Tuple2.biMapR(Fn1<? super _2, ? extends _2Prime> fn)	Covariantly map over the right parameter.
Tuple2<_1,_2>	Tuple2.censor(Fn1<? super _1, ? extends _1> fn)	Update the accumulated state.
<_0> Tuple2<_0,_1>	SingletonHList.cons(_0 _0)	Cons an element onto the front of this HList.
<_2Prime> Tuple2<_1,_2Prime>	Tuple2.discardL(Applicative<_2Prime, Tuple2<_1,?>> appB)	Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
<_2Prime> Tuple2<_1,_2>	Tuple2.discardR(Applicative<_2Prime, Tuple2<_1,?>> appB)	Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
static <A> Tuple2<A,A>	Tuple2.fill(A a)	Given a value of type A, produce an instance of this tuple with each slot set to that value.
<_2Prime> Tuple2<_1,_2Prime>	Tuple2.flatMap(Fn1<? super _2, ? extends Monad<_2Prime, Tuple2<_1,?>>> f)	Chain dependent computations that may continue or short-circuit based on previous results.
<_2Prime> Tuple2<_1,_2Prime>	Tuple2.fmap(Fn1<? super _2, ? extends _2Prime> fn)	Covariantly transmute this functor's parameter using the given mapping function.
static <K,V> Tuple2<K,V>	Tuple2.fromEntry(Map.Entry<K,V> entry)	Static factory method for creating Tuple2s from Map.Entrys.
Tuple2<_1,_2>	Tuple3.init()	Returns a Tuple2<_1, _2> of all the elements of this Tuple3<_1, _2, _3> except the last.
Tuple2<_2,_1>	Tuple2.invert()	Rotate the first two slots of this product.
<_3> Tuple2<_1, Tuple2<_2,_3>>	Tuple2.listens(Fn1<? super _1, ? extends _3> fn)	Map the accumulation into a value and pair it with the current output.
<_2Prime> Tuple2<_1,_2Prime>	Tuple2.pure(_2Prime _2Prime)	Lift the value b into this applicative functor.
<_2> Tuple2<_1,_2>	SingletonHList.snoc(_2 _2)	Snoc an element onto the back of this SingletonHList.
<_2Prime> Tuple2<_1,_2Prime>	Tuple2.trampolineM(Fn1<? super _2, ? extends MonadRec<RecursiveResult<_2,_2Prime>, Tuple2<_1,?>>> fn)	Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.
static <_1,_2> Tuple2<_1,_2>	HList.tuple(_1 _1, _2 _2)	Static factory method for creating a 2-element HList.
<_2Prime> Tuple2<_1,_2Prime>	Tuple2.zip(Applicative<Fn1<? super _2, ? extends _2Prime>, Tuple2<_1,?>> appFn)	Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.

Methods in com.jnape.palatable.lambda.adt.hlist that return types with arguments of type Tuple2

Modifier and Type	Method	Description
static <A> Maybe<Tuple2<A,A>>	Tuple2.fromIterable(Iterable<A> as)	Return just the first two elements from the given Iterable, or nothing if there are less than two elements.
<_2Prime> Lazy<Tuple2<_1,_2Prime>>	Tuple2.lazyZip(Lazy<? extends Applicative<Fn1<? super _2, ? extends _2Prime>, Tuple2<_1,?>>> lazyAppFn)	Given a lazy instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
<_3> Tuple2<_1, Tuple2<_2,_3>>	Tuple2.listens(Fn1<? super _1, ? extends _3> fn)	Map the accumulation into a value and pair it with the current output.
static <_1> Pure<Tuple2<_1,?>>	Tuple2.pureTuple(_1 _1)	The canonical Pure instance for Tuple2.

Method parameters in com.jnape.palatable.lambda.adt.hlist with type arguments of type Tuple2

Modifier and Type	Method	Description
<_2Prime> Tuple2<_1,_2Prime>	Tuple2.discardL(Applicative<_2Prime, Tuple2<_1,?>> appB)	Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
<_2Prime> Tuple2<_1,_2>	Tuple2.discardR(Applicative<_2Prime, Tuple2<_1,?>> appB)	Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
<_2Prime> Tuple2<_1,_2Prime>	Tuple2.flatMap(Fn1<? super _2, ? extends Monad<_2Prime, Tuple2<_1,?>>> f)	Chain dependent computations that may continue or short-circuit based on previous results.
<_2Prime> Lazy<Tuple2<_1,_2Prime>>	Tuple2.lazyZip(Lazy<? extends Applicative<Fn1<? super _2, ? extends _2Prime>, Tuple2<_1,?>>> lazyAppFn)	Given a lazy instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
<_2Prime> Tuple2<_1,_2Prime>	Tuple2.trampolineM(Fn1<? super _2, ? extends MonadRec<RecursiveResult<_2,_2Prime>, Tuple2<_1,?>>> fn)	Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.
<_2Prime> Tuple2<_1,_2Prime>	Tuple2.zip(Applicative<Fn1<? super _2, ? extends _2Prime>, Tuple2<_1,?>> appFn)	Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.

Constructors in com.jnape.palatable.lambda.adt.hlist with parameters of type Tuple2

Modifier	Constructor	Description
(package private)	Tuple3(_1 _1, Tuple2<_2,_3> tail)

Uses of Tuple2 in com.jnape.palatable.lambda.adt.hmap

Classes in com.jnape.palatable.lambda.adt.hmap that implement interfaces with type arguments of type Tuple2

Modifier and Type	Class	Description
final class	HMap	An immutable heterogeneous mapping from a parametrized type-safe key to any value, supporting a minimal mapping interface.

Methods in com.jnape.palatable.lambda.adt.hmap that return types with arguments of type Tuple2

Modifier and Type	Method	Description
Iterator<Tuple2<TypeSafeKey<?,?>, Object>>	HMap.iterator()
static <A,B> Schema<Tuple2<A,B>>	Schema.schema(TypeSafeKey<?,A> aKey, TypeSafeKey<?,B> bKey)	Create a Schema from two TypeSafeKeys.

Uses of Tuple2 in com.jnape.palatable.lambda.functions

Methods in com.jnape.palatable.lambda.functions that return types with arguments of type Tuple2

Modifier and Type	Method	Description
default Fn1<A, Tuple2<A,B>>	Fn1.carry()	Pair the covariantly-positioned carrier type with the contravariantly-positioned carrier type.
default <C> Fn1<Tuple2<C,A>, Tuple2<C,B>>	Fn1.cartesian()	Pair a value with the input to this function, and preserve the paired value through to the output.
default <C> Fn1<Tuple2<C,A>, Tuple2<C,B>>	Fn1.cartesian()	Pair a value with the input to this function, and preserve the paired value through to the output.
default <C> Fn1<A, Tuple2<B,C>>	Fn1.listens(Fn1<? super A, ? extends C> fn)	Map the accumulation into a value and pair it with the current output.

Method parameters in com.jnape.palatable.lambda.functions with type arguments of type Tuple2

Modifier and Type	Method	Description
static <A,B,C> Fn2<A,B,C>	Fn2.curry(Fn1<? super Tuple2<A,B>, ? extends C> uncurriedFn1)	Static factory method for wrapping an uncurried Fn1 in an Fn2.

Uses of Tuple2 in com.jnape.palatable.lambda.functions.builtin.fn1

Classes in com.jnape.palatable.lambda.functions.builtin.fn1 that implement interfaces with type arguments of type Tuple2

Modifier and Type	Class	Description
final class	Uncons<A>	Destructure an Iterable into a Tuple2 of its head and tail, wrapped in an Maybe.

Methods in com.jnape.palatable.lambda.functions.builtin.fn1 that return types with arguments of type Tuple2

Modifier and Type	Method	Description
Maybe<Tuple2<A, Iterable<A>>>	Uncons.checkedApply(Iterable<A> as)
static <A> Maybe<Tuple2<A, Iterable<A>>>	Uncons.uncons(Iterable<A> as)

Uses of Tuple2 in com.jnape.palatable.lambda.functions.builtin.fn2

Classes in com.jnape.palatable.lambda.functions.builtin.fn2 that implement interfaces with type arguments of type Tuple2

Modifier and Type	Class	Description
final class	Both<A,B,C>	Given two functions f and g, produce a Fn1<A, Tuple2<B, C>> (the dual application of both functions).
final class	CartesianProduct<A,B>	Lazily compute the cartesian product of an Iterable<A> and Iterable<B>, returning an Iterable<Tuple2<A, B>>, the products as tuples of multiplicand As and multiplier Bs.
final class	Partition<A,B,C>	Given an Iterable<A> as and a disjoint mapping function a -> CoProduct2<A, B>, return a Tuple2 over the lazily unwrapped left A and right B values in the first and second slots, respectively.
final class	Span<A>	Given a predicate, return a Tuple2 where the first slot is the front contiguous elements of an Iterable matching the predicate and the second slot is all the remaining elements.
final class	Tupler2<A,B>	Creates a Tuple2 from two values.
final class	Unfoldr<A,B>	Given an initial seed value and a function that takes the seed type and produces an Maybe<Tuple2<X, Seed>>, where the tuple's first slot represents the next Iterable element, and the second slot represents the next input to the unfolding function, unfold an Iterable of Xs.
final class	Zip<A,B>	Zip together two Iterables into a single Iterable of Tuple2<A, B>.

Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return Tuple2

Modifier and Type	Method	Description
static <A,B,C> Tuple2<B,C>	Both.both(Fn1<? super A, ? extends B> f, Fn1<? super A, ? extends C> g, A a)
Tuple2<B,C>	Both.checkedApply(Fn1<? super A, ? extends B> f, Fn1<? super A, ? extends C> g, A a)
Tuple2<Iterable<B>, Iterable<C>>	Partition.checkedApply(Fn1<? super A, ? extends CoProduct2<B,C,?>> function, Iterable<A> as)
Tuple2<Iterable<A>, Iterable<A>>	Span.checkedApply(Fn1<? super A, ? extends Boolean> predicate, Iterable<A> as)
Tuple2<A,B>	Tupler2.checkedApply(A a, B b)
static <A,B,C> Tuple2<Iterable<B>, Iterable<C>>	Partition.partition(Fn1<? super A, ? extends CoProduct2<B,C,?>> function, Iterable<A> as)
static <A> Tuple2<Iterable<A>, Iterable<A>>	Span.span(Fn1<? super A, ? extends Boolean> predicate, Iterable<A> as)
static <A,B> Tuple2<A,B>	Tupler2.tupler(A a, B b)

Methods in com.jnape.palatable.lambda.functions.builtin.fn2 that return types with arguments of type Tuple2

Modifier and Type	Method	Description
static <A,B,C> Fn1<Fn1<? super A, ? extends C>, Fn1<A, Tuple2<B,C>>>	Both.both(Fn1<? super A, ? extends B> f)
static <A,B,C> Fn1<A, Tuple2<B,C>>	Both.both(Fn1<? super A, ? extends B> f, Fn1<? super A, ? extends C> g)
static <A,B> Fn1<Iterable<B>, Iterable<Tuple2<A,B>>>	CartesianProduct.cartesianProduct(Iterable<A> as)
static <A,B> Iterable<Tuple2<A,B>>	CartesianProduct.cartesianProduct(Iterable<A> as, Iterable<B> bs)
Iterable<Tuple2<A,B>>	CartesianProduct.checkedApply(Iterable<A> as, Iterable<B> bs)
Iterable<Tuple2<A,B>>	Zip.checkedApply(Iterable<A> as, Iterable<B> bs)
static <A,B,C> Fn1<Iterable<A>, Tuple2<Iterable<B>, Iterable<C>>>	Partition.partition(Fn1<? super A, ? extends CoProduct2<B,C,?>> function)
static <A> Fn1<Iterable<A>, Tuple2<Iterable<A>, Iterable<A>>>	Span.span(Fn1<? super A, ? extends Boolean> predicate)
static <A,B> Fn1<B, Tuple2<A,B>>	Tupler2.tupler(A a)
static <A,B> Fn1<Iterable<B>, Iterable<Tuple2<A,B>>>	Zip.zip(Iterable<A> as)
static <A,B> Iterable<Tuple2<A,B>>	Zip.zip(Iterable<A> as, Iterable<B> bs)

Method parameters in com.jnape.palatable.lambda.functions.builtin.fn2 with type arguments of type Tuple2

Modifier and Type	Method	Description
Iterable<A>	Unfoldr.checkedApply(Fn1<? super B, Maybe<Tuple2<A,B>>> fn, B b)
static <A,B> Fn1<B, Iterable<A>>	Unfoldr.unfoldr(Fn1<? super B, Maybe<Tuple2<A,B>>> fn)
static <A,B> Iterable<A>	Unfoldr.unfoldr(Fn1<? super B, Maybe<Tuple2<A,B>>> fn, B b)

Uses of Tuple2 in com.jnape.palatable.lambda.functor

Methods in com.jnape.palatable.lambda.functor that return types with arguments of type Tuple2

Modifier and Type	Method	Description
default Cartesian<A, Tuple2<A,B>, P>	Cartesian.carry()	Pair the covariantly-positioned carrier type with the contravariantly-positioned carrier type.
<C> Cartesian<Tuple2<C,A>, Tuple2<C,B>, P>	Cartesian.cartesian()	Pair some type C to this profunctor's carrier types.
<C> Cartesian<Tuple2<C,A>, Tuple2<C,B>, P>	Cartesian.cartesian()	Pair some type C to this profunctor's carrier types.

Uses of Tuple2 in com.jnape.palatable.lambda.functor.builtin

Fields in com.jnape.palatable.lambda.functor.builtin with type parameters of type Tuple2

Modifier and Type	Field	Description
private final Fn1<? super Monoid<W>, ? extends Tuple2<A,W>>	Writer.writerFn

Methods in com.jnape.palatable.lambda.functor.builtin that return Tuple2

Modifier and Type	Method	Description
Tuple2<A,S>	State.run(S s)	Run the stateful computation, returning a Tuple2 of the result and the final state.
Tuple2<A,W>	Writer.runWriter(Monoid<W> monoid)	Given a Monoid for the accumulation, run the computation represented by this Writer, accumulate the written output in terms of the Monoid, and produce the accumulation and the value.

Methods in com.jnape.palatable.lambda.functor.builtin that return types with arguments of type Tuple2

Modifier and Type	Method	Description
<B> State<S, Tuple2<A,B>>	State.listens(Fn1<? super S, ? extends B> fn)	Map the accumulation into a value and pair it with the current output.
<B> Writer<W, Tuple2<A,B>>	Writer.listens(Fn1<? super W, ? extends B> fn)	Map the accumulation into a value and pair it with the current output.

Methods in com.jnape.palatable.lambda.functor.builtin with parameters of type Tuple2

Modifier and Type	Method	Description
static <W,A> Writer<W,A>	Writer.writer(Tuple2<A,W> aw)	Construct a Writer from an accumulation and a value.

Method parameters in com.jnape.palatable.lambda.functor.builtin with type arguments of type Tuple2

Modifier and Type	Method	Description
<B> State<S,B>	State.mapState(Fn1<? super Tuple2<A,S>, ? extends Tuple2<B,S>> fn)	Map both the result and the final state to a new result and final state.
<B> State<S,B>	State.mapState(Fn1<? super Tuple2<A,S>, ? extends Tuple2<B,S>> fn)	Map both the result and the final state to a new result and final state.
static <S,A> State<S,A>	State.state(Fn1<? super S, ? extends Tuple2<A,S>> stateFn)	Create a State from stateFn, a function that maps an initial state into a result and a final state.

Constructor parameters in com.jnape.palatable.lambda.functor.builtin with type arguments of type Tuple2

Modifier	Constructor	Description
private	Writer(Fn1<? super Monoid<W>, ? extends Tuple2<A,W>> writerFn)

Uses of Tuple2 in com.jnape.palatable.lambda.internal.iteration

Subclasses with type arguments of type Tuple2 in com.jnape.palatable.lambda.internal.iteration

Modifier and Type	Class	Description
final class	CombinatorialIterator<A,B>

Fields in com.jnape.palatable.lambda.internal.iteration with type parameters of type Tuple2

Modifier and Type	Field	Description
private final Fn1<? super B, Maybe<Tuple2<A,B>>>	UnfoldingIterator.function
private Maybe<Tuple2<A,B>>	UnfoldingIterator.maybeAcc

Methods in com.jnape.palatable.lambda.internal.iteration that return Tuple2

Modifier and Type	Method	Description
Tuple2<A,B>	CombinatorialIterator.next()

Constructor parameters in com.jnape.palatable.lambda.internal.iteration with type arguments of type Tuple2

Modifier	Constructor	Description
	UnfoldingIterator(Fn1<? super B, Maybe<Tuple2<A,B>>> function, B seed)

Uses of Tuple2 in com.jnape.palatable.lambda.monad

Methods in com.jnape.palatable.lambda.monad that return types with arguments of type Tuple2

Modifier and Type	Method	Description
<B> MonadWriter<W, Tuple2<A,B>, MW>	MonadWriter.listens(Fn1<? super W, ? extends B> fn)	Map the accumulation into a value and pair it with the current output.

Uses of Tuple2 in com.jnape.palatable.lambda.monad.transformer.builtin

Fields in com.jnape.palatable.lambda.monad.transformer.builtin with type parameters of type Tuple2

Modifier and Type	Field	Description
private final ImmutableQueue<Choice2<Fn0<MonadRec<Maybe<Tuple2<A, IterateT<M,A>>>, M>>, MonadRec<A,M>>>	IterateT.spine
private final Fn1<? super S, ? extends MonadRec<Tuple2<A,S>, M>>	StateT.stateFn
private final Fn1<? super Monoid<W>, ? extends MonadRec<Tuple2<A,W>, M>>	WriterT.writerFn

Methods in com.jnape.palatable.lambda.monad.transformer.builtin with type parameters of type Tuple2

Modifier and Type	Method	Description
<MMTA extends MonadRec<Maybe<Tuple2<A, IterateT<M,A>>>, M>> MMTA	IterateT.runIterateT()	Recover the full structure of the embedded Monad.
<MAS extends MonadRec<Tuple2<A,S>, M>> MAS	StateT.runStateT(S s)	Run the stateful computation embedded in the Monad, returning a Tuple2 of the result and the final state.
<MStep extends MonadRec<Maybe<Tuple2<Maybe<A>, IterateT<M,A>>>, M>> MStep	IterateT.runStep()	Run a single step of this IterateT, where a step is the smallest amount of work that could possibly be productive in advancing through the IterateT.
<MAW extends MonadRec<Tuple2<A,W>, M>> MAW	WriterT.runWriterT(Monoid<W> monoid)	Given a Monoid for the accumulation, run the computation represented by this WriterT inside the monadic effect, accumulate the written output in terms of the Monoid, and produce the accumulation and the result inside the Monad.

Methods in com.jnape.palatable.lambda.monad.transformer.builtin that return types with arguments of type Tuple2

Modifier and Type	Method	Description
ReaderT<R, M, Tuple2<R,A>>	ReaderT.carry()	Pair the covariantly-positioned carrier type with the contravariantly-positioned carrier type.
<C> ReaderT<Tuple2<C,R>, M, Tuple2<C,A>>	ReaderT.cartesian()	Pair some type C to this profunctor's carrier types.
<C> ReaderT<Tuple2<C,R>, M, Tuple2<C,A>>	ReaderT.cartesian()	Pair some type C to this profunctor's carrier types.
<B> StateT<S, M, Tuple2<A,B>>	StateT.listens(Fn1<? super S, ? extends B> fn)	Map the accumulation into a value and pair it with the current output.
<B> WriterT<W, M, Tuple2<A,B>>	WriterT.listens(Fn1<? super W, ? extends B> fn)	Map the accumulation into a value and pair it with the current output.

Method parameters in com.jnape.palatable.lambda.monad.transformer.builtin with type arguments of type Tuple2

Modifier and Type	Method	Description
static <M extends MonadRec<?,M>, A> IterateT<M,A>	IterateT.iterateT(MonadRec<Maybe<Tuple2<A, IterateT<M,A>>>, M> unwrapped)	Static factory method for wrapping an uncons of an IterateT in an IterateT.
<N extends MonadRec<?,N>, B> StateT<S,N,B>	StateT.mapStateT(Fn1<? super MonadRec<Tuple2<A,S>, M>, ? extends MonadRec<Tuple2<B,S>, N>> fn)	Map both the result and the final state to a new result and final state inside the Monad.
<N extends MonadRec<?,N>, B> StateT<S,N,B>	StateT.mapStateT(Fn1<? super MonadRec<Tuple2<A,S>, M>, ? extends MonadRec<Tuple2<B,S>, N>> fn)	Map both the result and the final state to a new result and final state inside the Monad.
static <S, M extends MonadRec<?,M>, A> StateT<S,M,A>	StateT.stateT(Fn1<? super S, ? extends MonadRec<Tuple2<A,S>, M>> stateFn)	Lift a state-sensitive monadically embedded computation into StateT.
static <M extends MonadRec<?,M>, A> IterateT<M,A>	IterateT.suspended(Fn0<MonadRec<Maybe<Tuple2<A, IterateT<M,A>>>, M>> thunk, Pure<M> pureM)	Create an IterateT from a suspended computation that yields the spine of the IterateT inside the effect.
static <M extends MonadRec<?,M>, A, B> IterateT<M,A>	IterateT.unfold(Fn1<? super B, ? extends MonadRec<Maybe<Tuple2<A,B>>, M>> fn, MonadRec<B,M> mb)	Lazily unfold an IterateT from an unfolding function fn and a starting seed value mb by successively applying fn to the latest seed value, producing maybe a value to yield out and the next seed value for the subsequent computation.
static <W, M extends MonadRec<?,M>, A> WriterT<W,M,A>	WriterT.writerT(MonadRec<Tuple2<A,W>, M> maw)	Lift a value and an accumulation embedded in a Monad into a WriterT.

Constructor parameters in com.jnape.palatable.lambda.monad.transformer.builtin with type arguments of type Tuple2

Modifier	Constructor	Description
private	IterateT(Pure<M> pureM, ImmutableQueue<Choice2<Fn0<MonadRec<Maybe<Tuple2<A, IterateT<M,A>>>, M>>, MonadRec<A,M>>> spine)
private	StateT(Fn1<? super S, ? extends MonadRec<Tuple2<A,S>, M>> stateFn)
private	WriterT(Pure<M> pureM, Fn1<? super Monoid<W>, ? extends MonadRec<Tuple2<A,W>, M>> writerFn)

Uses of Tuple2 in com.jnape.palatable.lambda.monoid.builtin

Classes in com.jnape.palatable.lambda.monoid.builtin that implement interfaces with type arguments of type Tuple2

Modifier and Type	Class	Description
final class	Collapse<_1,_2>	A Monoid instance formed by a Tuple2<_1, _2> and monoids over _1 and _2.

Methods in com.jnape.palatable.lambda.monoid.builtin that return Tuple2

Modifier and Type	Method	Description
static <_1,_2> Tuple2<_1,_2>	Collapse.collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid, Tuple2<_1,_2> x, Tuple2<_1,_2> y)

Methods in com.jnape.palatable.lambda.monoid.builtin that return types with arguments of type Tuple2

Modifier and Type	Method	Description
Monoid<Tuple2<_1,_2>>	Collapse.checkedApply(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid)
static <_1,_2> MonoidFactory<Monoid<_2>, Tuple2<_1,_2>>	Collapse.collapse(Monoid<_1> _1Monoid)
static <_1,_2> Monoid<Tuple2<_1,_2>>	Collapse.collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid)
static <_1,_2> Fn1<Tuple2<_1,_2>, Tuple2<_1,_2>>	Collapse.collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid, Tuple2<_1,_2> x)
static <_1,_2> Fn1<Tuple2<_1,_2>, Tuple2<_1,_2>>	Collapse.collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid, Tuple2<_1,_2> x)

Methods in com.jnape.palatable.lambda.monoid.builtin with parameters of type Tuple2

Modifier and Type	Method	Description
static <_1,_2> Fn1<Tuple2<_1,_2>, Tuple2<_1,_2>>	Collapse.collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid, Tuple2<_1,_2> x)
static <_1,_2> Tuple2<_1,_2>	Collapse.collapse(Monoid<_1> _1Monoid, Monoid<_2> _2Monoid, Tuple2<_1,_2> x, Tuple2<_1,_2> y)

Uses of Tuple2 in com.jnape.palatable.lambda.optics

Methods in com.jnape.palatable.lambda.optics that return Tuple2

Modifier and Type	Method	Description
default Tuple2<Fn1<? super S, ? extends A>, Fn1<? super B, ? extends T>>	Iso.unIso()	Destructure this Iso into the two functions S -< A and B -< T that constitute the isomorphism.
default Tuple2<Fn1<? super B, ? extends T>, Fn1<? super S, ? extends Either<T,A>>>	Prism.unPrism()	Recover the two mappings encapsulated by this Prism by sending it through a Market.

Methods in com.jnape.palatable.lambda.optics that return types with arguments of type Tuple2

Modifier and Type	Method	Description
static <S,A,B> Lens.Simple<S, Tuple2<A,B>>	Lens.both(Lens.Simple<S,A> f, Lens.Simple<S,B> g)	Dually focus on two simple lenses at the same time.
static <S,A,B,C,D> Lens<S, S, Tuple2<A,B>, Tuple2<C,D>>	Lens.both(Lens<S,S,A,C> f, Lens<S,S,B,D> g)	Dually focus on two lenses at the same time.
static <S,A,B,C,D> Lens<S, S, Tuple2<A,B>, Tuple2<C,D>>	Lens.both(Lens<S,S,A,C> f, Lens<S,S,B,D> g)	Dually focus on two lenses at the same time.
static <S,A,B> Lens.Simple<S, Tuple2<A,B>>	Lens.Simple.both(Lens<S,S,A,A> f, Lens<S,S,B,B> g)	Specialization of Lens.both(Lens, Lens) for simple lenses.

Uses of Tuple2 in com.jnape.palatable.lambda.semigroup.builtin

Classes in com.jnape.palatable.lambda.semigroup.builtin that implement interfaces with type arguments of type Tuple2

Modifier and Type	Class	Description
final class	Collapse<_1,_2>	A Semigroup instance formed by a Tuple2<_1, _2> and semigroups over _1 and _2.

Methods in com.jnape.palatable.lambda.semigroup.builtin that return Tuple2

Modifier and Type	Method	Description
static <_1,_2> Tuple2<_1,_2>	Collapse.collapse(Semigroup<_1> _1Semigroup, Semigroup<_2> _2Semigroup, Tuple2<_1,_2> x, Tuple2<_1,_2> y)

Methods in com.jnape.palatable.lambda.semigroup.builtin that return types with arguments of type Tuple2

Modifier and Type	Method	Description
Semigroup<Tuple2<_1,_2>>	Collapse.checkedApply(Semigroup<_1> _1Semigroup, Semigroup<_2> _2Semigroup)
static <_1,_2> SemigroupFactory<Semigroup<_2>, Tuple2<_1,_2>>	Collapse.collapse(Semigroup<_1> _1Semigroup)
static <_1,_2> Semigroup<Tuple2<_1,_2>>	Collapse.collapse(Semigroup<_1> _1Semigroup, Semigroup<_2> _2Semigroup)
static <_1,_2> Fn1<Tuple2<_1,_2>, Tuple2<_1,_2>>	Collapse.collapse(Semigroup<_1> _1Semigroup, Semigroup<_2> _2Semigroup, Tuple2<_1,_2> x)
static <_1,_2> Fn1<Tuple2<_1,_2>, Tuple2<_1,_2>>	Collapse.collapse(Semigroup<_1> _1Semigroup, Semigroup<_2> _2Semigroup, Tuple2<_1,_2> x)

Methods in com.jnape.palatable.lambda.semigroup.builtin with parameters of type Tuple2

Modifier and Type	Method	Description
static <_1,_2> Fn1<Tuple2<_1,_2>, Tuple2<_1,_2>>	Collapse.collapse(Semigroup<_1> _1Semigroup, Semigroup<_2> _2Semigroup, Tuple2<_1,_2> x)
static <_1,_2> Tuple2<_1,_2>	Collapse.collapse(Semigroup<_1> _1Semigroup, Semigroup<_2> _2Semigroup, Tuple2<_1,_2> x, Tuple2<_1,_2> y)