Uses of Class
fj.Unit

Packages that use Unit

Package	Description
fj	Types that set the premise for the existence of Functional Java.
fj.control.parallel	Parallelization strategies.
fj.data	Common algebraic data types.
fj.data.hlist	Type-safe, extensible, heterogeneous lists
fj.function	A prelude of commonly used first-class functions
fj.parser	Parser combinators.

Uses of Unit in fj

Fields in fj with type parameters of type Unit

Modifier and Type	Field	Description
static final Monoid<Unit>	Monoid.unitMonoid	A monoid for the Unit value.
static final Ord<Unit>	Ord.unitOrd	An order instance for the Unit type.
static final Semigroup<Unit>	Semigroup.unitSemigroup	A semigroup for the Unit value.

Methods in fj that return Unit

Modifier and Type	Method	Description
Unit	Show.print(A a)	Prints the given argument to the standard output stream.
Unit	Show.println(A a)	Prints the given argument to the standard output stream with a new line.
static Unit	Unit.unit()	The only value of the unit type.

Methods in fj that return types with arguments of type Unit

Modifier and Type	Method	Description
static P1<Unit>	Effect.f(Effect0 e)
static <A> F<A,Unit>	Effect.f(Effect1<A> e1)	Returns a function for the given effect.
static <A,B> F2<A,B,Unit>	Effect.f(Effect2<A,B> e)
static <A,B,C> F3<A,B,C,Unit>	Effect.f(Effect3<A,B,C> e)
static <A,B,C,D> F4<A,B,C,D,Unit>	Effect.f(Effect4<A,B,C,D> e)
static <A,B,C,D,E> F5<A,B,C,D,E,Unit>	Effect.f(Effect5<A,B,C,D,E> z)
static <A,B,C,D,E,$F> F6<A,B,C,D,E,$F,Unit>	Effect.f(Effect6<A,B,C,D,E,$F> z)
static <A,B,C,D,E,$F,G> F7<A,B,C,D,E,$F,G,Unit>	Effect.f(Effect7<A,B,C,D,E,$F,G> z)
static <A,B,C,D,E,$F,G,H> F8<A,B,C,D,E,$F,G,H,Unit>	Effect.f(Effect8<A,B,C,D,E,$F,G,H> z)
static <A, Z extends Exception> P1<Validation<Z,Unit>>	TryEffect.f(TryEffect0<Z> t)
static <A, Z extends Exception> F<A, Validation<Z,Unit>>	TryEffect.f(TryEffect1<A,Z> t)
static <A, B, Z extends Exception> F2<A, B, Validation<Z,Unit>>	TryEffect.f(TryEffect2<A,B,Z> t)
static <A, B, C, Z extends Exception> F3<A, B, C, Validation<Z,Unit>>	TryEffect.f(TryEffect3<A,B,C,Z> t)
static <A, B, C, D, Z extends Exception> F4<A, B, C, D, Validation<Z,Unit>>	TryEffect.f(TryEffect4<A,B,C,D,Z> t)
static <A, B, C, D, E, Z extends Exception> F5<A, B, C, D, E, Validation<Z,Unit>>	TryEffect.f(TryEffect5<A,B,C,D,E,Z> t)
static <A, B, C, D, E, $F, Z extends Exception> F6<A, B, C, D, E, $F, Validation<Z,Unit>>	TryEffect.f(TryEffect6<A,B,C,D,E,$F,Z> t)
static <A, B, C, D, E, $F, G, Z extends Exception> F7<A, B, C, D, E, $F, G, Validation<Z,Unit>>	TryEffect.f(TryEffect7<A,B,C,D,E,$F,G,Z> t)
static <A, B, C, D, E, $F, G, H, Z extends Exception> F8<A, B, C, D, E, $F, G, H, Validation<Z,Unit>>	TryEffect.f(TryEffect8<A,B,C,D,E,$F,G,H,Z> t)

Method parameters in fj with type arguments of type Unit

Modifier and Type	Method	Description
static <A> Effect1<A>	Effect.lazy(F<A,Unit> f)
static <A> P1<A>	P.lazy(F<Unit,A> f)
static <A,B> P2<A,B>	P.lazy(F<Unit,A> fa, F<Unit,B> fb)
static <A,B,C> P3<A,B,C>	P.lazy(F<Unit,A> fa, F<Unit,B> fb, F<Unit,C> fc)
static <A,B,C,D> P4<A,B,C,D>	P.lazy(F<Unit,A> fa, F<Unit,B> fb, F<Unit,C> fc, F<Unit,D> fd)
static <A,B,C,D,E> P5<A,B,C,D,E>	P.lazy(F<Unit,A> fa, F<Unit,B> fb, F<Unit,C> fc, F<Unit,D> fd, F<Unit,E> fe)
static <A,B,C,D,E,F$> P6<A,B,C,D,E,F$>	P.lazy(F<Unit,A> fa, F<Unit,B> fb, F<Unit,C> fc, F<Unit,D> fd, F<Unit,E> fe, F<Unit,F$> ff)
static <A,B,C,D,E,F$,G> P7<A,B,C,D,E,F$,G>	P.lazy(F<Unit,A> fa, F<Unit,B> fb, F<Unit,C> fc, F<Unit,D> fd, F<Unit,E> fe, F<Unit,F$> ff, F<Unit,G> fg)
static <A,B,C,D,E,F$,G,H> P8<A,B,C,D,E,F$,G,H>	P.lazy(F<Unit,A> fa, F<Unit,B> fb, F<Unit,C> fc, F<Unit,D> fd, F<Unit,E> fe, F<Unit,F$> ff, F<Unit,G> fg, F<Unit,H> fh)
default F<A, Promise<B>>	F.promiseK(Strategy<Unit> s)	Promotes this function to a concurrent function that returns a Promise of a value.

Uses of Unit in fj.control.parallel

Methods in fj.control.parallel that return types with arguments of type Unit

Modifier and Type	Method	Description
P1<Unit>	Actor.act(A a)	Pass a message to this actor, applying its side-effect to the message.

Method parameters in fj.control.parallel with type arguments of type Unit

Modifier and Type	Method	Description
static <A> Actor<A>	Actor.actor(Strategy<Unit> s, F<A,P1<Unit>> e)	Creates a new Actor that uses the given parallelization strategy and has the given side-effect.
static <A> Actor<A>	Actor.actor(Strategy<Unit> s, F<A,P1<Unit>> e)	Creates a new Actor that uses the given parallelization strategy and has the given side-effect.
static <A> Actor<A>	Actor.actor(Strategy<Unit> s, Effect1<A> e)	Creates a new Actor that uses the given parallelization strategy and has the given side-effect.
static <A,B> F<List<A>, Promise<B>>	Promise.foldRight(Strategy<Unit> s, F<A,F<B,B>> f, B b)	Performs a right-fold reduction across a list in constant stack space.
static <A,B> F<Stream<A>, Promise<B>>	Promise.foldRightS(Strategy<Unit> s, F<A, F<P1<B>,B>> f, B b)	Performs a right-fold reduction across a Stream in constant stack space.
static <A> Promise<A>	Promise.join(Strategy<Unit> s, P1<Promise<A>> p)	Turns a product of a promise into just a promise.
static ParModule	ParModule.parModule(Strategy<Unit> u)	Constructor method for ParModule
static <A> F<P1<A>, Promise<A>>	Promise.promise(Strategy<Unit> s)	Provides a first-class unit function for promises.
static <A,B> F<A, Promise<B>>	Promise.promise(Strategy<Unit> s, F<A,B> f)	Transforms any function so that it returns a promise of a value instead of an actual value.
static <A> Promise<A>	Promise.promise(Strategy<Unit> s, P1<A> a)	Promises to provide the value of the given 1-product, in the future.
static <A> Promise<Callable<A>>	Promise.promise(Strategy<Unit> s, Callable<A> a)	Provides a promise to call the given Callable in the future.
static <T> Actor<T>	Actor.queueActor(Strategy<Unit> s, Effect1<T> ea)	An Actor equipped with a queue and which is guaranteed to process one message at a time.
static <A> F<List<Promise<A>>, Promise<List<A>>>	Promise.sequence(Strategy<Unit> s)	First-class version of the sequence function through a List.
static <A> Promise<List<A>>	Promise.sequence(Strategy<Unit> s, List<Promise<A>> as)	Turns a List of promises into a single promise of a List.
static <A> Promise<Stream<A>>	Promise.sequence(Strategy<Unit> s, Stream<Promise<A>> as)	Turns a Stream of promises into a single promise of a Stream.
static <A> Promise<P1<A>>	Promise.sequence(Strategy<Unit> s, P1<Promise<A>> p)	Transforms a product of a promise to a promise of a product.
static <A> F<List<Promise<A>>, Promise<List<A>>>	Promise.sequenceS(Strategy<Unit> s)	First-class version of the sequence function through a Stream.

Uses of Unit in fj.data

Fields in fj.data with type parameters of type Unit

Modifier and Type	Field	Description
static final F<Reader,IO<Unit>>	IOFunctions.closeReader
static final IO<Unit>	IOFunctions.ioUnit

Methods in fj.data that return Unit

Modifier and Type	Method	Description
Unit	Array.foreach(F<A,Unit> f)	Performs a side-effect for each element of this array.
Unit	Array.ImmutableProjection.foreach(F<A,Unit> f)	Performs a side-effect for each element of this array.
Unit	Either.LeftProjection.foreach(F<A,Unit> f)	Execute a side-effect on this projection's value if it has one.
Unit	Either.RightProjection.foreach(F<B,Unit> f)	Execute a side-effect on this projection's value if it has one.
Unit	Either3.LeftProjection.foreach(F<A,Unit> f)
Unit	Either3.MiddleProjection.foreach(F<B,Unit> f)
Unit	Either3.RightProjection.foreach(F<C,Unit> f)
final Unit	List.foreach(F<A,Unit> f)	Performs a side-effect for each element of this list.
final Unit	Option.foreach(F<A,Unit> f)	Performs a side-effect for the value of this optional value.
final Unit	Stream.foreach(F<A,Unit> f)	Performs a side-effect for each element of this stream.
Unit	Validation.FailProjection.foreach(F<E,Unit> f)	Executes a side-effect on the failing value if there is one.
final Unit	Validation.foreach(F<T,Unit> f)	Executes a side-effect on the success value if there is one.
Unit	Array.set(int index, A a)	Sets the element at the given index to the given value.

Methods in fj.data that return types with arguments of type Unit

Modifier and Type	Method	Description
static IO<Unit>	IOFunctions.closeReader(Reader r)
static <A> F<Consumer<A>, F<A,Unit>>	Java8.Consumer_F()
static <A> F<A,Unit>	Java8.Consumer_F(Consumer<A> c)
static <E> Iteratee.IterV<E,Unit>	Iteratee.IterV.drop(int n)	An iteratee that skips the first n elements of the input
static F<Effect0,IO<Unit>>	Conversions.Effect_IO()
static IO<Unit>	Conversions.Effect_IO(Effect0 e)
static F<Effect0, SafeIO<Unit>>	Conversions.Effect_SafeIO()
static SafeIO<Unit>	Conversions.Effect_SafeIO(Effect0 e)
static F<Effect0,P1<Unit>>	Conversions.Effect0_P1()
static P1<Unit>	Conversions.Effect0_P1(Effect0 e)
static <A> F<Effect1<A>, F<A,Unit>>	Conversions.Effect1_F()
static <A> F<A,Unit>	Conversions.Effect1_F(Effect1<A> e)
static <A> F<F<Unit,A>, SafeIO<A>>	Conversions.F_SafeIO()
static IO<Unit>	IO.interact(F<LazyString, LazyString> f)
static IO<Unit>	IOFunctions.interact(F<LazyString, LazyString> f)
static IO<Unit>	IOFunctions.interactWhile(F<String,Boolean> condition, F<String,String> transform)	Read lines from stdin until condition is not met, transforming each line and printing the result to stdout.
static <S> State<S,Unit>	State.modify(F<S,S> f)
static <A> Prism<List<A>,Unit>	List.Optic.nil()	Nil prism
static <A> Prism<Option<A>, Unit>	Option.Optic.none()	None prism
static <S> State<S,Unit>	State.put(S s)
static IO<Unit>	IOFunctions.stdoutPrint(String s)
static IO<Unit>	IOFunctions.stdoutPrintln(String s)
static <E extends Exception> P1<Validation<E,Unit>>	Conversions.TryEffect_P(TryEffect0<E> t)
static IO<Unit>	IOFunctions.unless(Boolean b, IO<Unit> io)
static <A> IO<Unit>	IOFunctions.voided(IO<A> io)
static IO<Unit>	IOFunctions.when(Boolean b, IO<Unit> io)

Method parameters in fj.data with type arguments of type Unit

Modifier and Type	Method	Description
static <A> SafeIO<A>	Conversions.F_SafeIO(F<Unit,A> f)
Unit	Array.foreach(F<A,Unit> f)	Performs a side-effect for each element of this array.
Unit	Array.ImmutableProjection.foreach(F<A,Unit> f)	Performs a side-effect for each element of this array.
Unit	Either.LeftProjection.foreach(F<A,Unit> f)	Execute a side-effect on this projection's value if it has one.
Unit	Either.RightProjection.foreach(F<B,Unit> f)	Execute a side-effect on this projection's value if it has one.
Unit	Either3.LeftProjection.foreach(F<A,Unit> f)
Unit	Either3.MiddleProjection.foreach(F<B,Unit> f)
Unit	Either3.RightProjection.foreach(F<C,Unit> f)
void	HashMap.foreach(F<P2<K,V>,Unit> function)
final Unit	List.foreach(F<A,Unit> f)	Performs a side-effect for each element of this list.
final Unit	Option.foreach(F<A,Unit> f)	Performs a side-effect for the value of this optional value.
final Unit	Stream.foreach(F<A,Unit> f)	Performs a side-effect for each element of this stream.
Unit	Validation.FailProjection.foreach(F<E,Unit> f)	Executes a side-effect on the failing value if there is one.
final Unit	Validation.foreach(F<T,Unit> f)	Executes a side-effect on the success value if there is one.
static <A> IO<A>	IOFunctions.lazy(F<Unit,A> f)
static <A> SafeIO<A>	IOFunctions.lazySafe(F<Unit,A> f)
final Stream<A>	Stream.sort(Ord<A> o, Strategy<Unit> s)	Sort this stream according to the given ordering, using a parallel Quick Sort algorithm that uses the given parallelisation strategy.
static IO<Unit>	IOFunctions.unless(Boolean b, IO<Unit> io)
static IO<Unit>	IOFunctions.when(Boolean b, IO<Unit> io)

Uses of Unit in fj.data.hlist

Methods in fj.data.hlist that return types with arguments of type Unit

Modifier and Type	Method	Description
static <X,Y,Z> HList.Apply<Unit, P2<F<X,Y>,F<Y,Z>>, F<X,Z>>	HList.Apply.comp()	A function application operator for function composition.
static <E, L extends HList<L>> HList.Apply<Unit, P2<E,L>, HList.HCons<E,L>>	HList.Apply.cons()	An operator for the construction of heterogeneous lists.
abstract <E> HList.Apply<Unit, P2<E,A>, HList.HCons<E,A>>	HList.extender()
<X> HList.Apply<Unit, P2<X, HList.HCons<E,L>>, HList.HCons<X, HList.HCons<E,L>>>	HList.HCons.extender()
<E> HList.Apply<Unit, P2<E, HList.HNil>, HList.HCons<E, HList.HNil>>	HList.HNil.extender()
static <X> HList.Apply<Unit,X,X>	HList.Apply.id()	Identity operator

Uses of Unit in fj.function

Methods in fj.function that return types with arguments of type Unit

Modifier and Type	Method	Description
default P1<Unit>	Effect1.partial(A a)
default F<A,Unit>	Effect1.toF()
default F0<Unit>	Effect0.toF0()
default F2<A,B,Unit>	Effect2.toF2()
default P1<Unit>	Effect0.toP1()
default P1<Unit>	TryEffect0.toP1()
default <E extends Exception> Try0<Unit,E>	Effect0.toTry0()
default Try0<Unit,Z>	TryEffect0.toTry0()
default <Z extends Exception> Try1<A,Unit,Z>	Effect1.toTry1()

Method parameters in fj.function with type arguments of type Unit

Modifier and Type	Method	Description
default <B> F<A,B>	Effect1.andThen(F<Unit,B> f)
default <C> F<A,C>	Effect1.bind(F<Unit,F<A,C>> g)
static <A> Effect1<A>	Effect1.fromF(F<A,Unit> f)
default <C> F<A,C>	Effect1.map(F<Unit,C> f)

Uses of Unit in fj.parser

Methods in fj.parser that return types with arguments of type Unit

Modifier and Type	Method	Description
Parser<I,Unit,E>	Parser.not(E e)	Returns a parser that negates this parser.
Parser<I,Unit,E>	Parser.not(F0<E> e)	Returns a parser that negates this parser.