Uses of Class
com.github.tonivade.purefun.core.Tuple2

Packages that use Tuple2

Package	Description
com.github.tonivade.purefun.concurrent
com.github.tonivade.purefun.core
com.github.tonivade.purefun.data
com.github.tonivade.purefun.effect
com.github.tonivade.purefun.instances
com.github.tonivade.purefun.monad
com.github.tonivade.purefun.stream
com.github.tonivade.purefun.transformer
com.github.tonivade.purefun.typeclasses

Uses of Tuple2 in com.github.tonivade.purefun.concurrent

Methods in com.github.tonivade.purefun.concurrent that return types with arguments of type Tuple2

Modifier and Type	Method	Description
static <T, V> Future<Tuple2<T,V>>	Future.tuple(Future<T> fa, Future<V> fb)

Uses of Tuple2 in com.github.tonivade.purefun.core

Fields in com.github.tonivade.purefun.core with type parameters of type Tuple2

Modifier and Type	Field	Description
private static final Equal<Tuple2<?,?>>	Tuple2.EQUAL

Methods in com.github.tonivade.purefun.core that return Tuple2

Modifier and Type	Method	Description
static <A, B> Tuple2<A,B>	Tuple.from(Map.Entry<A,B> entry)
<C, D> Tuple2<C,D>	Tuple2.map(Function1<? super A,? extends C> mapper1, Function1<? super B,? extends D> mapper2)
<C> Tuple2<C,B>	Tuple2.map1(Function1<? super A,? extends C> mapper)
<C> Tuple2<A,C>	Tuple2.map2(Function1<? super B,? extends C> mapper)
static <A, B> Tuple2<A,B>	Tuple.of(A value1, B value2)
static <A, B> Tuple2<A,B>	Tuple2.of(A value1, B value2)
static <A, B> Tuple2<A,B>	Tuple2Of.toTuple2(Kind<Tuple2<A,?>,? extends B> value)

Methods in com.github.tonivade.purefun.core that return types with arguments of type Tuple2

Modifier and Type	Method	Description
static <A, B, T> Function1<Tuple2<A,B>,T>	Tuple.applyTo(Function2<? super A,? super B,? extends T> function)
static <E, A, B> Validator<Validation.Result<E>,Tuple2<A,B>>	Validator.product(Validator<E,A> v1, Validator<E,B> v2)
static <E, F, A, B> Validator<F,Tuple2<A,B>>	Validator.product(Validator<E,A> v1, Validator<E,B> v2, Function1<Validation.Result<E>,F> reduce)
Effect<F,Tuple2<Duration,A>>	Effect.timed()
default Function1<Tuple2<A,B>,R>	Function2.tupled()
default Matcher1<Tuple2<A,B>>	Matcher2.tupled()
default <B> Applicable<F,Tuple2<A,B>>	Applicable.zip(Kind<F,? extends B> other)
default <B> Effect<F,Tuple2<A,B>>	Effect.zip(Kind<F,? extends B> other)

Method parameters in com.github.tonivade.purefun.core with type arguments of type Tuple2

Modifier and Type	Method	Description
static <A, B> Tuple2<A,B>	Tuple2Of.toTuple2(Kind<Tuple2<A,?>,? extends B> value)

Uses of Tuple2 in com.github.tonivade.purefun.data

Methods in com.github.tonivade.purefun.data that return Tuple2

Modifier and Type	Method	Description
static <K, V> Tuple2<K,V>	ImmutableMap.entry(K key, V value)
static <K, V> Tuple2<K,V>	ImmutableTreeMap.entry(K key, V value)
Tuple2<A,B>	PairIterator.next()

Methods in com.github.tonivade.purefun.data that return types with arguments of type Tuple2

Modifier and Type	Method	Description
Option<Tuple2<K,V>>	ImmutableTreeMap.ceilingEntry(K key)
Option<Tuple2<K,V>>	ImmutableTreeMap.PImmutableTreeMap.ceilingEntry(K key)
ImmutableSet<Tuple2<K,V>>	ImmutableMap.entries()
ImmutableSet<Tuple2<K,V>>	ImmutableMap.PImmutableMap.entries()
ImmutableSet<Tuple2<K,V>>	ImmutableTreeMap.PImmutableTreeMap.entries()
Option<Tuple2<K,V>>	ImmutableTreeMap.floorEntry(K key)
Option<Tuple2<K,V>>	ImmutableTreeMap.PImmutableTreeMap.floorEntry(K key)
Option<Tuple2<K,V>>	ImmutableTreeMap.headEntry()
Option<Tuple2<K,V>>	ImmutableTreeMap.PImmutableTreeMap.headEntry()
Option<Tuple2<K,V>>	ImmutableTreeMap.higherEntry(K key)
Option<Tuple2<K,V>>	ImmutableTreeMap.PImmutableTreeMap.higherEntry(K key)
default Iterator<Tuple2<K,V>>	ImmutableMap.iterator()
Option<Tuple2<K,V>>	ImmutableTreeMap.lowerEntry(K key)
Option<Tuple2<K,V>>	ImmutableTreeMap.PImmutableTreeMap.lowerEntry(K key)
Option<Tuple2<K,V>>	ImmutableTreeMap.PImmutableTreeMap.tailEntry()
Option<Tuple2<K,V>>	ImmutableTreeMap.tailEntry()
static <A, B> Stream<Tuple2<A,B>>	Sequence.zip(Sequence<A> first, Sequence<B> second)
static <A, B> Stream<Tuple2<A,B>>	Sequence.zip(Iterator<A> first, Iterator<B> second)
static <A, B> Stream<Tuple2<A,B>>	Sequence.zip(Stream<A> first, Stream<B> second)
default Stream<Tuple2<Integer,E>>	Sequence.zipWithIndex()

Methods in com.github.tonivade.purefun.data with parameters of type Tuple2

Modifier and Type	Method	Description
static <K, V> ImmutableMap<K,V>	ImmutableMap.of(Tuple2<K,V>... entries)
static <K, V> ImmutableTreeMap<K,V>	ImmutableTreeMap.of(Tuple2<K,V>... entries)

Method parameters in com.github.tonivade.purefun.data with type arguments of type Tuple2

Modifier and Type	Method	Description
static <K, V> ImmutableMap<K,V>	ImmutableMap.from(ImmutableSet<Tuple2<K,V>> entries)
static <K, V> ImmutableMap<K,V>	ImmutableMap.from(Iterable<Tuple2<K,V>> entries)
static <K, V> ImmutableMap<K,V>	ImmutableMap.from(Stream<Tuple2<K,V>> entries)
static <K, V> ImmutableTreeMap<K,V>	ImmutableTreeMap.from(ImmutableSet<Tuple2<K,V>> entries)
static <K, V> ImmutableTreeMap<K,V>	ImmutableTreeMap.from(Comparator<? super K> comparator, ImmutableSet<Tuple2<K,V>> entries)
static <K, V> ImmutableTreeMap<K,V>	ImmutableTreeMap.from(Comparator<? super K> comparator, Stream<Tuple2<K,V>> entries)
static <K, V> ImmutableTreeMap<K,V>	ImmutableTreeMap.from(Stream<Tuple2<K,V>> entries)

Uses of Tuple2 in com.github.tonivade.purefun.effect

Fields in com.github.tonivade.purefun.effect with type parameters of type Tuple2

Modifier and Type	Field	Description
private final PureIO<R,E,Tuple2<A,Consumer1<? super A>>>	Managed.resource

Methods in com.github.tonivade.purefun.effect that return types with arguments of type Tuple2

Modifier and Type	Method	Description
<B> Managed<R,E,Tuple2<A,B>>	Managed.combine(Managed<R,E,B> other)
static <E, A, B> EIO<E,Either<Tuple2<A,Fiber<EIO<E,?>,B>>,Tuple2<Fiber<EIO<E,?>,A>,B>>>	EIO.racePair(Executor executor, Kind<EIO<E,?>,? extends A> fa, Kind<EIO<E,?>,? extends B> fb)
static <E, A, B> EIO<E,Either<Tuple2<A,Fiber<EIO<E,?>,B>>,Tuple2<Fiber<EIO<E,?>,A>,B>>>	EIO.racePair(Executor executor, Kind<EIO<E,?>,? extends A> fa, Kind<EIO<E,?>,? extends B> fb)
static <R, E, A, B> PureIO<R,E,Either<Tuple2<A,Fiber<PureIO<R,E,?>,B>>,Tuple2<Fiber<PureIO<R,E,?>,A>,B>>>	PureIO.racePair(Executor executor, Kind<PureIO<R,E,?>,? extends A> fa, Kind<PureIO<R,E,?>,? extends B> fb)
static <R, E, A, B> PureIO<R,E,Either<Tuple2<A,Fiber<PureIO<R,E,?>,B>>,Tuple2<Fiber<PureIO<R,E,?>,A>,B>>>	PureIO.racePair(Executor executor, Kind<PureIO<R,E,?>,? extends A> fa, Kind<PureIO<R,E,?>,? extends B> fb)
static <R, A, B> RIO<R,Either<Tuple2<A,Fiber<RIO<R,?>,B>>,Tuple2<Fiber<RIO<R,?>,A>,B>>>	RIO.racePair(Executor executor, Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
static <R, A, B> RIO<R,Either<Tuple2<A,Fiber<RIO<R,?>,B>>,Tuple2<Fiber<RIO<R,?>,A>,B>>>	RIO.racePair(Executor executor, Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
static <A, B> Task<Either<Tuple2<A,Fiber<Task<?>,B>>,Tuple2<Fiber<Task<?>,A>,B>>>	Task.racePair(Executor executor, Kind<Task<?>,? extends A> fa, Kind<Task<?>,? extends B> fb)
static <A, B> Task<Either<Tuple2<A,Fiber<Task<?>,B>>,Tuple2<Fiber<Task<?>,A>,B>>>	Task.racePair(Executor executor, Kind<Task<?>,? extends A> fa, Kind<Task<?>,? extends B> fb)
static <A, B> UIO<Either<Tuple2<A,Fiber<UIO<?>,B>>,Tuple2<Fiber<UIO<?>,A>,B>>>	UIO.racePair(Executor executor, Kind<UIO<?>,? extends A> fa, Kind<UIO<?>,? extends B> fb)
static <A, B> UIO<Either<Tuple2<A,Fiber<UIO<?>,B>>,Tuple2<Fiber<UIO<?>,A>,B>>>	UIO.racePair(Executor executor, Kind<UIO<?>,? extends A> fa, Kind<UIO<?>,? extends B> fb)
static <R, A, B> URIO<R,Either<Tuple2<A,Fiber<URIO<R,?>,B>>,Tuple2<Fiber<URIO<R,?>,A>,B>>>	URIO.racePair(Executor executor, Kind<URIO<R,?>,? extends A> fa, Kind<URIO<R,?>,? extends B> fb)
static <R, A, B> URIO<R,Either<Tuple2<A,Fiber<URIO<R,?>,B>>,Tuple2<Fiber<URIO<R,?>,A>,B>>>	URIO.racePair(Executor executor, Kind<URIO<R,?>,? extends A> fa, Kind<URIO<R,?>,? extends B> fb)
private static <T> Consumer1<Tuple2<T,Consumer1<? super T>>>	Managed.release()
EIO<E,Tuple2<Duration,A>>	EIO.timed()
Managed<R,E,Tuple2<Duration,A>>	Managed.timed()
default PureIO<R,E,Tuple2<Duration,A>>	PureIO.timed()
RIO<R,Tuple2<Duration,A>>	RIO.timed()
Task<Tuple2<Duration,A>>	Task.timed()
UIO<Tuple2<Duration,A>>	UIO.timed()
URIO<R,Tuple2<Duration,A>>	URIO.timed()
<B> EIO<E,Tuple2<A,B>>	EIO.zip(Kind<EIO<E,?>,? extends B> other)
default <B> PureIO<R,E,Tuple2<A,B>>	PureIO.zip(Kind<PureIO<R,E,?>,? extends B> other)
<B> RIO<R,Tuple2<A,B>>	RIO.zip(Kind<RIO<R,?>,? extends B> other)
<B> Task<Tuple2<A,B>>	Task.zip(Kind<Task<?>,? extends B> other)
<B> UIO<Tuple2<A,B>>	UIO.zip(Kind<UIO<?>,? extends B> other)
<B> URIO<R,Tuple2<A,B>>	URIO.zip(Kind<URIO<R,?>,? extends B> other)

Methods in com.github.tonivade.purefun.effect with parameters of type Tuple2

Modifier and Type	Method	Description
private static <X, T, R> Consumer1<X>	Managed.releaseAndThen(Tuple2<T,Consumer1<? super T>> outter, Tuple2<R,Consumer1<? super R>> inner)

Method parameters in com.github.tonivade.purefun.effect with type arguments of type Tuple2

Modifier and Type	Method	Description
<B> UIO<B>	Ref.modify(Function1<A,Tuple2<B,A>> change)

Constructor parameters in com.github.tonivade.purefun.effect with type arguments of type Tuple2

Modifier	Constructor	Description
private	Managed(PureIO<R,E,Tuple2<A,Consumer1<? super A>>> resource)

Uses of Tuple2 in com.github.tonivade.purefun.instances

Methods in com.github.tonivade.purefun.instances that return types with arguments of type Tuple2

Modifier and Type	Method	Description
default <A> WriterT<F,L,Tuple2<L,A>>	WriterTMonadWriter.listen(Kind<WriterT<F,L,?>,? extends A> value)
default <A, B> Kind<Option<?>,Tuple2<A,B>>	OptionSemigroupal.product(Kind<Option<?>,? extends A> fa, Kind<Option<?>,? extends B> fb)
default <A, B> EIO<Throwable,Either<Tuple2<A,Fiber<EIO<Throwable,?>,B>>,Tuple2<Fiber<EIO<Throwable,?>,A>,B>>>	EIOConcurrent.racePair(Kind<EIO<Throwable,?>,? extends A> fa, Kind<EIO<Throwable,?>,? extends B> fb)
default <A, B> EIO<Throwable,Either<Tuple2<A,Fiber<EIO<Throwable,?>,B>>,Tuple2<Fiber<EIO<Throwable,?>,A>,B>>>	EIOConcurrent.racePair(Kind<EIO<Throwable,?>,? extends A> fa, Kind<EIO<Throwable,?>,? extends B> fb)
default <A, B> IO<Either<Tuple2<A,Fiber<IO<?>,B>>,Tuple2<Fiber<IO<?>,A>,B>>>	IOConcurrent.racePair(Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
default <A, B> IO<Either<Tuple2<A,Fiber<IO<?>,B>>,Tuple2<Fiber<IO<?>,A>,B>>>	IOConcurrent.racePair(Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
default <A, B> PureIO<R,Throwable,Either<Tuple2<A,Fiber<PureIO<R,Throwable,?>,B>>,Tuple2<Fiber<PureIO<R,Throwable,?>,A>,B>>>	PureIOConcurrent.racePair(Kind<PureIO<R,Throwable,?>,? extends A> fa, Kind<PureIO<R,Throwable,?>,? extends B> fb)
default <A, B> PureIO<R,Throwable,Either<Tuple2<A,Fiber<PureIO<R,Throwable,?>,B>>,Tuple2<Fiber<PureIO<R,Throwable,?>,A>,B>>>	PureIOConcurrent.racePair(Kind<PureIO<R,Throwable,?>,? extends A> fa, Kind<PureIO<R,Throwable,?>,? extends B> fb)
default <A, B> RIO<R,Either<Tuple2<A,Fiber<RIO<R,?>,B>>,Tuple2<Fiber<RIO<R,?>,A>,B>>>	RIOConcurrent.racePair(Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
default <A, B> RIO<R,Either<Tuple2<A,Fiber<RIO<R,?>,B>>,Tuple2<Fiber<RIO<R,?>,A>,B>>>	RIOConcurrent.racePair(Kind<RIO<R,?>,? extends A> fa, Kind<RIO<R,?>,? extends B> fb)
default <A, B> Task<Either<Tuple2<A,Fiber<Task<?>,B>>,Tuple2<Fiber<Task<?>,A>,B>>>	TaskConcurrent.racePair(Kind<Task<?>,? extends A> fa, Kind<Task<?>,? extends B> fb)
default <A, B> Task<Either<Tuple2<A,Fiber<Task<?>,B>>,Tuple2<Fiber<Task<?>,A>,B>>>	TaskConcurrent.racePair(Kind<Task<?>,? extends A> fa, Kind<Task<?>,? extends B> fb)
default <A, B> UIO<Either<Tuple2<A,Fiber<UIO<?>,B>>,Tuple2<Fiber<UIO<?>,A>,B>>>	UIOConcurrent.racePair(Kind<UIO<?>,? extends A> fa, Kind<UIO<?>,? extends B> fb)
default <A, B> UIO<Either<Tuple2<A,Fiber<UIO<?>,B>>,Tuple2<Fiber<UIO<?>,A>,B>>>	UIOConcurrent.racePair(Kind<UIO<?>,? extends A> fa, Kind<UIO<?>,? extends B> fb)
default <A, B> URIO<R,Either<Tuple2<A,Fiber<URIO<R,?>,B>>,Tuple2<Fiber<URIO<R,?>,A>,B>>>	URIOConcurrent.racePair(Kind<URIO<R,?>,? extends A> fa, Kind<URIO<R,?>,? extends B> fb)
default <A, B> URIO<R,Either<Tuple2<A,Fiber<URIO<R,?>,B>>,Tuple2<Fiber<URIO<R,?>,A>,B>>>	URIOConcurrent.racePair(Kind<URIO<R,?>,? extends A> fa, Kind<URIO<R,?>,? extends B> fb)
MonadMTL.EffectR<F,R,E,Tuple2<S,A>>	MonadMTL.EffectS.run(S state)
MonadMTL.EffectE<F,E,Tuple2<S,A>>	MonadMTL.EffectS.run(S state, R env)

Methods in com.github.tonivade.purefun.instances with parameters of type Tuple2

Modifier and Type	Method	Description
default <A> WriterT<F,L,A>	WriterTMonadWriter.writer(Tuple2<L,A> value)

Method parameters in com.github.tonivade.purefun.instances with type arguments of type Tuple2

Modifier and Type	Method	Description
default <A> WriterT<F,L,A>	WriterTMonadWriter.pass(Kind<WriterT<F,L,?>,Tuple2<Operator1<L>,A>> value)

Uses of Tuple2 in com.github.tonivade.purefun.monad

Methods in com.github.tonivade.purefun.monad that return Tuple2

Modifier and Type	Method	Description
Tuple2<S,A>	State.run(S state)
Tuple2<L,A>	Writer.value()

Methods in com.github.tonivade.purefun.monad that return types with arguments of type Tuple2

Modifier and Type	Method	Description
static <A, B> IO<Either<Tuple2<A,Fiber<IO<?>,B>>,Tuple2<Fiber<IO<?>,A>,B>>>	IO.racePair(Executor executor, Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
static <A, B> IO<Either<Tuple2<A,Fiber<IO<?>,B>>,Tuple2<Fiber<IO<?>,A>,B>>>	IO.racePair(Executor executor, Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
default IO<Tuple2<Duration,T>>	IO.timed()
static <A, B> IO<Tuple2<A,B>>	IO.tuple(Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)
static <A, B> IO<Tuple2<A,B>>	IO.tuple(Executor executor, Kind<IO<?>,? extends A> fa, Kind<IO<?>,? extends B> fb)

Methods in com.github.tonivade.purefun.monad with parameters of type Tuple2

Modifier and Type	Method	Description
static <L, A> Writer<L,A>	Writer.writer(Monoid<L> monoid, Tuple2<L,A> value)

Method parameters in com.github.tonivade.purefun.monad with type arguments of type Tuple2

Modifier and Type	Method	Description
<B> IO<B>	Ref.modify(Function1<A,Tuple2<B,A>> change)
static <S, A> State<S,A>	State.state(Function1<S,Tuple2<S,A>> runState)

Uses of Tuple2 in com.github.tonivade.purefun.stream

Methods in com.github.tonivade.purefun.stream that return types with arguments of type Tuple2

Modifier and Type	Method	Description
Kind<F,Option<Tuple2<Kind<F,T>,PureStream<F,T>>>>	Cons.split()
Kind<F,Option<Tuple2<Kind<F,T>,PureStream<F,T>>>>	Nil.split()
Kind<F,Option<Tuple2<Kind<F,T>,PureStream<F,T>>>>	PureStream.split()
Kind<F,Option<Tuple2<Kind<F,T>,PureStream<F,T>>>>	Suspend.split()
default <A, B> PureStream<F,Tuple2<A,B>>	PureStream.Of.zip(PureStream<F,? extends A> s1, PureStream<F,? extends B> s2)
static <F extends Kind<F, ?>, A, B> PureStream<F,Tuple2<A,B>>	PureStream.zip(PureStream<F,? extends A> s1, PureStream<F,? extends B> s2, F... reified)
default <A> PureStream<F,Tuple2<A,Integer>>	PureStream.Of.zipWithIndex(PureStream<F,? extends A> stream)
static <F extends Kind<F, ?>, A> PureStream<F,Tuple2<A,Integer>>	PureStream.zipWithIndex(PureStream<F,? extends A> stream, F... reified)

Method parameters in com.github.tonivade.purefun.stream with type arguments of type Tuple2

Modifier and Type	Method	Description
private <T, S> PureStream<F,T>	PureStream.Of.doUnfold(S seed, Function1<? super S,Option<Tuple2<? extends T,? extends S>>> function)
default <T, S> PureStream<F,T>	PureStream.Of.unfold(S seed, Function1<? super S,Option<Tuple2<? extends T,? extends S>>> function)
static <F extends Kind<F, ?>, T, S> PureStream<F,T>	PureStream.unfold(S seed, Function1<? super S,Option<Tuple2<? extends T,? extends S>>> function, F... reified)

Uses of Tuple2 in com.github.tonivade.purefun.transformer

Methods in com.github.tonivade.purefun.transformer that return types with arguments of type Tuple2

Modifier and Type	Method	Description
default WriterT<F,L,Tuple2<L,A>>	WriterT.listen()
Kind<F,Tuple2<S,A>>	StateT.run(S state)
Kind<F,Tuple2<L,A>>	WriterT.value()

Methods in com.github.tonivade.purefun.transformer with parameters of type Tuple2

Modifier and Type	Method	Description
static <F extends Kind<F, ?>, L, A> WriterT<F,L,A>	WriterT.lift(Monoid<L> monoid, Monad<F> monad, Tuple2<L,A> value)

Method parameters in com.github.tonivade.purefun.transformer with type arguments of type Tuple2

Modifier and Type	Method	Description
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateT.lift(Monad<F> monad, Function1<S,Tuple2<S,A>> run)
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateT.of(Monad<F> monad, Function1<S,Kind<F,Tuple2<S,A>>> run)
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateT.state(Monad<F> monad, Function1<S,Kind<F,Tuple2<S,A>>> run)
static <F extends Kind<F, ?>, L, A> WriterT<F,L,A>	WriterT.writer(Monoid<L> monoid, Monad<F> monad, Kind<F,Tuple2<L,A>> value)

Uses of Tuple2 in com.github.tonivade.purefun.typeclasses

Fields in com.github.tonivade.purefun.typeclasses with type parameters of type Tuple2

Modifier and Type	Field	Description
private final Kind<F,Tuple2<T,Consumer1<? super T>>>	Resource.resource

Methods in com.github.tonivade.purefun.typeclasses that return types with arguments of type Tuple2

Modifier and Type	Method	Description
Kind<F,Tuple2<A,B>>	TupleK2.apply(Applicative<F> applicative)
final Kind<F,Tuple2<A,B>>	TupleK2.apply(F... reified)
<R> Resource<F,Tuple2<T,R>>	Resource.combine(Resource<F,? extends R> other)
private <T, C> ScheduleImpl<F,Tuple2<S,T>,A,C>	ScheduleImpl.doCompose(ScheduleImpl<F,T,B,C> other)
private <T, C> ScheduleImpl<F,Tuple2<S,T>,A,Tuple2<B,C>>	ScheduleImpl.doZip(ScheduleImpl<F,T,A,C> other)
private <T, C> ScheduleImpl<F,Tuple2<S,T>,A,Tuple2<B,C>>	ScheduleImpl.doZip(ScheduleImpl<F,T,A,C> other)
<A> Kind<F,Tuple2<W,A>>	MonadWriter.listen(Kind<F,? extends A> value)
default <A, B> Kind<F,Tuple2<B,A>>	MonadWriter.listens(Kind<F,? extends A> value, Function1<? super W,? extends B> mapper)
<A, B> Kind<F,Tuple2<A,B>>	Semigroupal.product(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
<A, B> Kind<F,Either<Tuple2<A,Fiber<F,B>>,Tuple2<Fiber<F,A>,B>>>	Concurrent.racePair(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
<A, B> Kind<F,Either<Tuple2<A,Fiber<F,B>>,Tuple2<Fiber<F,A>,B>>>	Concurrent.racePair(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
default <A> Schedule<F,A,Tuple2<Integer,Integer>>	Schedule.Of.recursSpaced(Duration delay, int times)
static <F extends Kind<F, ?>, A> Schedule<F,A,Tuple2<Integer,Integer>>	Schedule.recursSpaced(Duration delay, int times, F... reified)
private static <T> Consumer1<Tuple2<T,Consumer1<? super T>>>	Resource.release()
default <A, B, C> Kind<F,Tuple2<C,A>>	MonadDefer.summarized(Kind<F,A> value, Kind<F,B> summary, Function2<? super B,? super B,? extends C> combinator)
default <A> Kind<F,Tuple2<Duration,A>>	MonadDefer.timed(Kind<F,A> value)
default <A, B> Kind<F,Tuple2<A,B>>	Applicative.tuple(Kind<F,? extends A> fa, Kind<F,? extends B> fb)
Kind<F,Tuple2<A,B>>	Apply2.tuple()
Kind<F,Tuple2<A,B>>	FlatMap2.tuple()
<C> Schedule<F,A,Tuple2<B,C>>	Schedule.zip(Schedule<F,A,C> other)
<C> Schedule<F,A,Tuple2<B,C>>	ScheduleImpl.zip(Schedule<F,A,C> other)

Methods in com.github.tonivade.purefun.typeclasses with parameters of type Tuple2

Modifier and Type	Method	Description
private static <T, R> void	Resource.releaseAndThen(Tuple2<T,Consumer1<? super T>> outter, Tuple2<R,Consumer1<? super R>> inner)
<A> Kind<F,A>	MonadWriter.writer(Tuple2<W,A> value)

Method parameters in com.github.tonivade.purefun.typeclasses with type arguments of type Tuple2

Modifier and Type	Method	Description
<B> Kind<F,B>	MonadDeferReference.modify(Function1<A,Tuple2<B,A>> change)
<B> Kind<F,B>	Reference.modify(Function1<A,Tuple2<B,A>> change)
<A> Kind<F,A>	MonadWriter.pass(Kind<F,Tuple2<Operator1<W>,A>> value)
default <A> Kind<F,A>	MonadState.state(Function1<? super S,Tuple2<S,? extends A>> mapper)

Constructor parameters in com.github.tonivade.purefun.typeclasses with type arguments of type Tuple2

Modifier	Constructor	Description
(package private)	Resource(MonadDefer<F> monad, Kind<F,Tuple2<T,Consumer1<? super T>>> resource)