| Modifier and Type | Method and 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.
|
| Modifier and Type | Method and Description |
|---|---|
Tuple2<Maybe<A>,Maybe<B>> |
Choice2.project()
Specialize this choice's projection to a
Tuple2. |
| Modifier and Type | Method and Description |
|---|---|
<_2Prime,App extends Applicative<?,App>,TravB extends Traversable<_2Prime,Tuple2<_1,?>>,AppTrav extends Applicative<TravB,App>> |
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. |
| Modifier and Type | Method and Description |
|---|---|
<_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<_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. |
<_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.
|
| Modifier and Type | Method and Description |
|---|---|
static <A> Maybe<Tuple2<A,A>> |
Tuple2.fromIterable(Iterable<A> as)
|
<_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)
|
| Modifier and Type | Method and 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.
|
| Modifier and Type | Method and 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. |
| Modifier and Type | Method and 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.
|
| Modifier and Type | Method and Description |
|---|---|
static <A,B,C> Fn2<A,B,C> |
Fn2.curry(Fn1<? super Tuple2<A,B>,? extends C> uncurriedFn1)
|
| Modifier and Type | Method and Description |
|---|---|
Maybe<Tuple2<A,Iterable<A>>> |
Uncons.checkedApply(Iterable<A> as) |
static <A> Maybe<Tuple2<A,Iterable<A>>> |
Uncons.uncons(Iterable<A> as) |
| Modifier and Type | Method and 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<A,B> |
Tupler2.checkedApply(A a,
B b) |
Tuple2<B,C> |
Both.checkedApply(Fn1<? super A,? extends B> f,
Fn1<? super A,? extends C> g,
A a) |
Tuple2<Iterable<A>,Iterable<A>> |
Span.checkedApply(Fn1<? super A,? extends Boolean> predicate,
Iterable<A> as) |
Tuple2<Iterable<B>,Iterable<C>> |
Partition.checkedApply(Fn1<? super A,? extends CoProduct2<B,C,?>> function,
Iterable<A> as) |
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) |
| Modifier and Type | Method and 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) |
| Modifier and Type | Method and 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) |
| Modifier and Type | Method and 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. |
| Modifier and Type | Method and 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)
|
| Modifier and Type | Method and 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.
|
| Modifier and Type | Method and Description |
|---|---|
static <W,A> Writer<W,A> |
Writer.writer(Tuple2<A,W> aw)
Construct a
Writer from an accumulation and a value. |
| Modifier and Type | Method and 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. |
| Modifier and Type | Method and Description |
|---|---|
Tuple2<A,B> |
CombinatorialIterator.next() |
| Constructor and Description |
|---|
UnfoldingIterator(Fn1<? super B,Maybe<Tuple2<A,B>>> function,
B seed) |
| Modifier and Type | Method and 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.
|
| Modifier and Type | Method and Description |
|---|---|
<MAS extends MonadRec<Tuple2<A,S>,M>> |
StateT.runStateT(S s)
|
<MAW extends MonadRec<Tuple2<A,W>,M>> |
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. |
| Modifier and Type | Method and 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.
|
| Modifier and Type | Method and Description |
|---|---|
<N extends MonadRec<?,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.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.stateT(Fn1<? super S,? extends MonadRec<Tuple2<A,S>,M>> stateFn)
Lift a state-sensitive
monadically embedded computation into StateT. |
static <W,M extends MonadRec<?,M>,A> |
WriterT.writerT(MonadRec<Tuple2<A,W>,M> maw)
|
| Modifier and Type | Method and Description |
|---|---|
static <_1,_2> Tuple2<_1,_2> |
Collapse.collapse(Monoid<_1> _1Monoid,
Monoid<_2> _2Monoid,
Tuple2<_1,_2> x,
Tuple2<_1,_2> y) |
| Modifier and Type | Method and 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) |
| Modifier and Type | Method and 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) |
static <_1,_2> Tuple2<_1,_2> |
Collapse.collapse(Monoid<_1> _1Monoid,
Monoid<_2> _2Monoid,
Tuple2<_1,_2> x,
Tuple2<_1,_2> y) |
| Modifier and Type | Method and Description |
|---|---|
default Tuple2<Fn1<? super S,? extends A>,Fn1<? super B,? extends T>> |
Iso.unIso()
|
default Tuple2<Fn1<? super B,? extends T>,Fn1<? super S,? extends Either<T,A>>> |
Prism.unPrism()
|
| Modifier and Type | Method and 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> 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. |
static <S,A,B,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.both(Lens<S,S,A,C> f,
Lens<S,S,B,D> g)
Dually focus on two lenses at the same time.
|
| Modifier and Type | Method and Description |
|---|---|
static <_1,_2> Tuple2<_1,_2> |
Collapse.collapse(Semigroup<_1> _1Semigroup,
Semigroup<_2> _2Semigroup,
Tuple2<_1,_2> x,
Tuple2<_1,_2> y) |
| Modifier and Type | Method and 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) |
| Modifier and Type | Method and 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) |
static <_1,_2> Tuple2<_1,_2> |
Collapse.collapse(Semigroup<_1> _1Semigroup,
Semigroup<_2> _2Semigroup,
Tuple2<_1,_2> x,
Tuple2<_1,_2> y) |