Uses of Interface
com.github.tonivade.purefun.core.Function1

Packages that use Function1

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.free
com.github.tonivade.purefun.instances
com.github.tonivade.purefun.monad
com.github.tonivade.purefun.optics
com.github.tonivade.purefun.runtimes
com.github.tonivade.purefun.stream
com.github.tonivade.purefun.transformer
com.github.tonivade.purefun.type
com.github.tonivade.purefun.typeclasses

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

Methods in com.github.tonivade.purefun.concurrent with parameters of type Function1

Modifier and Type	Method	Description
static <T extends AutoCloseable, R> Future<R>	Future.bracket(Future<? extends T> acquire, Function1<? super T,? extends Future<? extends R>> use)
static <T, R> Future<R>	Future.bracket(Future<? extends T> acquire, Function1<? super T,? extends Future<? extends R>> use, Consumer1<? super T> release)
static <T extends AutoCloseable, R> Future<R>	Future.bracket(Executor executor, Future<? extends T> acquire, Function1<? super T,? extends Future<? extends R>> use)
static <T, R> Future<R>	Future.bracket(Executor executor, Future<? extends T> acquire, Function1<? super T,? extends Future<? extends R>> use, Consumer1<? super T> release)
(package private) static <T, R> Future<R>	FutureImpl.bracket(Executor executor, Future<? extends T> acquire, Function1<? super T,? extends Future<? extends R>> use, Consumer1<? super T> release)
private <R> Future<R>	FutureImpl.chain(Function1<? super Try<? extends T>,? extends Kind<Future<?>,? extends R>> mapper)
<R> Future<R>	Future.flatMap(Function1<? super T,? extends Kind<Future<?>,? extends R>> mapper)
<R> Future<R>	FutureImpl.flatMap(Function1<? super T,? extends Kind<Future<?>,? extends R>> mapper)
<R> Promise<R>	Promise.flatMap(Function1<? super T,? extends Kind<Promise<?>,? extends R>> mapper)
<R> Promise<R>	PromiseImpl.flatMap(Function1<? super T,? extends Kind<Promise<?>,? extends R>> mapper)
<U> Future<U>	Future.fold(Function1<? super Throwable,? extends U> failureMapper, Function1<? super T,? extends U> successMapper)
<U> Future<U>	FutureImpl.fold(Function1<? super Throwable,? extends U> failureMapper, Function1<? super T,? extends U> successMapper)
<R> Future<R>	Future.map(Function1<? super T,? extends R> mapper)
<R> Future<R>	FutureImpl.map(Function1<? super T,? extends R> mapper)
<R> Promise<R>	Promise.map(Function1<? super T,? extends R> mapper)
<R> Promise<R>	PromiseImpl.map(Function1<? super T,? extends R> mapper)
Future<T>	Future.mapError(Function1<? super Throwable,? extends Throwable> mapper)
Future<T>	FutureImpl.mapError(Function1<? super Throwable,? extends Throwable> mapper)
default Future<T>	Future.recover(Function1<? super Throwable,? extends T> mapper)
<X extends Throwable> Future<T>	Future.recoverWith(Class<X> type, Function1<? super X,? extends T> mapper)
<X extends Throwable> Future<T>	FutureImpl.recoverWith(Class<X> type, Function1<? super X,? extends T> mapper)
private <R> Future<R>	FutureImpl.transform(Function1<? super Try<? extends T>,? extends Try<? extends R>> mapper)

Method parameters in com.github.tonivade.purefun.concurrent with type arguments of type Function1

Modifier and Type	Method	Description
<R> Future<R>	Future.ap(Future<Function1<? super T,? extends R>> apply)
<R> Future<R>	FutureImpl.ap(Future<Function1<? super T,? extends R>> apply)
<R> Promise<R>	Promise.ap(Kind<Promise<?>,? extends Function1<? super T,? extends R>> apply)
<R> Promise<R>	PromiseImpl.ap(Kind<Promise<?>,? extends Function1<? super T,? extends R>> apply)

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

Subinterfaces of Function1 in com.github.tonivade.purefun.core

Modifier and Type	Interface	Description
interface	Operator1<T>

Classes in com.github.tonivade.purefun.core that implement Function1

Modifier and Type	Class	Description
(package private) final class	MemoizedFunction<T,R>

Fields in com.github.tonivade.purefun.core declared as Function1

Modifier and Type	Field	Description
private final Function1<? super T,? extends R>	MemoizedFunction.function
private final Function1<Unit,? extends T>	MemoizedProducer.function

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

Modifier and Type	Method	Description
default <B> Function1<A,B>	Function1.andThen(Function1<? super R,? extends B> after)
static <A, T> Function1<Tuple1<A>,T>	Tuple.applyTo(Function1<? super A,? extends T> function)
static <A, B, T> Function1<Tuple2<A,B>,T>	Tuple.applyTo(Function2<? super A,? super B,? extends T> function)
static <A, B, C, T> Function1<Tuple3<A,B,C>,T>	Tuple.applyTo(Function3<? super A,? super B,? super C,? extends T> function)
static <A, B, C, D, T> Function1<Tuple4<A,B,C,D>,T>	Tuple.applyTo(Function4<? super A,? super B,? super C,? super D,? extends T> function)
static <A, B, C, D, E, T> Function1<Tuple5<A,B,C,D,E>,T>	Tuple.applyTo(Function5<? super A,? super B,? super C,? super D,? super E,? extends T> function)
default Function1<A,Unit>	Consumer1.asFunction()
default Function1<A,Boolean>	Matcher1.asFunction()
default <V> Function1<V,T>	Producer.asFunction()
default <B> Function1<B,R>	Function1.compose(Function1<? super B,? extends A> before)
default <C> Function1<C,R>	Function2.compose(Function1<? super C,? extends A> beforeT, Function1<? super C,? extends B> beforeV)
default <D> Function1<D,R>	Function3.compose(Function1<? super D,? extends A> beforeT1, Function1<? super D,? extends B> beforeT2, Function1<? super D,? extends C> beforeT3)
default <E> Function1<E,R>	Function4.compose(Function1<? super E,? extends A> beforeT1, Function1<? super E,? extends B> beforeT2, Function1<? super E,? extends C> beforeT3, Function1<? super E,? extends D> beforeT4)
default <F> Function1<F,R>	Function5.compose(Function1<? super F,? extends A> beforeT1, Function1<? super F,? extends B> beforeT2, Function1<? super F,? extends C> beforeT3, Function1<? super F,? extends D> beforeT4, Function1<? super F,? extends E> beforeT5)
default <B> Function1<B,R>	PartialFunction1.compose(Function1<? super B,? extends A> before)
static <A, T> Function1<A,T>	Function1.cons(Producer<? extends T> cons)
static <A, T> Function1<A,T>	Function1.cons(T cons)
default Function1<A,Function1<B,R>>	Function2.curried()
default Function1<A,Function1<B,Function1<C,R>>>	Function3.curried()
default Function1<A,Function1<B,Function1<C,Function1<D,R>>>>	Function4.curried()
default Function1<A,Function1<B,Function1<C,Function1<D,Function1<E,R>>>>>	Function5.curried()
default <B, Z> Function1<B,Z>	Function1.dimap(Function1<? super B,? extends A> before, Function1<? super R,? extends Z> after)
static <X extends Throwable, A, T> Function1<A,T>	Function1.fail(Producer<? extends X> supplier)
default <B> Function1<A,B>	Function1.flatMap(Function1<? super R,? extends Function1<? super A,? extends B>> after)
static <A> Function1<A,A>	Function1.identity()
static <E> Function1<Validation.Result<E>,String>	Validator.join()
static <E> Function1<Validation.Result<E>,String>	Validator.join(Producer<String> message)
static <E> Function1<Validation.Result<E>,String>	Validator.join(String separator)
static <E> Function1<Validation.Result<E>,String>	Validator.join(String separator, Producer<String> message)
default Function1<A,Option<R>>	PartialFunction1.lift()
default Function1<A,Either<Throwable,R>>	Function1.liftEither()
default Function1<A,Future<R>>	Function1.liftFuture()
default Function1<A,Id<R>>	Function1.liftId()
default <L> Function1<A,Either<R,L>>	Function1.liftLeft()
default Function1<A,Option<R>>	Function1.liftOption()
default Function1<A,Optional<R>>	Function1.liftOptional()
default <L> Function1<A,Either<L,R>>	Function1.liftRight()
default Function1<A,Try<R>>	Function1.liftTry()
default Function1<A,R>	Function1.memoized()
Function1<T,R>	MemoizedFunction.memoized()
static <A, R> Function1<A,R>	Function1.of(Function1<? super A,? extends R> reference)
default Function1<A,A>	Consumer1.peek()
default Function1<A,Sequence<R>>	Function1.sequence()
default Function1<A,Stream<R>>	Function1.stream()
static <A, R> Function1<A,R>	Function1Of.toFunction1(Kind<Function1<A,?>,? extends R> value)
default Function1<Tuple2<A,B>,R>	Function2.tupled()
default Function1<Tuple3<A,B,C>,R>	Function3.tupled()
default Function1<Tuple4<A,B,C,D>,R>	Function4.tupled()
default Function1<Tuple5<A,B,C,D,E>,R>	Function5.tupled()

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

Modifier and Type	Method	Description
default Function1<A,Function1<B,R>>	Function2.curried()
default Function1<A,Function1<B,Function1<C,R>>>	Function3.curried()
default Function1<A,Function1<B,Function1<C,R>>>	Function3.curried()
default Function1<A,Function1<B,Function1<C,Function1<D,R>>>>	Function4.curried()
default Function1<A,Function1<B,Function1<C,Function1<D,R>>>>	Function4.curried()
default Function1<A,Function1<B,Function1<C,Function1<D,R>>>>	Function4.curried()
default Function1<A,Function1<B,Function1<C,Function1<D,Function1<E,R>>>>>	Function5.curried()
default Function1<A,Function1<B,Function1<C,Function1<D,Function1<E,R>>>>>	Function5.curried()
default Function1<A,Function1<B,Function1<C,Function1<D,Function1<E,R>>>>>	Function5.curried()
default Function1<A,Function1<B,Function1<C,Function1<D,Function1<E,R>>>>>	Function5.curried()

Methods in com.github.tonivade.purefun.core with parameters of type Function1

Modifier and Type	Method	Description
default <B> Function1<A,B>	Function1.andThen(Function1<? super R,? extends B> after)
default <C> Function2<A,B,C>	Function2.andThen(Function1<? super R,? extends C> after)
default <D> Function3<A,B,C,D>	Function3.andThen(Function1<? super R,? extends D> after)
default <E> Function4<A,B,C,D,E>	Function4.andThen(Function1<? super R,? extends E> after)
default <F> Function5<A,B,C,D,E,F>	Function5.andThen(Function1<? super R,? extends F> after)
default <B> PartialFunction1<A,B>	PartialFunction1.andThen(Function1<? super R,? extends B> after)
default <R> Producer<R>	Producer.andThen(Function1<? super T,? extends R> after)
default R	PartialFunction1.applyOrElse(A value, Function1<? super A,? extends R> orElse)
static <A, T> Function1<Tuple1<A>,T>	Tuple.applyTo(Function1<? super A,? extends T> function)
<R> R	Tuple1.applyTo(Function1<? super A,? extends R> function)
static <E, F, T> Validator<F,T>	Validator.combine(Validator<E,T> v1, Validator<E,T> v2, Function1<Validation.Result<E>,F> reduce)
static <E, F, T> Validator<F,T>	Validator.combine(Validator<E,T> v1, Validator<E,T> v2, Validator<E,T> v3, Function1<Validation.Result<E>,F> reduce)
static <E, F, T> Validator<F,T>	Validator.combine(Validator<E,T> v1, Validator<E,T> v2, Validator<E,T> v3, Validator<E,T> v4, Function1<Validation.Result<E>,F> reduce)
static <E, F, T> Validator<F,T>	Validator.combine(Validator<E,T> v1, Validator<E,T> v2, Validator<E,T> v3, Validator<E,T> v4, Validator<E,T> v5, Function1<Validation.Result<E>,F> reduce)
static <T, V> Eq<T>	Eq.comparing(Function1<? super T,? extends V> getter)
<V> Equal<T>	Equal.comparing(Function1<T,V> getter)
static <T, V> Eq<T>	Eq.comparingArray(Function1<? super T,? extends V[]> getter)
<V> Equal<T>	Equal.comparingArray(Function1<T,V[]> getter)
default <B> Function1<B,R>	Function1.compose(Function1<? super B,? extends A> before)
default <C> Function1<C,R>	Function2.compose(Function1<? super C,? extends A> beforeT, Function1<? super C,? extends B> beforeV)
default <D> Function1<D,R>	Function3.compose(Function1<? super D,? extends A> beforeT1, Function1<? super D,? extends B> beforeT2, Function1<? super D,? extends C> beforeT3)
default <E> Function1<E,R>	Function4.compose(Function1<? super E,? extends A> beforeT1, Function1<? super E,? extends B> beforeT2, Function1<? super E,? extends C> beforeT3, Function1<? super E,? extends D> beforeT4)
default <F> Function1<F,R>	Function5.compose(Function1<? super F,? extends A> beforeT1, Function1<? super F,? extends B> beforeT2, Function1<? super F,? extends C> beforeT3, Function1<? super F,? extends D> beforeT4, Function1<? super F,? extends E> beforeT5)
default <B> Function1<B,R>	PartialFunction1.compose(Function1<? super B,? extends A> before)
default <R> Validator<E,R>	Validator.compose(Function1<? super R,? extends T> getter)
default <B, Z> Function1<B,Z>	Function1.dimap(Function1<? super B,? extends A> before, Function1<? super R,? extends Z> after)
<R> Bindable<F,R>	Bindable.flatMap(Function1<? super A,? extends Kind<F,? extends R>> mapper)
<R> Effect<F,R>	Effect.flatMap(Function1<? super A,? extends Kind<F,? extends R>> mapper)
default <B> Function1<A,B>	Function1.flatMap(Function1<? super R,? extends Function1<? super A,? extends B>> after)
default <R> Producer<R>	Producer.flatMap(Function1<? super T,? extends Producer<? extends R>> after)
default <R> Trampoline<R>	Trampoline.flatMap(Function1<? super T,? extends Kind<Trampoline<?>,? extends R>> map)
default <R> R	Trampoline.fold(Function1<Trampoline<T>,R> more, Function1<T,R> done)
<R> Applicable<F,R>	Applicable.map(Function1<? super A,? extends R> mapper)
<R> Bindable<F,R>	Bindable.map(Function1<? super A,? extends R> mapper)
<R> Effect<F,R>	Effect.map(Function1<? super A,? extends R> mapper)
<R> Mappable<F,R>	Mappable.map(Function1<? super A,? extends R> mapper)
default <R> Producer<R>	Producer.map(Function1<? super T,? extends R> after)
default <R> Trampoline<R>	Trampoline.map(Function1<? super T,? extends R> map)
<C, D> Tuple2<C,D>	Tuple2.map(Function1<? super A,? extends C> mapper1, Function1<? super B,? extends D> mapper2)
<D, E, F> Tuple3<D,E,F>	Tuple3.map(Function1<? super A,? extends D> map1, Function1<? super B,? extends E> map2, Function1<? super C,? extends F> map3)
<E, F, G, H> Tuple4<E,F,G,H>	Tuple4.map(Function1<? super A,? extends E> map1, Function1<? super B,? extends F> map2, Function1<? super C,? extends G> map3, Function1<? super D,? extends H> map4)
<F, G, H, I, J> Tuple5<F,G,H,I,J>	Tuple5.map(Function1<? super A,? extends F> map1, Function1<? super B,? extends G> map2, Function1<? super C,? extends H> map3, Function1<? super D,? extends I> map4, Function1<? super E,? extends J> map5)
<B> Tuple1<B>	Tuple1.map1(Function1<? super A,? extends B> mapper)
<C> Tuple2<C,B>	Tuple2.map1(Function1<? super A,? extends C> mapper)
<R> Tuple3<R,B,C>	Tuple3.map1(Function1<? super A,? extends R> mapper)
<R> Tuple4<R,B,C,D>	Tuple4.map1(Function1<? super A,? extends R> mapper)
<R> Tuple5<R,B,C,D,E>	Tuple5.map1(Function1<? super A,? extends R> mapper)
<C> Tuple2<A,C>	Tuple2.map2(Function1<? super B,? extends C> mapper)
<R> Tuple3<A,R,C>	Tuple3.map2(Function1<? super B,? extends R> mapper)
<R> Tuple4<A,R,C,D>	Tuple4.map2(Function1<? super B,? extends R> mapper)
<R> Tuple5<A,R,C,D,E>	Tuple5.map2(Function1<? super B,? extends R> mapper)
<R> Tuple3<A,B,R>	Tuple3.map3(Function1<? super C,? extends R> mapper)
<R> Tuple4<A,B,R,D>	Tuple4.map3(Function1<? super C,? extends R> mapper)
<R> Tuple5<A,B,R,D,E>	Tuple5.map3(Function1<? super C,? extends R> mapper)
<R> Tuple4<A,B,C,R>	Tuple4.map4(Function1<? super D,? extends R> mapper)
<R> Tuple5<A,B,C,R,E>	Tuple5.map4(Function1<? super D,? extends R> mapper)
<R> Tuple5<A,B,C,D,R>	Tuple5.map5(Function1<? super E,? extends R> mapper)
default <F> Validator<F,T>	Validator.mapError(Function1<? super E,? extends F> mapper)
static <A, R> Function1<A,R>	Function1.of(Function1<? super A,? extends R> reference)
static <A, R> PartialFunction1<A,R>	PartialFunction1.of(Matcher1<? super A> isDefined, Function1<? super A,? extends R> apply)
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)
static <E, F, A, B, C> Validator<F,Tuple3<A,B,C>>	Validator.product(Validator<E,A> v1, Validator<E,B> v2, Validator<E,C> v3, Function1<Validation.Result<E>,F> reduce)
static <E, F, A, B, C, D> Validator<F,Tuple4<A,B,C,D>>	Validator.product(Validator<E,A> v1, Validator<E,B> v2, Validator<E,C> v3, Validator<E,D> v4, Function1<Validation.Result<E>,F> reduce)
static <F, G, A, B, C, D, E> Validator<G,Tuple5<A,B,C,D,E>>	Validator.product(Validator<F,A> v1, Validator<F,B> v2, Validator<F,C> v3, Validator<F,D> v4, Validator<F,E> v5, Function1<Validation.Result<F>,G> reduce)
static <A, B, R> Function2<A,B,R>	Function2.uncurried(Function1<? super A,? extends Function1<? super B,? extends R>> function)

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

Modifier and Type	Method	Description
<R> Applicable<F,R>	Applicable.ap(Kind<F,? extends Function1<? super A,? extends R>> apply)
<R> Effect<F,R>	Effect.ap(Kind<F,? extends Function1<? super A,? extends R>> apply)
default <B> Function1<A,B>	Function1.flatMap(Function1<? super R,? extends Function1<? super A,? extends B>> after)
static <A, R> Function1<A,R>	Function1Of.toFunction1(Kind<Function1<A,?>,? extends R> value)
static <A, B, R> Function2<A,B,R>	Function2.uncurried(Function1<? super A,? extends Function1<? super B,? extends R>> function)

Constructors in com.github.tonivade.purefun.core with parameters of type Function1

Modifier	Constructor	Description
(package private)	MemoizedFunction(Function1<? super T,? extends R> function)

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

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

Modifier and Type	Method	Description
default <A, B> ImmutableMap<A,B>	ImmutableMap.bimap(Function1<? super K,? extends A> keyMapper, Function1<? super V,? extends B> valueMapper)
default <A, B> ImmutableTreeMap<A,B>	ImmutableTreeMap.bimap(Function1<? super K,? extends A> keyMapper, Function1<? super V,? extends B> valueMapper)
default <A, B> ImmutableTreeMap<A,B>	ImmutableTreeMap.bimap(Comparator<? super A> comparator, Function1<? super K,? extends A> keyMapper, Function1<? super V,? extends B> valueMapper)
default <R> ImmutableArray<R>	ImmutableArray.flatMap(Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)
default <R> ImmutableList<R>	ImmutableList.flatMap(Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)
default <R> ImmutableSet<R>	ImmutableSet.flatMap(Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)
default <R> ImmutableTree<R>	ImmutableTree.flatMap(Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)
default <R> ImmutableTree<R>	ImmutableTree.flatMap(Comparator<? super R> comparator, Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)
<R> NonEmptyList<R>	NonEmptyList.flatMap(Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)
<R> Sequence<R>	Sequence.flatMap(Function1<? super E,? extends Kind<Sequence<?>,? extends R>> mapper)
default <G> ImmutableMap<G,ImmutableList<E>>	Sequence.groupBy(Function1<? super E,? extends G> selector)
default <R> ImmutableArray<R>	ImmutableArray.map(Function1<? super E,? extends R> mapper)
default <R> ImmutableList<R>	ImmutableList.map(Function1<? super E,? extends R> mapper)
default <R> ImmutableSet<R>	ImmutableSet.map(Function1<? super E,? extends R> mapper)
default <R> ImmutableTree<R>	ImmutableTree.map(Function1<? super E,? extends R> mapper)
default <R> ImmutableTree<R>	ImmutableTree.map(Comparator<? super R> comparator, Function1<? super E,? extends R> mapper)
<R> NonEmptyList<R>	NonEmptyList.map(Function1<? super E,? extends R> mapper)
<T> ImmutableArray<T>	Range.map(Function1<? super Integer,? extends T> map)
<R> Sequence<R>	Sequence.map(Function1<? super E,? extends R> mapper)
default <A> ImmutableMap<A,V>	ImmutableMap.mapKeys(Function1<? super K,? extends A> mapper)
default <A> ImmutableTreeMap<A,V>	ImmutableTreeMap.mapKeys(Function1<? super K,? extends A> mapper)
default <A> ImmutableTreeMap<A,V>	ImmutableTreeMap.mapKeys(Comparator<? super A> comparator, Function1<? super K,? extends A> mapper)
default <A> ImmutableMap<K,A>	ImmutableMap.mapValues(Function1<? super V,? extends A> mapper)
default <A> ImmutableTreeMap<K,A>	ImmutableTreeMap.mapValues(Function1<? super V,? extends A> mapper)
default E[]	Sequence.toArray(Function1<Integer,E[]> supplier)
static <T, K, V> Collector<T,?,ImmutableMap<K,V>>	ImmutableMap.toImmutableMap(Function1<? super T,? extends K> keyMapper, Function1<? super T,? extends V> valueMapper)
static <T, K, V> Collector<T,?,ImmutableTreeMap<K,V>>	ImmutableTreeMap.toImmutableTreeMap(Function1<? super T,? extends K> keyMapper, Function1<? super T,? extends V> valueMapper)
static <T, K, V> Collector<T,?,ImmutableTreeMap<K,V>>	ImmutableTreeMap.toImmutableTreeMap(Comparator<? super K> comparator, Function1<? super T,? extends K> keyMapper, Function1<? super T,? extends V> valueMapper)
private static <T, K, V> Collector<T,?,? extends LinkedHashMap<K,V>>	ImmutableMap.toLinkedHashMap(Function1<? super T,? extends K> keyMapper, Function1<? super T,? extends V> valueMapper)
private static <T, K, V> Collector<T,?,? extends TreeMap<K,V>>	ImmutableTreeMap.toTreeMap(Comparator<? super K> comparator, Function1<? super T,? extends K> keyMapper, Function1<? super T,? extends V> valueMapper)
<T> T	NonEmptyString.transform(Function1<String,T> mapper)

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

Fields in com.github.tonivade.purefun.effect declared as Function1

Modifier and Type	Field	Description
private final Function1<? super R,? extends Kind<PureIO<R,E,?>,? extends A>>	PureIO.AccessM.function
private final Function1<? super A,? extends Kind<PureIO<R,F,?>,? extends B>>	PureIO.FlatMapped.next
private final Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends B>>	PureIO.FlatMapped.nextError

Methods in com.github.tonivade.purefun.effect that return Function1

Modifier and Type	Method	Description
static <A, B> Function1<A,EIO<Throwable,B>>	EIO.lift(Function1<? super A,? extends B> function)
static <R, A, B> Function1<A,PureIO<R,Throwable,B>>	PureIO.lift(Function1<? super A,? extends B> function)
static <R, A, B> Function1<A,RIO<R,B>>	RIO.lift(Function1<? super A,? extends B> function)
static <A, B> Function1<A,Task<B>>	Task.lift(Function1<? super A,? extends B> function)
static <A, B> Function1<A,UIO<B>>	UIO.lift(Function1<? super A,? extends B> function)
static <R, A, B> Function1<A,URIO<R,B>>	URIO.lift(Function1<? super A,? extends B> function)
static <E, A, B> Function1<A,EIO<E,B>>	EIO.liftEither(Function1<? super A,? extends Either<E,? extends B>> function)
static <R, E, A, B> Function1<A,PureIO<R,E,B>>	PureIO.liftEither(Function1<? super A,? extends Either<E,? extends B>> function)
static <R, A, B> Function1<A,RIO<R,B>>	RIO.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <A, B> Function1<A,Task<B>>	Task.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <A, B> Function1<A,UIO<B>>	UIO.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <R, A, B> Function1<A,URIO<R,B>>	URIO.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <A, B> Function1<A,EIO<Throwable,B>>	EIO.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <R, A, B> Function1<A,PureIO<R,Throwable,B>>	PureIO.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <R, A, B> Function1<A,RIO<R,B>>	RIO.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <A, B> Function1<A,Task<B>>	Task.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <A, B> Function1<A,UIO<B>>	UIO.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <R, A, B> Function1<A,URIO<R,B>>	URIO.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <A, B> Function1<A,EIO<Throwable,B>>	EIO.liftTry(Function1<? super A,? extends Try<? extends B>> function)
static <R, A, B> Function1<A,PureIO<R,Throwable,B>>	PureIO.liftTry(Function1<? super A,? extends Try<? extends B>> function)
static <R, A, B> Function1<A,RIO<R,B>>	RIO.liftTry(Function1<? super A,? extends Try<? extends B>> function)
static <A, B> Function1<A,Task<B>>	Task.liftTry(Function1<? super A,? extends Try<? extends B>> function)
static <A, B> Function1<A,UIO<B>>	UIO.liftTry(Function1<? super A,? extends Try<? extends B>> function)
static <R, A, B> Function1<A,URIO<R,B>>	URIO.liftTry(Function1<? super A,? extends Try<? extends B>> function)

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

Modifier and Type	Method	Description
static <A, T> UIO<Function1<A,UIO<T>>>	UIO.memoize(Function1<A,UIO<T>> function)
static <A, T> UIO<Function1<A,UIO<T>>>	UIO.memoize(Executor executor, Function1<A,UIO<T>> function)

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

Modifier and Type	Method	Description
static <R, E, A> PureIO<R,E,A>	PureIO.access(Function1<? super R,? extends A> map)
static <R, A> RIO<R,A>	RIO.access(Function1<? super R,? extends A> map)
static <R, A> URIO<R,A>	URIO.access(Function1<? super R,? extends A> map)
static <R, E, A> PureIO<R,E,A>	PureIO.accessM(Function1<? super R,? extends Kind<PureIO<R,E,?>,? extends A>> map)
static <R, A> RIO<R,A>	RIO.accessM(Function1<? super R,? extends Kind<RIO<R,?>,? extends A>> map)
static <R, A> URIO<R,A>	URIO.accessM(Function1<? super R,? extends Kind<URIO<R,?>,? extends A>> map)
static <A> Task<A>	Task.asyncF(Function1<Consumer1<? super Try<? extends A>>,Task<Unit>> consumer)
<B, F> EIO<F,B>	EIO.bimap(Function1<? super E,? extends F> mapError, Function1<? super A,? extends B> map)
default <B, F> PureIO<R,F,B>	PureIO.bimap(Function1<? super E,? extends F> mapError, Function1<? super A,? extends B> map)
static <E, A extends AutoCloseable, B> EIO<E,B>	EIO.bracket(Kind<EIO<E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> use)
static <E, A, B> EIO<E,B>	EIO.bracket(Kind<EIO<E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> use, Consumer1<? super A> release)
static <E, A, B> EIO<E,B>	EIO.bracket(Kind<EIO<E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> use, Function1<? super A,? extends Kind<EIO<E,?>,Unit>> release)
static <R, E, A extends AutoCloseable, B> PureIO<R,E,B>	PureIO.bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use)
static <R, E, A, B> PureIO<R,E,B>	PureIO.bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use, Consumer1<? super A> release)
static <R, E, A, B> PureIO<R,E,B>	PureIO.bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use, Function1<? super A,? extends Kind<PureIO<R,E,?>,Unit>> release)
static <R, A extends AutoCloseable, B> RIO<R,B>	RIO.bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use)
static <R, A, B> RIO<R,B>	RIO.bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use, Consumer1<? super A> release)
static <R, A, B> RIO<R,B>	RIO.bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use, Function1<? super A,? extends Kind<RIO<R,?>,Unit>> release)
static <A extends AutoCloseable, B> Task<B>	Task.bracket(Kind<Task<?>,? extends A> acquire, Function1<? super A,? extends Kind<Task<?>,? extends B>> use)
static <A, B> Task<B>	Task.bracket(Kind<Task<?>,? extends A> acquire, Function1<? super A,? extends Kind<Task<?>,? extends B>> use, Consumer1<? super A> release)
static <A, B> Task<B>	Task.bracket(Kind<Task<?>,? extends A> acquire, Function1<? super A,? extends Kind<Task<?>,? extends B>> use, Function1<? super A,? extends Kind<Task<?>,Unit>> release)
static <A extends AutoCloseable, B> UIO<B>	UIO.bracket(Kind<UIO<?>,? extends A> acquire, Function1<? super A,? extends Kind<UIO<?>,? extends B>> use)
static <A, B> UIO<B>	UIO.bracket(Kind<UIO<?>,? extends A> acquire, Function1<? super A,? extends Kind<UIO<?>,? extends B>> use, Consumer1<? super A> release)
static <A, B> UIO<B>	UIO.bracket(Kind<UIO<?>,? extends A> acquire, Function1<? super A,? extends Kind<UIO<?>,? extends B>> use, Function1<? super A,? extends Kind<UIO<?>,Unit>> release)
static <R, A extends AutoCloseable, B> URIO<R,B>	URIO.bracket(Kind<URIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> use)
static <R, A, B> URIO<R,B>	URIO.bracket(Kind<URIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> use, Consumer1<? super A> release)
static <R, A, B> URIO<R,B>	URIO.bracket(Kind<URIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> use, Function1<? super A,? extends Kind<URIO<R,?>,Unit>> release)
static <E, A> EIO<E,A>	EIO.cancellable(Function1<Consumer1<? super Try<? extends Either<E,? extends A>>>,EIO<E,Unit>> consumer)
static <A> UIO<A>	UIO.cancellable(Function1<Consumer1<? super Try<? extends A>>,UIO<Unit>> consumer)
<B> EIO<E,B>	EIO.flatMap(Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> map)
<B> Managed<R,E,B>	Managed.flatMap(Function1<? super A,? extends Kind<Managed<R,E,?>,? extends B>> mapper)
default <B> PureIO<R,E,B>	PureIO.flatMap(Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> map)
<B> RIO<R,B>	RIO.flatMap(Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> map)
<B> Task<B>	Task.flatMap(Function1<? super A,? extends Kind<Task<?>,? extends B>> map)
<B> UIO<B>	UIO.flatMap(Function1<? super A,? extends Kind<UIO<?>,? extends B>> map)
<B> URIO<R,B>	URIO.flatMap(Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> map)
<F> EIO<F,A>	EIO.flatMapError(Function1<? super E,? extends Kind<EIO<F,?>,? extends A>> map)
<F> Managed<R,F,A>	Managed.flatMapError(Function1<? super E,? extends Kind<Managed<R,F,?>,? extends A>> mapper)
default <F> PureIO<R,F,A>	PureIO.flatMapError(Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends A>> map)
<B> UIO<B>	EIO.fold(Function1<? super E,? extends B> mapError, Function1<? super A,? extends B> map)
<B> Managed<R,Void,B>	Managed.fold(Function1<? super E,? extends B> mapError, Function1<? super A,? extends B> mapper)
default <B> URIO<R,B>	PureIO.fold(Function1<? super E,? extends B> mapError, Function1<? super A,? extends B> map)
<B> URIO<R,B>	RIO.fold(Function1<? super Throwable,? extends B> mapError, Function1<? super A,? extends B> map)
<B> UIO<B>	Task.fold(Function1<? super Throwable,? extends B> mapError, Function1<? super A,? extends B> map)
<B, F> EIO<F,B>	EIO.foldM(Function1<? super E,? extends Kind<EIO<F,?>,? extends B>> mapError, Function1<? super A,? extends Kind<EIO<F,?>,? extends B>> map)
<F, B> Managed<R,F,B>	Managed.foldM(Function1<? super E,? extends Kind<Managed<R,F,?>,? extends B>> mapError, Function1<? super A,? extends Kind<Managed<R,F,?>,? extends B>> mapper)
default <F, B> PureIO<R,F,B>	PureIO.foldM(Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends B>> left, Function1<? super A,? extends Kind<PureIO<R,F,?>,? extends B>> right)
<B> RIO<R,B>	RIO.foldM(Function1<? super Throwable,? extends Kind<RIO<R,?>,? extends B>> mapError, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> map)
<B> Task<B>	Task.foldM(Function1<? super Throwable,? extends Kind<Task<?>,? extends B>> mapError, Function1<? super A,? extends Kind<Task<?>,? extends B>> map)
static <R, E, A extends AutoCloseable> Managed<R,E,A>	Managed.from(Function1<? super R,? extends A> mapper)
static <R, E, A> Managed<R,E,A>	Managed.from(Function1<? super R,? extends A> mapper, Consumer1<? super A> release)
static <R, E, A extends AutoCloseable> Managed<R,E,A>	Managed.fromM(Function1<? super R,? extends PureIO<R,E,? extends A>> mapper)
static <R, E, A> Managed<R,E,A>	Managed.fromM(Function1<? super R,? extends PureIO<R,E,? extends A>> mapper, Consumer1<? super A> release)
static <A, B> Function1<A,EIO<Throwable,B>>	EIO.lift(Function1<? super A,? extends B> function)
static <R, A, B> Function1<A,PureIO<R,Throwable,B>>	PureIO.lift(Function1<? super A,? extends B> function)
static <R, A, B> Function1<A,RIO<R,B>>	RIO.lift(Function1<? super A,? extends B> function)
static <A, B> Function1<A,Task<B>>	Task.lift(Function1<? super A,? extends B> function)
static <A, B> Function1<A,UIO<B>>	UIO.lift(Function1<? super A,? extends B> function)
static <R, A, B> Function1<A,URIO<R,B>>	URIO.lift(Function1<? super A,? extends B> function)
static <E, A, B> Function1<A,EIO<E,B>>	EIO.liftEither(Function1<? super A,? extends Either<E,? extends B>> function)
static <R, E, A, B> Function1<A,PureIO<R,E,B>>	PureIO.liftEither(Function1<? super A,? extends Either<E,? extends B>> function)
static <R, A, B> Function1<A,RIO<R,B>>	RIO.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <A, B> Function1<A,Task<B>>	Task.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <A, B> Function1<A,UIO<B>>	UIO.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <R, A, B> Function1<A,URIO<R,B>>	URIO.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <A, B> Function1<A,EIO<Throwable,B>>	EIO.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <R, A, B> Function1<A,PureIO<R,Throwable,B>>	PureIO.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <R, A, B> Function1<A,RIO<R,B>>	RIO.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <A, B> Function1<A,Task<B>>	Task.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <A, B> Function1<A,UIO<B>>	UIO.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <R, A, B> Function1<A,URIO<R,B>>	URIO.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <A, B> Function1<A,EIO<Throwable,B>>	EIO.liftTry(Function1<? super A,? extends Try<? extends B>> function)
static <R, A, B> Function1<A,PureIO<R,Throwable,B>>	PureIO.liftTry(Function1<? super A,? extends Try<? extends B>> function)
static <R, A, B> Function1<A,RIO<R,B>>	RIO.liftTry(Function1<? super A,? extends Try<? extends B>> function)
static <A, B> Function1<A,Task<B>>	Task.liftTry(Function1<? super A,? extends Try<? extends B>> function)
static <A, B> Function1<A,UIO<B>>	UIO.liftTry(Function1<? super A,? extends Try<? extends B>> function)
static <R, A, B> Function1<A,URIO<R,B>>	URIO.liftTry(Function1<? super A,? extends Try<? extends B>> function)
<B> EIO<E,B>	EIO.map(Function1<? super A,? extends B> map)
<B> Managed<R,E,B>	Managed.map(Function1<? super A,? extends B> mapper)
default <B> PureIO<R,E,B>	PureIO.map(Function1<? super A,? extends B> map)
<B> RIO<R,B>	RIO.map(Function1<? super A,? extends B> map)
<B> Task<B>	Task.map(Function1<? super A,? extends B> map)
<B> UIO<B>	UIO.map(Function1<? super A,? extends B> map)
<B> URIO<R,B>	URIO.map(Function1<? super A,? extends B> map)
<B> EIO<B,A>	EIO.mapError(Function1<? super E,? extends B> map)
<F> Managed<R,F,A>	Managed.mapError(Function1<? super E,? extends F> mapper)
default <B> PureIO<R,B,A>	PureIO.mapError(Function1<? super E,? extends B> map)
static <A, T> UIO<Function1<A,UIO<T>>>	UIO.memoize(Function1<A,UIO<T>> function)
static <A, T> UIO<Function1<A,UIO<T>>>	UIO.memoize(Executor executor, Function1<A,UIO<T>> function)
<B> UIO<B>	Ref.modify(Function1<A,Tuple2<B,A>> change)
UIO<A>	EIO.recover(Function1<? super E,? extends A> mapError)
Managed<R,Void,A>	Managed.recover(Function1<? super E,? extends A> mapError)
default URIO<R,A>	PureIO.recover(Function1<? super E,? extends A> mapError)
URIO<R,A>	RIO.recover(Function1<? super Throwable,? extends A> mapError)
UIO<A>	Task.recover(Function1<? super Throwable,? extends A> mapError)
UIO<A>	UIO.recover(Function1<? super Throwable,? extends A> mapError)
URIO<R,A>	URIO.recover(Function1<? super Throwable,? extends A> mapError)
<X extends Throwable> URIO<R,A>	RIO.recoverWith(Class<X> type, Function1<? super X,? extends A> function)
<X extends Throwable> UIO<A>	Task.recoverWith(Class<X> type, Function1<? super X,? extends A> function)
<X extends Throwable> UIO<A>	UIO.recoverWith(Class<X> type, Function1<? super X,? extends A> function)
<X extends Throwable> URIO<R,A>	URIO.recoverWith(Class<X> type, Function1<? super X,? extends A> function)
<B> UIO<B>	UIO.redeem(Function1<? super Throwable,? extends B> mapError, Function1<? super A,? extends B> map)
<B> URIO<R,B>	URIO.redeem(Function1<? super Throwable,? extends B> mapError, Function1<? super A,? extends B> map)
<B> UIO<B>	UIO.redeemWith(Function1<? super Throwable,? extends Kind<UIO<?>,? extends B>> mapError, Function1<? super A,? extends Kind<UIO<?>,? extends B>> map)
<B> URIO<R,B>	URIO.redeemWith(Function1<? super Throwable,? extends Kind<URIO<R,?>,? extends B>> mapError, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> map)
private static <R, E, F, A, B> Kind<PureIO<R,E,?>,A>	PureIO.unwrap(R env, Kind<PureIO<R,E,?>,A> current, CallStack<R,F,B> stack, Function1<Kind<PureIO<R,E,?>,? extends A>,Kind<PureIO<R,F,?>,? extends B>> next)
<B> PureIO<R,E,B>	Managed.use(Function1<? super A,? extends PureIO<R,E,? extends B>> use)

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

Modifier and Type	Method	Description
<B> EIO<E,B>	EIO.ap(Kind<EIO<E,?>,? extends Function1<? super A,? extends B>> apply)
default <B> PureIO<R,E,B>	PureIO.ap(Kind<PureIO<R,E,?>,? extends Function1<? super A,? extends B>> apply)
<B> RIO<R,B>	RIO.ap(Kind<RIO<R,?>,? extends Function1<? super A,? extends B>> apply)
<B> Task<B>	Task.ap(Kind<Task<?>,? extends Function1<? super A,? extends B>> apply)
<B> UIO<B>	UIO.ap(Kind<UIO<?>,? extends Function1<? super A,? extends B>> apply)
<B> URIO<R,B>	URIO.ap(Kind<URIO<R,?>,? extends Function1<? super A,? extends B>> apply)

Constructors in com.github.tonivade.purefun.effect with parameters of type Function1

Modifier	Constructor	Description
private	AccessM(Function1<? super R,? extends Kind<PureIO<R,E,?>,? extends A>> function)
private	FlatMapped(PureIO<R,E,A> current, Function1<? super E,? extends Kind<PureIO<R,F,?>,? extends B>> nextError, Function1<? super A,? extends Kind<PureIO<R,F,?>,? extends B>> next)

Uses of Function1 in com.github.tonivade.purefun.free

Fields in com.github.tonivade.purefun.free declared as Function1

Modifier and Type	Field	Description
private final Function1<? super A,? extends Kind<Free<F,?>,? extends B>>	Free.FlatMapped.next	The field for the next record component.

Fields in com.github.tonivade.purefun.free with type parameters of type Function1

Modifier and Type	Field	Description
private final FreeAp<F,? extends Function1<? super A,? extends B>>	FreeAp.Apply.apply	The field for the apply record component.
private final Kind<G,Function1<A,B>>	FreeAp.CurriedFunction.value	The field for the value record component.

Methods in com.github.tonivade.purefun.free that return Function1

Modifier and Type	Method	Description
Function1<? super A,? extends Kind<Free<F,?>,? extends B>>	Free.FlatMapped.next()	Returns the value of the next record component.

Methods in com.github.tonivade.purefun.free that return types with arguments of type Function1

Modifier and Type	Method	Description
FreeAp<F,? extends Function1<? super A,? extends B>>	FreeAp.Apply.apply()	Returns the value of the apply record component.
Kind<G,Function1<A,B>>	FreeAp.CurriedFunction.value()	Returns the value of the value record component.

Methods in com.github.tonivade.purefun.free with parameters of type Function1

Modifier and Type	Method	Description
<R> EitherK<F,G,R>	EitherK.coflatMap(Comonad<F> comonadF, Comonad<G> comonadG, Function1<? super EitherK<F,G,? extends T>,? extends R> mapper)
<R> EitherK<F,G,R>	EitherK.contramap(Contravariant<F> contravariantF, Contravariant<G> contravariantG, Function1<? super R,? extends T> contramap)
<R> Free<F,R>	Free.flatMap(Function1<? super A,? extends Kind<Free<F,?>,? extends R>> mapper)
<C> Free<F,C>	Free.FlatMapped.flatMap(Function1<? super B,? extends Kind<Free<F,?>,? extends C>> map)
<B> Free<F,B>	Free.Pure.flatMap(Function1<? super A,? extends Kind<Free<F,?>,? extends B>> map)
<B> Free<F,B>	Free.Suspend.flatMap(Function1<? super A,? extends Kind<Free<F,?>,? extends B>> map)
default <T, R> Free<F,R>	FreeMonad.flatMap(Kind<Free<F,?>,? extends T> value, Function1<? super T,? extends Kind<Free<F,?>,? extends R>> map)
<R> EitherK<F,G,R>	EitherK.map(Functor<F> functorF, Functor<G> functorG, Function1<? super T,? extends R> mapper)
default <R> Free<F,R>	Free.map(Function1<? super A,? extends R> map)
default <B> FreeAp<F,B>	FreeAp.map(Function1<? super A,? extends B> mapper)

Method parameters in com.github.tonivade.purefun.free with type arguments of type Function1

Modifier and Type	Method	Description
default <B> FreeAp<F,B>	FreeAp.ap(Kind<FreeAp<F,?>,? extends Function1<? super A,? extends B>> apply)

Constructors in com.github.tonivade.purefun.free with parameters of type Function1

Modifier	Constructor	Description
	FlatMapped(Free<F,? extends A> value, Function1<? super A,? extends Kind<Free<F,?>,? extends B>> next)	Creates an instance of a FlatMapped record class.

Constructor parameters in com.github.tonivade.purefun.free with type arguments of type Function1

Modifier	Constructor	Description
	CurriedFunction(Kind<G,Function1<A,B>> value, int remaining)	Creates an instance of a CurriedFunction record class.

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

Methods in com.github.tonivade.purefun.instances that return Function1

Modifier and Type	Method	Description
default <A, R> Function1<T,R>	Function1Applicative.ap(Kind<Function1<T,?>,? extends A> value, Kind<Function1<T,?>,? extends Function1<? super A,? extends R>> apply)
default <A, R> Function1<T,R>	Function1Monad.flatMap(Kind<Function1<T,?>,? extends A> value, Function1<? super A,? extends Kind<Function1<T,?>,? extends R>> map)
default <A, R> Function1<T,R>	Function1Functor.map(Kind<Function1<T,?>,? extends A> value, Function1<? super A,? extends R> map)
default <A> Function1<T,A>	Function1Pure.pure(A value)

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

Modifier and Type	Method	Description
static <T> Applicative<Function1<T,?>>	Function1Instances.applicative()
static <T> Functor<Function1<T,?>>	Function1Instances.functor()
static <T> Monad<Function1<T,?>>	Function1Instances.monad()

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

Modifier and Type	Method	Description
default <A> EIO<Throwable,A>	EIOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<EIO<Throwable,?>,Unit>> consumer)
default <A> IO<A>	IOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<IO<?>,Unit>> consumer)
default <A> PureIO<R,Throwable,A>	PureIOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<PureIO<R,Throwable,?>,Unit>> consumer)
default <A> RIO<R,A>	RIOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<RIO<R,?>,Unit>> consumer)
default <A> Task<A>	TaskAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<Task<?>,Unit>> consumer)
default <A> UIO<A>	UIOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<UIO<?>,Unit>> consumer)
default <A> URIO<R,A>	URIOAsync.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<URIO<R,?>,Unit>> consumer)
default <A, B> EIO<E,B>	EIOBracket.bracket(Kind<EIO<E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> use, Function1<? super A,? extends Kind<EIO<E,?>,Unit>> release)
default <A, B> EitherT<F,E,B>	EitherTBracket.bracket(Kind<EitherT<F,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<EitherT<F,E,?>,? extends B>> use, Function1<? super A,? extends Kind<EitherT<F,E,?>,Unit>> release)
default <A, B> IO<B>	IOBracket.bracket(Kind<IO<?>,? extends A> acquire, Function1<? super A,? extends Kind<IO<?>,? extends B>> use, Function1<? super A,? extends Kind<IO<?>,Unit>> release)
default <A, B> OptionT<F,B>	OptionTBracket.bracket(Kind<OptionT<F,?>,? extends A> acquire, Function1<? super A,? extends Kind<OptionT<F,?>,? extends B>> use, Function1<? super A,? extends Kind<OptionT<F,?>,Unit>> release)
default <A, B> PureIO<R,E,B>	PureIOBracket.bracket(Kind<PureIO<R,E,?>,? extends A> acquire, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> use, Function1<? super A,? extends Kind<PureIO<R,E,?>,Unit>> release)
default <A, B> RIO<R,B>	RIOBracket.bracket(Kind<RIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> use, Function1<? super A,? extends Kind<RIO<R,?>,Unit>> release)
default <A, B> Task<B>	TaskBracket.bracket(Kind<Task<?>,? extends A> acquire, Function1<? super A,? extends Kind<Task<?>,? extends B>> use, Function1<? super A,? extends Kind<Task<?>,Unit>> release)
default <A, B> UIO<B>	UIOBracket.bracket(Kind<UIO<?>,? extends A> acquire, Function1<? super A,? extends Kind<UIO<?>,? extends B>> use, Function1<? super A,? extends Kind<UIO<?>,Unit>> release)
default <A, B> URIO<R,B>	URIOBracket.bracket(Kind<URIO<R,?>,? extends A> acquire, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> use, Function1<? super A,? extends Kind<URIO<R,?>,Unit>> release)
default <A, B> EitherK<F,G,B>	EitherKComonad.coflatMap(Kind<EitherK<F,G,?>,? extends A> value, Function1<? super Kind<EitherK<F,G,?>,? extends A>,? extends B> map)
default <A, B> Kind<Eval<?>,B>	EvalComonad.coflatMap(Kind<Eval<?>,? extends A> value, Function1<? super Kind<Eval<?>,? extends A>,? extends B> map)
default <A, B> Kind<Id<?>,B>	IdComonad.coflatMap(Kind<Id<?>,? extends A> value, Function1<? super Kind<Id<?>,? extends A>,? extends B> map)
default <A, B> Kind<Producer<?>,B>	ProducerComonad.coflatMap(Kind<Producer<?>,? extends A> value, Function1<? super Kind<Producer<?>,? extends A>,? extends B> map)
default <A, B> Const<T,B>	ConstContravariant.contramap(Kind<Const<T,?>,? extends A> value, Function1<? super B,? extends A> map)
default <A, B> EitherK<F,G,B>	EitherKContravariant.contramap(Kind<EitherK<F,G,?>,? extends A> value, Function1<? super B,? extends A> map)
<A, B> MonadMTL.EffectE<F,E,B>	EffectEMonadError.flatMap(Kind<MonadMTL.EffectE<F,E,?>,? extends A> value, Function1<? super A,? extends Kind<MonadMTL.EffectE<F,E,?>,? extends B>> map)
<A, B> MonadMTL.EffectR<F,R,E,B>	EffectRMonad.flatMap(Kind<MonadMTL.EffectR<F,R,E,?>,? extends A> value, Function1<? super A,? extends Kind<MonadMTL.EffectR<F,R,E,?>,? extends B>> map)
default <A, B> EIO<E,B>	EIOMonad.flatMap(Kind<EIO<E,?>,? extends A> value, Function1<? super A,? extends Kind<EIO<E,?>,? extends B>> map)
default <T, R> Either<L,R>	EitherMonad.flatMap(Kind<Either<L,?>,? extends T> value, Function1<? super T,? extends Kind<Either<L,?>,? extends R>> map)
default <T, R> EitherT<F,L,R>	EitherTMonad.flatMap(Kind<EitherT<F,L,?>,? extends T> value, Function1<? super T,? extends Kind<EitherT<F,L,?>,? extends R>> map)
default <T, R> Kind<Eval<?>,R>	EvalMonad.flatMap(Kind<Eval<?>,? extends T> value, Function1<? super T,? extends Kind<Eval<?>,? extends R>> map)
default <A, R> Function1<T,R>	Function1Monad.flatMap(Kind<Function1<T,?>,? extends A> value, Function1<? super A,? extends Kind<Function1<T,?>,? extends R>> map)
default <T, R> Kind<Future<?>,R>	FutureMonad.flatMap(Kind<Future<?>,? extends T> value, Function1<? super T,? extends Kind<Future<?>,? extends R>> map)
default <T, R> Kind<Id<?>,R>	IdMonad.flatMap(Kind<Id<?>,? extends T> value, Function1<? super T,? extends Kind<Id<?>,? extends R>> map)
default <T, R> IO<R>	IOMonad.flatMap(Kind<IO<?>,? extends T> value, Function1<? super T,? extends Kind<IO<?>,? extends R>> map)
default <T, R> Kleisli<F,Z,R>	KleisliMonad.flatMap(Kind<Kleisli<F,Z,?>,? extends T> value, Function1<? super T,? extends Kind<Kleisli<F,Z,?>,? extends R>> map)
<A, B> MonadMTL.EffectS<F,S,R,E,B>	MonadMTL.flatMap(Kind<MonadMTL.EffectS<F,S,R,E,?>,? extends A> value, Function1<? super A,? extends Kind<MonadMTL.EffectS<F,S,R,E,?>,? extends B>> map)
default <T, R> Kind<Option<?>,R>	OptionMonad.flatMap(Kind<Option<?>,? extends T> value, Function1<? super T,? extends Kind<Option<?>,? extends R>> map)
default <T, R> OptionT<F,R>	OptionTMonad.flatMap(Kind<OptionT<F,?>,? extends T> value, Function1<? super T,? extends Kind<OptionT<F,?>,? extends R>> map)
default <T, R> Kind<Producer<?>,R>	ProducerMonad.flatMap(Kind<Producer<?>,? extends T> value, Function1<? super T,? extends Kind<Producer<?>,? extends R>> mapper)
default <T, R> Kind<Promise<?>,R>	PromiseMonad.flatMap(Kind<Promise<?>,? extends T> value, Function1<? super T,? extends Kind<Promise<?>,? extends R>> map)
default <A, B> PureIO<R,E,B>	PureIOMonad.flatMap(Kind<PureIO<R,E,?>,? extends A> value, Function1<? super A,? extends Kind<PureIO<R,E,?>,? extends B>> map)
default <T, R> PureStream<F,R>	PureStreamMonad.flatMap(Kind<PureStream<F,?>,? extends T> value, Function1<? super T,? extends Kind<PureStream<F,?>,? extends R>> mapper)
default <T, V> Reader<R,V>	ReaderMonad.flatMap(Kind<Reader<R,?>,? extends T> value, Function1<? super T,? extends Kind<Reader<R,?>,? extends V>> map)
default <A, B> RIO<R,B>	RIOMonad.flatMap(Kind<RIO<R,?>,? extends A> value, Function1<? super A,? extends Kind<RIO<R,?>,? extends B>> map)
default <T, R> Kind<Sequence<?>,R>	SequenceMonad.flatMap(Kind<Sequence<?>,? extends T> value, Function1<? super T,? extends Kind<Sequence<?>,? extends R>> map)
default <T, R> State<S,R>	StateMonad.flatMap(Kind<State<S,?>,? extends T> value, Function1<? super T,? extends Kind<State<S,?>,? extends R>> map)
default <T, R> StateT<F,S,R>	StateTMonad.flatMap(Kind<StateT<F,S,?>,? extends T> value, Function1<? super T,? extends Kind<StateT<F,S,?>,? extends R>> map)
default <A, B> Task<B>	TaskMonad.flatMap(Kind<Task<?>,? extends A> value, Function1<? super A,? extends Kind<Task<?>,? extends B>> map)
default <T, R> Kind<Trampoline<?>,R>	TrampolineMonad.flatMap(Kind<Trampoline<?>,? extends T> value, Function1<? super T,? extends Kind<Trampoline<?>,? extends R>> map)
default <T, R> Kind<Try<?>,R>	TryMonad.flatMap(Kind<Try<?>,? extends T> value, Function1<? super T,? extends Kind<Try<?>,? extends R>> map)
default <A, B> UIO<B>	UIOMonad.flatMap(Kind<UIO<?>,? extends A> value, Function1<? super A,? extends Kind<UIO<?>,? extends B>> map)
default <A, B> URIO<R,B>	URIOMonad.flatMap(Kind<URIO<R,?>,? extends A> value, Function1<? super A,? extends Kind<URIO<R,?>,? extends B>> map)
default <T, R> Validation<E,R>	ValidationMonad.flatMap(Kind<Validation<E,?>,? extends T> value, Function1<? super T,? extends Kind<Validation<E,?>,? extends R>> map)
default <T, R> Writer<L,R>	WriterMonad.flatMap(Kind<Writer<L,?>,? extends T> value, Function1<? super T,? extends Kind<Writer<L,?>,? extends R>> map)
default <T, R> WriterT<F,L,R>	WriterTMonad.flatMap(Kind<WriterT<F,L,?>,? extends T> value, Function1<? super T,? extends Kind<WriterT<F,L,?>,? extends R>> map)
<A> MonadMTL.EffectE<F,E,A>	EffectEMonadError.handleErrorWith(Kind<MonadMTL.EffectE<F,E,?>,A> value, Function1<? super E,? extends Kind<MonadMTL.EffectE<F,E,?>,? extends A>> handler)
<A> MonadMTL.EffectR<F,R,E,A>	EffectRMonadError.handleErrorWith(Kind<MonadMTL.EffectR<F,R,E,?>,A> value, Function1<? super E,? extends Kind<MonadMTL.EffectR<F,R,E,?>,? extends A>> handler)
default <A> EIO<E,A>	EIOMonadError.handleErrorWith(Kind<EIO<E,?>,A> value, Function1<? super E,? extends Kind<EIO<E,?>,? extends A>> handler)
default <A> Either<L,A>	EitherMonadError.handleErrorWith(Kind<Either<L,?>,A> value, Function1<? super L,? extends Kind<Either<L,?>,? extends A>> handler)
default <A> EitherT<F,E,A>	EitherTMonadErrorFromMonad.handleErrorWith(Kind<EitherT<F,E,?>,A> value, Function1<? super E,? extends Kind<EitherT<F,E,?>,? extends A>> handler)
default <A> EitherT<F,E,A>	EitherTMonadErrorFromMonadError.handleErrorWith(Kind<EitherT<F,E,?>,A> value, Function1<? super E,? extends Kind<EitherT<F,E,?>,? extends A>> handler)
default <A> Kind<Eval<?>,A>	EvalMonadError.handleErrorWith(Kind<Eval<?>,A> value, Function1<? super Throwable,? extends Kind<Eval<?>,? extends A>> handler)
default <A> Kind<Future<?>,A>	FutureMonadThrow.handleErrorWith(Kind<Future<?>,A> value, Function1<? super Throwable,? extends Kind<Future<?>,? extends A>> handler)
default <A> IO<A>	IOMonadError.handleErrorWith(Kind<IO<?>,A> value, Function1<? super Throwable,? extends Kind<IO<?>,? extends A>> handler)
default <A> Kleisli<F,R,A>	KleisliMonadError.handleErrorWith(Kind<Kleisli<F,R,?>,A> value, Function1<? super E,? extends Kind<Kleisli<F,R,?>,? extends A>> handler)
<A> MonadMTL.EffectS<F,S,R,E,A>	MonadMTL.handleErrorWith(Kind<MonadMTL.EffectS<F,S,R,E,?>,A> value, Function1<? super E,? extends Kind<MonadMTL.EffectS<F,S,R,E,?>,? extends A>> handler)
default <A> Kind<Option<?>,A>	OptionMonadError.handleErrorWith(Kind<Option<?>,A> value, Function1<? super Unit,? extends Kind<Option<?>,? extends A>> handler)
default <A> OptionT<F,A>	OptionTMonadErrorFromMonad.handleErrorWith(Kind<OptionT<F,?>,A> value, Function1<? super Unit,? extends Kind<OptionT<F,?>,? extends A>> handler)
default <A> OptionT<F,A>	OptionTMonadErrorFromMonadError.handleErrorWith(Kind<OptionT<F,?>,A> value, Function1<? super E,? extends Kind<OptionT<F,?>,? extends A>> handler)
default <A> PureIO<R,E,A>	PureIOMonadError.handleErrorWith(Kind<PureIO<R,E,?>,A> value, Function1<? super E,? extends Kind<PureIO<R,E,?>,? extends A>> handler)
default <A> RIO<R,A>	RIOMonadError.handleErrorWith(Kind<RIO<R,?>,A> value, Function1<? super Throwable,? extends Kind<RIO<R,?>,? extends A>> handler)
default <A> StateT<F,S,A>	StateTMonadError.handleErrorWith(Kind<StateT<F,S,?>,A> value, Function1<? super E,? extends Kind<StateT<F,S,?>,? extends A>> handler)
default <A> Task<A>	TaskMonadError.handleErrorWith(Kind<Task<?>,A> value, Function1<? super Throwable,? extends Kind<Task<?>,? extends A>> handler)
default <A> Kind<Try<?>,A>	TryMonadError.handleErrorWith(Kind<Try<?>,A> value, Function1<? super Throwable,? extends Kind<Try<?>,? extends A>> handler)
default <A> UIO<A>	UIOMonadError.handleErrorWith(Kind<UIO<?>,A> value, Function1<? super Throwable,? extends Kind<UIO<?>,? extends A>> handler)
default <A> URIO<R,A>	URIOMonadError.handleErrorWith(Kind<URIO<R,?>,A> value, Function1<? super Throwable,? extends Kind<URIO<R,?>,? extends A>> handler)
default <A> Validation<E,A>	ValidationMonadError.handleErrorWith(Kind<Validation<E,?>,A> value, Function1<? super E,? extends Kind<Validation<E,?>,? extends A>> handler)
default <A> WriterT<F,L,A>	WriterTMonadError.handleErrorWith(Kind<WriterT<F,L,?>,A> value, Function1<? super E,? extends Kind<WriterT<F,L,?>,? extends A>> handler)
private <T, R> Trampoline<Kind<Either<L,?>,R>>	EitherMonad.loop(T value, Function1<T,? extends Kind<Either<L,?>,Either<T,R>>> map)
private <T, R> Trampoline<Kind<Option<?>,R>>	OptionMonad.loop(T value, Function1<T,? extends Kind<Option<?>,Either<T,R>>> map)
private <T, R> Trampoline<Kind<Try<?>,R>>	TryMonad.loop(T value, Function1<T,? extends Kind<Try<?>,Either<T,R>>> map)
private <T, R> Trampoline<Kind<Validation<E,?>,R>>	ValidationMonad.loop(T value, Function1<T,? extends Kind<Validation<E,?>,Either<T,R>>> map)
default <A, B> Kind<Const<T,?>,B>	ConstFunctor.map(Kind<Const<T,?>,? extends A> value, Function1<? super A,? extends B> map)
default <A, B> EIO<E,B>	EIOFunctor.map(Kind<EIO<E,?>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> Either<L,R>	EitherFunctor.map(Kind<Either<L,?>,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> EitherK<F,G,R>	EitherKFunctor.map(Kind<EitherK<F,G,?>,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Eval<R>	EvalFunctor.map(Kind<Eval<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <A, R> Function1<T,R>	Function1Functor.map(Kind<Function1<T,?>,? extends A> value, Function1<? super A,? extends R> map)
default <T, R> Kind<Future<?>,R>	FutureFunctor.map(Kind<Future<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Id<?>,R>	IdFunctor.map(Kind<Id<?>,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Kind<IO<?>,R>	IOFunctor.map(Kind<IO<?>,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Kind<Option<?>,R>	OptionFunctor.map(Kind<Option<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Producer<?>,R>	ProducerFunctor.map(Kind<Producer<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Promise<?>,R>	PromiseFunctor.map(Kind<Promise<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <A, B> PureIO<R,E,B>	PureIOFunctor.map(Kind<PureIO<R,E,?>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> PureStream<F,R>	PureStreamFunctor.map(Kind<PureStream<F,?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <A, B> RIO<R,B>	RIOFunctor.map(Kind<RIO<R,?>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> Schedule<F,A,R>	ScheduleFunctor.map(Kind<Schedule<F,A,?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Sequence<?>,R>	SequenceFunctor.map(Kind<Sequence<?>,? extends T> value, Function1<? super T,? extends R> map)
default <A, B> Task<B>	TaskFunctor.map(Kind<Task<?>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> Kind<Trampoline<?>,R>	TrampolineFunctor.map(Kind<Trampoline<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Try<?>,R>	TryFunctor.map(Kind<Try<?>,? extends T> value, Function1<? super T,? extends R> mapper)
default <T, R> Kind<Tuple1<?>,R>	Tuple1Functor.map(Kind<Tuple1<?>,? extends T> value, Function1<? super T,? extends R> map)
default <A, B> UIO<B>	UIOFunctor.map(Kind<UIO<?>,? extends A> value, Function1<? super A,? extends B> map)
default <A, B> URIO<R,B>	URIOFunctor.map(Kind<URIO<R,?>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> Validation<E,R>	ValidationFunctor.map(Kind<Validation<E,?>,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Kind<Either<L,?>,R>	EitherMonad.tailRecM(T value, Function1<T,? extends Kind<Either<L,?>,Either<T,R>>> map)
default <T, R> Kind<Option<?>,R>	OptionMonad.tailRecM(T value, Function1<T,? extends Kind<Option<?>,Either<T,R>>> map)
default <T, R> Kind<Try<?>,R>	TryMonad.tailRecM(T value, Function1<T,? extends Kind<Try<?>,Either<T,R>>> map)
default <T, R> Kind<Validation<E,?>,R>	ValidationMonad.tailRecM(T value, Function1<T,? extends Kind<Validation<E,?>,Either<T,R>>> map)
default <G extends Kind<G, ?>, A, B> Kind<G,Kind<Const<T,?>,B>>	ConstTraverse.traverse(Applicative<G> applicative, Kind<Const<T,?>,A> value, Function1<? super A,? extends Kind<G,? extends B>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Either<L,?>,R>>	EitherTraverse.traverse(Applicative<G> applicative, Kind<Either<L,?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Id<?>,R>>	IdTraverse.traverse(Applicative<G> applicative, Kind<Id<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Option<?>,R>>	OptionTraverse.traverse(Applicative<G> applicative, Kind<Option<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Sequence<?>,R>>	SequenceTraverse.traverse(Applicative<G> applicative, Kind<Sequence<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <G extends Kind<G, ?>, T, R> Kind<G,Kind<Try<?>,R>>	TryTraverse.traverse(Applicative<G> applicative, Kind<Try<?>,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)

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

Modifier and Type	Method	Description
default <A, R> Function1<T,R>	Function1Applicative.ap(Kind<Function1<T,?>,? extends A> value, Kind<Function1<T,?>,? extends Function1<? super A,? extends R>> apply)
default <A, R> Function1<T,R>	Function1Monad.flatMap(Kind<Function1<T,?>,? extends A> value, Function1<? super A,? extends Kind<Function1<T,?>,? extends R>> map)
default <A, R> Function1<T,R>	Function1Monad.flatMap(Kind<Function1<T,?>,? extends A> value, Function1<? super A,? extends Kind<Function1<T,?>,? extends R>> map)
default <A, R> Function1<T,R>	Function1Functor.map(Kind<Function1<T,?>,? extends A> value, Function1<? super A,? extends R> map)

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

Fields in com.github.tonivade.purefun.monad declared as Function1

Modifier and Type	Field	Description
private final Function1<Consumer1<? super Try<? extends T>>,Kind<IO<?>,Unit>>	IO.Async.callback
private final Function1<? super T,? extends Kind<IO<?>,? extends R>>	IO.FlatMapped.next

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

Modifier and Type	Method	Description
static <T, R> Function1<T,IO<R>>	IO.lift(Function1<T,R> task)
static <A, B> Function1<A,IO<B>>	IO.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <A, B> Function1<A,IO<B>>	IO.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <A, B> Function1<A,IO<B>>	IO.liftTry(Function1<? super A,? extends Try<? extends B>> function)

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

Modifier and Type	Method	Description
static <A, T> IO<Function1<A,IO<T>>>	IO.memoize(Function1<A,IO<T>> function)
static <A, T> IO<Function1<A,IO<T>>>	IO.memoize(Executor executor, Function1<A,IO<T>> function)

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

Modifier and Type	Method	Description
default <V, R> Writer<V,R>	Writer.bimap(Monoid<V> monoidV, Function1<? super L,? extends V> mapper1, Function1<? super A,? extends R> mapper2)
static <T extends AutoCloseable, R> IO<R>	IO.bracket(Kind<IO<?>,? extends T> acquire, Function1<? super T,? extends Kind<IO<?>,? extends R>> use)
static <T, R> IO<R>	IO.bracket(Kind<IO<?>,? extends T> acquire, Function1<? super T,? extends Kind<IO<?>,? extends R>> use, Consumer1<? super T> release)
static <T, R> IO<R>	IO.bracket(Kind<IO<?>,? extends T> acquire, Function1<? super T,? extends Kind<IO<?>,? extends R>> use, Function1<? super T,? extends Kind<IO<?>,Unit>> release)
static <T> IO<T>	IO.cancellable(Function1<Consumer1<? super Try<? extends T>>,Kind<IO<?>,Unit>> callback)
default <L, R> IO<Either<L,R>>	IO.either(Function1<? super Throwable,? extends L> mapError, Function1<? super T,? extends R> mapper)
default <R> IO<R>	IO.flatMap(Function1<? super T,? extends Kind<IO<?>,? extends R>> map)
default <B> Reader<R,B>	Reader.flatMap(Function1<? super A,? extends Kind<Reader<R,?>,? extends B>> mapper)
default <R> State<S,R>	State.flatMap(Function1<? super A,? extends Kind<State<S,?>,? extends R>> mapper)
default <B> Writer<L,B>	Writer.flatMap(Function1<? super A,? extends Kind<Writer<L,?>,? extends B>> mapper)
static <S, A> State<S,A>	State.inspect(Function1<? super S,? extends A> mapper)
static <T, R> Function1<T,IO<R>>	IO.lift(Function1<T,R> task)
static <A, B> Function1<A,IO<B>>	IO.liftEither(Function1<? super A,? extends Either<Throwable,? extends B>> function)
static <A, B> Function1<A,IO<B>>	IO.liftOption(Function1<? super A,? extends Option<? extends B>> function)
static <A, B> Function1<A,IO<B>>	IO.liftTry(Function1<? super A,? extends Try<? extends B>> function)
default <R> IO<R>	IO.map(Function1<? super T,? extends R> map)
default <B> Reader<R,B>	Reader.map(Function1<? super A,? extends B> mapper)
default <R> State<S,R>	State.map(Function1<? super A,? extends R> mapper)
default <B> Writer<L,B>	Writer.map(Function1<? super A,? extends B> mapper)
default <R> Writer<R,A>	Writer.mapLog(Monoid<R> monoidR, Function1<? super L,? extends R> mapper)
static <A, T> IO<Function1<A,IO<T>>>	IO.memoize(Function1<A,IO<T>> function)
static <A, T> IO<Function1<A,IO<T>>>	IO.memoize(Executor executor, Function1<A,IO<T>> function)
<B> IO<B>	Ref.modify(Function1<A,Tuple2<B,A>> change)
static <R, A> Reader<R,A>	Reader.reader(Function1<? super R,? extends A> run)
default IO<T>	IO.recover(Function1<? super Throwable,? extends T> mapError)
default <X extends Throwable> IO<T>	IO.recover(Class<X> type, Function1<? super X,? extends T> function)
default <R> IO<R>	IO.redeem(Function1<? super Throwable,? extends R> mapError, Function1<? super T,? extends R> mapper)
default <R> IO<R>	IO.redeemWith(Function1<? super Throwable,? extends Kind<IO<?>,? extends R>> mapError, Function1<? super T,? extends Kind<IO<?>,? extends R>> mapper)
static <S, A> State<S,A>	State.state(Function1<S,Tuple2<S,A>> runState)
private static <T, U> Kind<IO<?>,T>	IO.unwrap(Kind<IO<?>,T> current, CallStack<U> stack, Function1<Kind<IO<?>,? extends T>,Kind<IO<?>,? extends U>> next)

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

Modifier and Type	Method	Description
default <R> IO<R>	IO.ap(Kind<IO<?>,? extends Function1<? super T,? extends R>> apply)

Constructors in com.github.tonivade.purefun.monad with parameters of type Function1

Modifier	Constructor	Description
private	Async(Function1<Consumer1<? super Try<? extends T>>,Kind<IO<?>,Unit>> callback)
private	FlatMapped(IO<? extends T> current, Function1<? super T,? extends Kind<IO<?>,? extends R>> next)

Uses of Function1 in com.github.tonivade.purefun.optics

Fields in com.github.tonivade.purefun.optics declared as Function1

Modifier and Type	Field	Description
private final Function1<S,A>	PIso.get
private final Function1<S,Either<T,A>>	POptional.getOrModify
private final Function1<S,Either<T,A>>	PPrism.getOrModify
private final Function1<S,A>	PLens.getter
private final Function1<B,T>	PIso.reverseGet
private final Function1<B,T>	PPrism.reverseGet
private final Function1<S,Function1<B,T>>	POptional.set
private final Function1<S,Function1<B,T>>	PLens.setter

Fields in com.github.tonivade.purefun.optics with type parameters of type Function1

Modifier and Type	Field	Description
private final Function1<S,Function1<B,T>>	POptional.set
private final Function1<S,Function1<B,T>>	PLens.setter

Methods in com.github.tonivade.purefun.optics that return Function1

Modifier and Type	Method	Description
Function1<S,T>	PIso.lift(Function1<A,B> mapper)
Function1<S,T>	POptional.lift(Function1<A,B> mapper)
Function1<S,T>	PLens.modify(B newValue)
Function1<S,T>	PLens.modify(Function1<A,B> mapper)
Function1<S,T>	PPrism.modify(Function1<A,B> mapper)
Function1<S,Option<T>>	PPrism.modifyOption(Function1<A,B> mapper)
Function1<S,Option<S>>	Prism.modifyOption(Operator1<A> mapper)
Function1<A,S>	Lens.set(S target)
Function1<A,S>	Optional.set(S target)
Function1<B,T>	PLens.set(S target)
Function1<B,T>	POptional.set(S target)
Function1<S,T>	PPrism.set(B value)
Function1<S,Option<T>>	PPrism.setOption(B value)
Function1<S,Option<S>>	Prism.setOption(A value)

Methods in com.github.tonivade.purefun.optics with parameters of type Function1

Modifier and Type	Method	Description
Function1<S,T>	PIso.lift(Function1<A,B> mapper)
Function1<S,T>	POptional.lift(Function1<A,B> mapper)
T	PIso.modify(S target, Function1<A,B> mapper)
Function1<S,T>	PLens.modify(Function1<A,B> mapper)
T	POptional.modify(S target, Function1<A,B> mapper)
Function1<S,T>	PPrism.modify(Function1<A,B> mapper)
T	PPrism.modify(S target, Function1<A,B> mapper)
Option<T>	POptional.modifyOption(S target, Function1<A,B> mapper)
Function1<S,Option<T>>	PPrism.modifyOption(Function1<A,B> mapper)
static <S, A> Iso<S,A>	Iso.of(Function1<S,A> get, Function1<A,S> reverseGet)
static <S, A> Lens<S,A>	Lens.of(Function1<S,A> getter, Function2<S,A,S> setter)
static <S, A> Optional<S,A>	Optional.of(Function2<S,A,S> set, Function1<S,Option<A>> getOption)
static <S, T, A, B> PIso<S,T,A,B>	PIso.of(Function1<S,A> get, Function1<B,T> reverseGet)
static <S, T, A, B> PLens<S,T,A,B>	PLens.of(Function1<S,A> getter, Function2<S,B,T> setter)
static <S, T, A, B> POptional<S,T,A,B>	POptional.of(Function2<S,B,T> set, Function1<S,Either<T,A>> getOrModify)
static <S, T, A, B> PPrism<S,T,A,B>	PPrism.of(Function1<S,Either<T,A>> getOrModify, Function1<B,T> reverseGet)
static <S, A> Prism<S,A>	Prism.of(Function1<S,Option<A>> getOption, Function1<A,S> reverseGet)

Constructors in com.github.tonivade.purefun.optics with parameters of type Function1

Modifier	Constructor	Description
(package private)	PIso(Function1<S,A> get, Function1<B,T> reverseGet)
(package private)	PLens(Function1<S,A> getter, Function1<S,Function1<B,T>> setter)
(package private)	POptional(Function1<S,Function1<B,T>> set, Function1<S,Either<T,A>> getOrModify)
(package private)	PPrism(Function1<S,Either<T,A>> getOrModify, Function1<B,T> reverseGet)

Constructor parameters in com.github.tonivade.purefun.optics with type arguments of type Function1

Modifier	Constructor	Description
(package private)	POptional(Function1<S,Function1<B,T>> set, Function1<S,Either<T,A>> getOrModify)

Uses of Function1 in com.github.tonivade.purefun.runtimes

Methods in com.github.tonivade.purefun.runtimes that return Function1

Modifier and Type	Method	Description
<R, E, T> Function1<R,Either<E,T>>	ConsoleExecutor.run(PureIO<R,E,T> program)
<R, T> Function1<R,Try<T>>	ConsoleExecutor.run(RIO<R,T> program)
<R, T> Function1<R,T>	ConsoleExecutor.run(URIO<R,T> program)

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

Methods in com.github.tonivade.purefun.stream with parameters of type Function1

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)
<R> PureStream<F,R>	Cons.flatMap(Function1<? super T,? extends Kind<PureStream<F,?>,? extends R>> map)
<R> PureStream<F,R>	Nil.flatMap(Function1<? super T,? extends Kind<PureStream<F,?>,? extends R>> map)
<R> PureStream<F,R>	PureStream.flatMap(Function1<? super T,? extends Kind<PureStream<F,?>,? extends R>> map)
<R> PureStream<F,R>	Suspend.flatMap(Function1<? super T,? extends Kind<PureStream<F,?>,? extends R>> map)
private <R> PureStream<F,R>	Suspend.lazyMap(Function1<PureStream<F,T>,PureStream<F,R>> mapper)
<R> PureStream<F,R>	Cons.map(Function1<? super T,? extends R> map)
<R> PureStream<F,R>	Nil.map(Function1<? super T,? extends R> map)
<R> PureStream<F,R>	PureStream.map(Function1<? super T,? extends R> map)
<R> PureStream<F,R>	Suspend.map(Function1<? super T,? extends R> mapper)
<R> PureStream<F,R>	Cons.mapEval(Function1<? super T,? extends Kind<F,? extends R>> mapper)
<R> PureStream<F,R>	Nil.mapEval(Function1<? super T,? extends Kind<F,? extends R>> mapper)
<R> PureStream<F,R>	PureStream.mapEval(Function1<? super T,? extends Kind<F,? extends R>> mapper)
<R> PureStream<F,R>	Suspend.mapEval(Function1<? super T,? extends Kind<F,? extends R>> mapper)
default <G extends Kind<G, ?>, R> PureStream<G,R>	PureStream.through(Function1<PureStream<F,T>,PureStream<G,R>> 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 Function1 in com.github.tonivade.purefun.transformer

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

Modifier and Type	Method	Description
default <T, V> EitherT<F,T,V>	EitherT.bimap(Function1<? super L,? extends T> leftMapper, Function1<? super R,? extends V> rightMapper)
default <V, R> WriterT<F,V,R>	WriterT.bimap(Monoid<V> monoidV, Function1<? super L,? extends V> mapper1, Function1<? super A,? extends R> mapper2)
default <V> EitherT<F,L,V>	EitherT.flatMap(Function1<? super R,? extends Kind<EitherT<F,L,?>,? extends V>> map)
default <R> Kleisli<F,Z,R>	Kleisli.flatMap(Function1<? super A,? extends Kind<Kleisli<F,Z,?>,? extends R>> map)
default <R> OptionT<F,R>	OptionT.flatMap(Function1<? super T,? extends Kind<OptionT<F,?>,? extends R>> map)
default <R> StateT<F,S,R>	StateT.flatMap(Function1<? super A,? extends Kind<StateT<F,S,?>,? extends R>> map)
default <R> WriterT<F,L,R>	WriterT.flatMap(Function1<? super A,? extends Kind<WriterT<F,L,?>,? extends R>> mapper)
default <V> Kind<F,Either<L,V>>	EitherT.flatMapF(Function1<? super R,? extends Kind<F,? extends Either<L,V>>> map)
default <R> Kind<F,Option<R>>	OptionT.flatMapF(Function1<? super T,? extends Kind<F,? extends Option<R>>> map)
default <V> Kind<F,V>	EitherT.fold(Function1<? super L,? extends V> leftMapper, Function1<? super R,? extends V> rightMapper)
default <R> Kind<F,R>	OptionT.fold(Producer<? extends R> orElse, Function1<? super T,? extends R> map)
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateT.inspect(Monad<F> monad, Function1<S,A> mapper)
static <F extends Kind<F, ?>, A, B> Kleisli<F,A,B>	Kleisli.lift(Monad<F> monad, Function1<? super A,? extends B> map)
static <F extends Kind<F, ?>, S, A> StateT<F,S,A>	StateT.lift(Monad<F> monad, Function1<S,Tuple2<S,A>> run)
default <X> Kleisli<F,X,A>	Kleisli.local(Function1<? super X,? extends Z> map)
default <V> EitherT<F,L,V>	EitherT.map(Function1<? super R,? extends V> map)
default <R> Kleisli<F,Z,R>	Kleisli.map(Function1<? super A,? extends R> map)
default <R> OptionT<F,R>	OptionT.map(Function1<? super T,? extends R> map)
default <R> StateT<F,S,R>	StateT.map(Function1<? super A,? extends R> map)
default <R> WriterT<F,L,R>	WriterT.map(Function1<? super A,? extends R> mapper)
default <T> EitherT<F,T,R>	EitherT.mapLeft(Function1<? super L,? extends T> leftMapper)
default <V> WriterT<F,V,A>	WriterT.mapLog(Monoid<V> monoidV, Function1<? super L,? extends V> mapper)
static <F extends Kind<F, ?>, A, B> Kleisli<F,A,B>	Kleisli.of(Monad<F> monad, Function1<? super A,? extends Kind<F,? extends B>> 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)

Uses of Function1 in com.github.tonivade.purefun.type

Fields in com.github.tonivade.purefun.type declared as Function1

Modifier and Type	Field	Description
private final Function1<? super A,? extends Kind<Eval<?>,? extends B>>	Eval.FlatMapped.run

Methods in com.github.tonivade.purefun.type that return Function1

Modifier and Type	Method	Description
static <E> Function1<Validation.Result<Validation.Result<E>>,Validation.Result<E>>	Validation.Result.flatten()

Methods in com.github.tonivade.purefun.type with parameters of type Function1

Modifier and Type	Method	Description
default <T, U> Either<T,U>	Either.bimap(Function1<? super L,? extends T> leftMapper, Function1<? super R,? extends U> rightMapper)
default <U, R> Validation<U,R>	Validation.bimap(Function1<? super E,? extends U> error, Function1<? super T,? extends R> mapper)
default <T> Either<L,T>	Either.flatMap(Function1<? super R,? extends Kind<Either<L,?>,? extends T>> map)
<R> Eval<R>	Eval.Defer.flatMap(Function1<? super A,? extends Kind<Eval<?>,? extends R>> map)
<R> Eval<R>	Eval.Done.flatMap(Function1<? super A,? extends Kind<Eval<?>,? extends R>> map)
<R> Eval<R>	Eval.flatMap(Function1<? super A,? extends Kind<Eval<?>,? extends R>> map)
<R> Eval<R>	Eval.FlatMapped.flatMap(Function1<? super B,? extends Kind<Eval<?>,? extends R>> map)
<R> Id<R>	Id.flatMap(Function1<? super T,? extends Kind<Id<?>,? extends R>> map)
default <R> Option<R>	Option.flatMap(Function1<? super T,? extends Kind<Option<?>,? extends R>> map)
default <R> Try<R>	Try.flatMap(Function1<? super T,? extends Kind<Try<?>,? extends R>> mapper)
default <R> Validation<E,R>	Validation.flatMap(Function1<? super T,? extends Kind<Validation<E,?>,? extends R>> mapper)
default <T> Either<T,R>	Either.flatMapLeft(Function1<? super L,? extends Either<? extends T,R>> map)
default <T> T	Either.fold(Function1<? super L,? extends T> leftMapper, Function1<? super R,? extends T> rightMapper)
default <U> U	Option.fold(Producer<? extends U> orElse, Function1<? super T,? extends U> mapper)
default <U> U	Try.fold(Function1<? super Throwable,? extends U> failureMapper, Function1<? super T,? extends U> successMapper)
default <U> U	Validation.fold(Function1<? super E,? extends U> invalidMap, Function1<? super T,? extends U> validMap)
default <X extends Throwable> T	Validation.getOrElseThrow(Function1<? super E,? extends X> mapper)
default <T> Either<L,T>	Either.map(Function1<? super R,? extends T> map)
default <R> Eval<R>	Eval.map(Function1<? super A,? extends R> map)
<R> Id<R>	Id.map(Function1<? super T,? extends R> map)
default <R> Option<R>	Option.map(Function1<? super T,? extends R> mapper)
default <R> Try<R>	Try.map(Function1<? super T,? extends R> mapper)
default <R> Validation<E,R>	Validation.map(Function1<? super T,? extends R> mapper)
default Try<T>	Try.mapError(Function1<? super Throwable,? extends Throwable> mapper)
default <U> Validation<U,T>	Validation.mapError(Function1<? super E,? extends U> mapper)
default <T> Either<T,R>	Either.mapLeft(Function1<? super L,? extends T> map)
default Try<T>	Try.recover(Function1<? super Throwable,? extends T> mapper)
default <X extends Throwable> Try<T>	Try.recoverWith(Class<X> type, Function1<? super X,? extends T> mapper)
default <E> Validation<E,T>	Try.toValidation(Function1<? super Throwable,? extends E> map)

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

Modifier and Type	Method	Description
default <T> Either<L,T>	Either.ap(Kind<Either<L,?>,? extends Function1<? super R,? extends T>> apply)
<R> Id<R>	Id.ap(Kind<Id<?>,? extends Function1<? super T,? extends R>> apply)
default <R> Option<R>	Option.ap(Kind<Option<?>,? extends Function1<? super T,? extends R>> apply)
default <R> Try<R>	Try.ap(Kind<Try<?>,? extends Function1<? super T,? extends R>> apply)
default <R> Validation<Validation.Result<E>,R>	Validation.ap(Validation<Validation.Result<E>,Function1<? super T,? extends R>> other)

Constructors in com.github.tonivade.purefun.type with parameters of type Function1

Modifier	Constructor	Description
private	FlatMapped(Producer<? extends Kind<Eval<?>,? extends A>> start, Function1<? super A,? extends Kind<Eval<?>,? extends B>> run)

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

Fields in com.github.tonivade.purefun.typeclasses declared as Function1

Modifier and Type	Field	Description
protected final Function1<? super A,? extends Kind<F,? extends B>>	AbstractFlatMap.value
private final Function1<? super A,? extends Kind<F,? extends B>>	FlatMap3.value2
private final Function1<? super A,? extends Kind<F,? extends B>>	FlatMap4.value2
private final Function1<? super A,? extends Kind<F,? extends B>>	FlatMap5.value2
private final Function1<? super B,? extends Kind<F,? extends C>>	FlatMap4.value3
private final Function1<? super B,? extends Kind<F,? extends C>>	FlatMap5.value3
private final Function1<? super C,? extends Kind<F,? extends D>>	FlatMap5.value4

Methods in com.github.tonivade.purefun.typeclasses that return Function1

Modifier and Type	Method	Description
default <A, B> Function1<Kind<F,A>,Kind<F,B>>	Functor.lift(Function1<? super A,? extends B> function)

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

Modifier and Type	Method	Description
default Schedule<F,A,B>	Schedule.addDelay(Function1<B,Duration> map)
Schedule<F,A,B>	Schedule.addDelayM(Function1<B,Kind<F,Duration>> map)
Schedule<F,A,B>	ScheduleImpl.addDelayM(Function1<B,Kind<F,Duration>> map)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.allS(Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition, G... reified)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.allS(Foldable<G> foldable, Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.anyS(Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition, G... reified)
default <G extends Kind<G, ?>, A> Eval<Kind<F,Boolean>>	Selective.anyS(Foldable<G> foldable, Kind<G,? extends A> values, Function1<? super A,? extends Kind<F,Boolean>> condition)
<R> Kind<F,R>	Apply1.apply(Function1<? super A,? extends R> combinator)
<A> Kind<F,A>	Async.asyncF(Function1<Consumer1<? super Try<? extends A>>,Kind<F,Unit>> consumer)
default <A extends AutoCloseable, B> Kind<F,B>	Bracket.bracket(Kind<F,? extends A> acquire, Function1<? super A,? extends Kind<F,? extends B>> use)
default <A, B> Kind<F,B>	Bracket.bracket(Kind<F,? extends A> acquire, Function1<? super A,? extends Kind<F,? extends B>> use, Consumer1<? super A> release)
<A, B> Kind<F,B>	Bracket.bracket(Kind<F,? extends A> acquire, Function1<? super A,? extends Kind<F,? extends B>> use, Function1<? super A,? extends Kind<F,Unit>> release)
default <A> Kind<F,A>	Concurrent.cancellable(Function1<Consumer1<? super Try<? extends A>>,Kind<F,Unit>> callback)
<A, B> Kind<F,B>	Comonad.coflatMap(Kind<F,? extends A> value, Function1<? super Kind<F,? extends A>,? extends B> map)
default <A, B> Kind<Nested<F,G>,B>	ComposedContravariantCovariant.contramap(Kind<Nested<F,G>,? extends A> value, Function1<? super B,? extends A> map)
default <A, B> Kind<Nested<F,G>,B>	ComposedCovariantContravariant.contramap(Kind<Nested<F,G>,? extends A> value, Function1<? super B,? extends A> map)
<A, B> Kind<F,B>	Contravariant.contramap(Kind<F,? extends A> value, Function1<? super B,? extends A> map)
<C> Schedule<F,C,B>	Schedule.contramap(Function1<? super C,? extends A> comap)
<C> Schedule<F,C,B>	ScheduleImpl.contramap(Function1<? super C,? extends A> comap)
default <C, D> Schedule<F,C,D>	Schedule.dimap(Function1<? super C,? extends A> comap, Function1<? super B,? extends D> map)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.doUntilM(Function1<A,Kind<F,Boolean>> condition, F... reified)
default <A> Schedule<F,A,A>	Schedule.Of.doUntilM(Function1<A,Kind<F,Boolean>> condition)
static <F extends Kind<F, ?>, A> Schedule<F,A,A>	Schedule.doWhileM(Function1<A,Kind<F,Boolean>> condition, F... reified)
default <A> Schedule<F,A,A>	Schedule.Of.doWhileM(Function1<A,Kind<F,Boolean>> condition)
<R> FlatMap2<F,A,R>	FlatMap1.flatMap(Function1<? super A,? extends Kind<F,? extends R>> mapper)
<R> FlatMap3<F,A,B,R>	FlatMap2.flatMap(Function1<? super B,? extends Kind<F,? extends R>> mapper)
<R> FlatMap4<F,A,B,C,R>	FlatMap3.flatMap(Function1<? super C,? extends Kind<F,? extends R>> mapper)
<R> FlatMap5<F,A,B,C,D,R>	FlatMap4.flatMap(Function1<D,? extends Kind<F,R>> mapper)
<T, R> Kind<F,R>	Monad.flatMap(Kind<F,? extends T> value, Function1<? super T,? extends Kind<F,? extends R>> map)
<T, R> Kind<F,R>	ReferenceMonadState.flatMap(Kind<F,? extends T> value, Function1<? super T,? extends Kind<F,? extends R>> map)
<R> Resource<F,R>	Resource.flatMap(Function1<? super T,? extends Kind<Resource<F,?>,? extends R>> mapper)
default <A, B> B	Foldable.foldMap(Monoid<B> monoid, Kind<F,? extends A> value, Function1<? super A,? extends B> mapper)
default <A> Kind<F,A>	ApplicativeError.handleError(Kind<F,A> value, Function1<? super E,? extends A> handler)
<A> Kind<F,A>	ApplicativeError.handleErrorWith(Kind<F,A> value, Function1<? super E,? extends Kind<F,? extends A>> handler)
default <A, B> Kind<Nested<F,G>,B>	ComposedInvariant.imap(Kind<Nested<F,G>,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<Nested<F,G>,B>	ComposedInvariantContravariant.imap(Kind<Nested<F,G>,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<Nested<F,G>,B>	ComposedInvariantCovariant.imap(Kind<Nested<F,G>,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<F,B>	Contravariant.imap(Kind<F,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A, B> Kind<F,B>	Functor.imap(Kind<F,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
<A, B> Kind<F,B>	Invariant.imap(Kind<F,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <R> Monoid<R>	Monoid.imap(Function1<T,R> map, Function1<R,T> comap)
default <A, B> Kind<Monoid<?>,B>	MonoidInvariant.imap(Kind<Monoid<?>,? extends A> value, Function1<? super A,? extends B> map, Function1<? super B,? extends A> comap)
default <A> Kind<F,A>	MonadState.inspect(Function1<? super S,? extends A> mapper)
default <A, B> Function1<Kind<F,A>,Kind<F,B>>	Functor.lift(Function1<? super A,? extends B> function)
default <A, B> Kind<F,Tuple2<B,A>>	MonadWriter.listens(Kind<F,? extends A> value, Function1<? super W,? extends B> mapper)
default <T, R> Kind<F,R>	Applicative.map(Kind<F,? extends T> value, Function1<? super T,? extends R> map)
default <A, B> Kind<Nested<F,G>,B>	ComposedContravariant.map(Kind<Nested<F,G>,? extends A> value, Function1<? super A,? extends B> map)
default <T, R> Kind<Nested<F,G>,R>	ComposedFunctor.map(Kind<Nested<F,G>,? extends T> value, Function1<? super T,? extends R> map)
<R> FlatMap2<F,A,R>	FlatMap1.map(Function1<? super A,? extends R> mapper)
<R> FlatMap3<F,A,B,R>	FlatMap2.map(Function1<? super B,? extends R> mapper)
<R> FlatMap4<F,A,B,C,R>	FlatMap3.map(Function1<? super C,? extends R> mapper)
<R> FlatMap5<F,A,B,C,D,R>	FlatMap4.map(Function1<D,R> mapper)
<T, R> Kind<F,R>	Functor.map(Kind<F,? extends T> value, Function1<? super T,? extends R> map)
default <T, R> Kind<F,R>	Monad.map(Kind<F,? extends T> value, Function1<? super T,? extends R> map)
<R> Resource<F,R>	Resource.map(Function1<? super T,? extends R> mapper)
<C> Schedule<F,A,C>	Schedule.map(Function1<? super B,? extends C> mapper)
<C> Schedule<F,A,C>	ScheduleImpl.map(Function1<? super B,? extends C> mapper)
default <T, R> Kind<F,R>	Traverse.map(Kind<F,? extends T> value, Function1<? super T,? extends R> map)
<B> TupleK1<F,B>	TupleK1.map1(Function1<? super A,? extends B> mapper, F... reified)
<B> TupleK1<F,B>	TupleK1.map1(Functor<F> functor, Function1<? super A,? extends B> mapper)
<R> TupleK2<F,R,B>	TupleK2.map1(Function1<? super A,? extends R> mapper, F... reified)
<R> TupleK2<F,R,B>	TupleK2.map1(Functor<F> functor, Function1<? super A,? extends R> mapper)
<R> TupleK3<F,R,B,C>	TupleK3.map1(Function1<? super A,? extends R> mapper, F... reified)
<R> TupleK3<F,R,B,C>	TupleK3.map1(Functor<F> functor, Function1<? super A,? extends R> mapper)
<R> TupleK4<F,R,B,C,D>	TupleK4.map1(Function1<? super A,? extends R> mapper, F... reified)
<R> TupleK4<F,R,B,C,D>	TupleK4.map1(Functor<F> functor, Function1<? super A,? extends R> mapper)
<R> TupleK5<F,R,B,C,D,E>	TupleK5.map1(Function1<? super A,? extends R> mapper, F... reified)
<R> TupleK5<F,R,B,C,D,E>	TupleK5.map1(Functor<F> functor, Function1<? super A,? extends R> mapper)
<R> TupleK2<F,A,R>	TupleK2.map2(Function1<? super B,? extends R> mapper, F... reified)
<R> TupleK2<F,A,R>	TupleK2.map2(Functor<F> functor, Function1<? super B,? extends R> mapper)
<R> TupleK3<F,A,R,C>	TupleK3.map2(Function1<? super B,? extends R> mapper, F... reified)
<R> TupleK3<F,A,R,C>	TupleK3.map2(Functor<F> functor, Function1<? super B,? extends R> mapper)
<R> TupleK4<F,A,R,C,D>	TupleK4.map2(Function1<? super B,? extends R> mapper, F... reified)
<R> TupleK4<F,A,R,C,D>	TupleK4.map2(Functor<F> functor, Function1<? super B,? extends R> mapper)
<R> TupleK5<F,A,R,C,D,E>	TupleK5.map2(Function1<? super B,? extends R> mapper, F... reified)
<R> TupleK5<F,A,R,C,D,E>	TupleK5.map2(Functor<F> functor, Function1<? super B,? extends R> mapper)
<R> TupleK3<F,A,B,R>	TupleK3.map3(Function1<? super C,? extends R> mapper, F... reified)
<R> TupleK3<F,A,B,R>	TupleK3.map3(Functor<F> functor, Function1<? super C,? extends R> mapper)
<R> TupleK4<F,A,B,R,D>	TupleK4.map3(Function1<? super C,? extends R> mapper, F... reified)
<R> TupleK4<F,A,B,R,D>	TupleK4.map3(Functor<F> functor, Function1<? super C,? extends R> mapper)
<R> TupleK5<F,A,B,R,D,E>	TupleK5.map3(Function1<? super C,? extends R> mapper, F... reified)
<R> TupleK5<F,A,B,R,D,E>	TupleK5.map3(Functor<F> functor, Function1<? super C,? extends R> mapper)
<R> TupleK4<F,A,B,C,R>	TupleK4.map4(Function1<? super D,? extends R> mapper, F... reified)
<R> TupleK4<F,A,B,C,R>	TupleK4.map4(Functor<F> functor, Function1<? super D,? extends R> mapper)
<R> TupleK5<F,A,B,C,R,E>	TupleK5.map4(Function1<? super D,? extends R> mapper, F... reified)
<R> TupleK5<F,A,B,C,R,E>	TupleK5.map4(Functor<F> functor, Function1<? super D,? extends R> mapper)
<R> TupleK5<F,A,B,C,D,R>	TupleK5.map5(Function1<? super E,? extends R> mapper, F... reified)
<R> TupleK5<F,A,B,C,D,R>	TupleK5.map5(Functor<F> functor, Function1<? super E,? extends R> mapper)
<B> Kind<F,B>	MonadDeferReference.modify(Function1<A,Tuple2<B,A>> change)
<B> Kind<F,B>	Reference.modify(Function1<A,Tuple2<B,A>> change)
default <T extends Kind<T, ?>, A, B> Kind<F,Kind<T,B>>	Parallel.parTraverse(Traverse<T> traverse, Kind<T,? extends A> value, Function1<? super A,? extends Kind<F,? extends B>> mapper)
default <A> Kind<F,A>	MonadReader.reader(Function1<? super R,? extends A> mapper)
default <A> Kind<F,A>	MonadState.state(Function1<? super S,Tuple2<S,? extends A>> mapper)
default <T, R> Kind<F,R>	Monad.tailRecM(T value, Function1<T,? extends Kind<F,Either<T,R>>> map)
default <H extends Kind<H, ?>, T, R> Kind<H,Kind<Nested<F,G>,R>>	ComposedTraverse.traverse(Applicative<H> applicative, Kind<Nested<F,G>,T> value, Function1<? super T,? extends Kind<H,? extends R>> mapper)
<G extends Kind<G, ?>, T, R> Kind<G,Kind<F,R>>	Traverse.traverse(Applicative<G> applicative, Kind<F,T> value, Function1<? super T,? extends Kind<G,? extends R>> mapper)
default <A, B> Schedule<F,A,B>	Schedule.Of.unfoldM(Kind<F,B> initial, Function1<B,Kind<F,Either<Unit,B>>> next)
static <F extends Kind<F, ?>, A, B> Schedule<F,A,B>	Schedule.unfoldM(Kind<F,B> initial, Function1<B,Kind<F,Either<Unit,B>>> next, F... reified)
Schedule<F,A,B>	Schedule.untilInputM(Function1<A,Kind<F,Boolean>> condition)
Schedule<F,A,B>	ScheduleImpl.untilInputM(Function1<A,Kind<F,Boolean>> condition)
Schedule<F,A,B>	Schedule.untilOutputM(Function1<B,Kind<F,Boolean>> condition)
Schedule<F,A,B>	ScheduleImpl.untilOutputM(Function1<B,Kind<F,Boolean>> condition)
private ScheduleImpl<F,S,A,B>	ScheduleImpl.updated(Function1<Schedule.Update<F,S,A>,Schedule.Update<F,S,A>> update)
<R> Kind<F,R>	Resource.use(Function1<? super T,? extends Kind<F,? extends R>> use)
default Schedule<F,A,B>	Schedule.whileInputM(Function1<A,Kind<F,Boolean>> condition)
default Schedule<F,A,B>	Schedule.whileOutputM(Function1<B,Kind<F,Boolean>> condition)

Constructors in com.github.tonivade.purefun.typeclasses with parameters of type Function1

Modifier	Constructor	Description
protected	AbstractFlatMap(Monad<F> monad, Function1<? super A,? extends Kind<F,? extends B>> value)
(package private)	FlatMap2(Monad<F> monad, Producer<? extends Kind<F,? extends A>> value1, Function1<? super A,? extends Kind<F,? extends B>> value2)
(package private)	FlatMap3(Monad<F> monad, Producer<? extends Kind<F,? extends A>> value1, Function1<? super A,? extends Kind<F,? extends B>> value2, Function1<? super B,? extends Kind<F,? extends C>> value3)
(package private)	FlatMap4(Monad<F> monad, Producer<? extends Kind<F,? extends A>> value1, Function1<? super A,? extends Kind<F,? extends B>> value2, Function1<? super B,? extends Kind<F,? extends C>> value3, Function1<? super C,? extends Kind<F,? extends D>> value4)
(package private)	FlatMap5(Monad<F> monad, Producer<? extends Kind<F,? extends A>> value1, Function1<? super A,? extends Kind<F,? extends B>> value2, Function1<? super B,? extends Kind<F,? extends C>> value3, Function1<? super C,? extends Kind<F,? extends D>> value4, Function1<? super D,? extends Kind<F,? extends E>> value5)