Uses of Interface
fj.F2

Packages that use F2
Package
Description
Types that set the premise for the existence of Functional Java.
Functional control abstractions.
Parallelization strategies.
Common algebraic data types.
Provides 2-3 finger trees, a functional representation of persistent sequences supporting access to the ends in amortized O(1) time.
 
Type-safe, extensible, heterogeneous lists
Fixed-length vectors
A prelude of commonly used first-class functions
 
  • Uses of F2 in fj

    Methods in fj that return F2
    Modifier and Type
    Method
    Description
    default F2<Array<A>,Array<B>,Array<C>>
    F2.arrayM()
    Promotes this function to a function on Arrays.
    default <X, Y> F2<X,Y,C>
    F2.contramap(F<X,A> f, F<Y,B> g)
     
    default <Z> F2<Z,B,C>
    F2.contramapFirst(F<Z,A> f)
     
    default <Z> F2<A,Z,C>
    F2.contramapSecond(F<Z,B> f)
     
    Equal.eq()
    First-class equality check.
    static <A, B> F2<A,B,Unit>
    Effect.f(Effect2<A,B> e)
     
    static <A, B, C, E extends Exception>
    F2<A,B,Validation<E,C>>
    Try.f(Try2<A,B,C,E> t)
    Promotes the Try2 to a Validation that returns an Exception on the failure side and its result on the success side.
    static <A, B, Z extends Exception>
    F2<A,B,Validation<Z,Unit>>
    TryEffect.f(TryEffect2<A,B,Z> t)
     
    default F2<B,A,C>
    F2.flip()
    Flips the arguments of this function.
    static <A, B, C> F2<B,A,C>
    Function.flip(F2<A,B,C> f)
    Function argument flipping.
    Promotes this function to a function on Iterables.
    default F2<List<A>,List<B>,List<C>>
    F2.listM()
    Promotes this function to a function on Lists.
    default <Z> F2<A,B,Z>
    F2.map(F<C,Z> f)
     
    F2.nelM()
    Promotes this function to a function on non-empty lists.
    default F2<Option<A>,Option<B>,Option<C>>
    F2.optionM()
    Promotes this function to a function on Options.
    default F2<Promise<A>,Promise<B>,Promise<C>>
    Promotes this function to a function on Promises.
    default F2<Set<A>,Set<B>,Set<C>>
    F2.setM(Ord<C> o)
    Promotes this function to a function on Sets.
    default F2<Stream<A>,Stream<B>,Stream<C>>
    F2.streamM()
    Promotes this function to a function on Streams.
    default F2<Tree<A>,Tree<B>,Tree<C>>
    F2.treeM()
    Promotes this function to a function on Trees.
    static <A, B, C> F2<A,B,C>
    Function.uncurryF2(F<A,F<B,C>> f)
    Uncurry a function of arity-2.
    static <A, B, C> F2<A,B,C>
    P2.untuple(F<P2<A,B>,C> f)
    Transforms a function of a product-2 to an uncurried function or arity-2.
    default F2<Array<A>,Array<B>,Array<C>>
    Promotes this function to zip two arrays, applying the function lock-step over both Arrays.
    Promotes this function to zip two iterables, applying the function lock-step over both iterables.
    default F2<List<A>,List<B>,List<C>>
    Promotes this function to zip two lists, applying the function lock-step over both lists.
    F2.zipNelM()
    Promotes this function to zip two non-empty lists, applying the function lock-step over both lists.
    default F2<Set<A>,Set<B>,Set<C>>
    F2.zipSetM(Ord<C> o)
    Promotes this function to zip two sets, applying the function lock-step over both sets.
    default F2<Stream<A>,Stream<B>,Stream<C>>
    Promotes this function to zip two streams, applying the function lock-step over both streams.
    default F2<Tree<A>,Tree<B>,Tree<C>>
    Promotes this function to zip two trees, applying the function lock-step over both trees.
    Promotes this function to zip two TreeZippers, applying the function lock-step over both zippers in all directions.
    default F2<Zipper<A>,Zipper<B>,Zipper<C>>
    Promotes this function to zip two zippers, applying the function lock-step over both zippers in both directions.
    Methods in fj that return types with arguments of type F2
    Modifier and Type
    Method
    Description
    static <A, B, C> F<F2<A,B,C>,F2<B,A,C>>
    Function.flip2()
    Function argument flipping.
    static <A, B, C> F<F2<A,B,C>,F2<B,A,C>>
    Function.flip2()
    Function argument flipping.
    static <A, B, C> F<F<A,F<B,C>>,F2<A,B,C>>
    Function.uncurryF2()
    Uncurry a function of arity-2.
    Methods in fj with parameters of type F2
    Modifier and Type
    Method
    Description
    static <A, B, C> F<C,B>
    Function.apply(F2<C,A,B> cab, F<C,A> ca)
    Performs function application within a higher-order function (applicative functor pattern).
    final <B, C> P1<C>
    P1.bind(P1<B> cb, F2<A,B,C> f)
    Binds the given function to the values in the given P1s with a final join.
    <B, C> Monoid<C>
    Monoid.compose(Monoid<B> mb, F<C,A> a, F<C,B> b, F2<A,B,C> c)
     
    <B, C> Semigroup<C>
    Semigroup.compose(Semigroup<B> sb, F<C,B> b, F<C,A> a, F2<A,B,C> c)
     
    static <A, B, C> F<A,F<B,C>>
    Function.curry(F2<A,B,C> f)
    Curry a function of arity-2.
    static <A, B, C> F<B,C>
    Function.curry(F2<A,B,C> f, A a)
    Curry a function of arity-2.
    static <A> Equal<A>
    Equal.equal(F2<A,A,Boolean> f)
    Constructs an equal instance from the given function.
    static <A, B, C> F2<B,A,C>
    Function.flip(F2<A,B,C> f)
    Function argument flipping.
    final <B, C> P1<C>
    P1.liftM2(P1<B> pb, F2<A,B,C> f)
     
    static <A> Monoid<A>
    Monoid.monoid(F2<A,A,A> sum, A zero)
    Constructs a monoid from the given sum function and zero value, which must follow the monoidal laws.
    static <A> Ord<A>
    Ord.ord(F2<A,A,Ordering> f)
    Returns an order instance that uses the given equality test and ordering function.
    static <A> Semigroup<A>
    Semigroup.semigroup(F2<A,A,A> sum)
    Constructs a semigroup from the given function.
    static <A, B, C> F<P2<A,B>,C>
    P2.tuple(F2<A,B,C> f)
    Transforms an uncurried function of arity-2 to a function of a product-2
  • Uses of F2 in fj.control

    Methods in fj.control with parameters of type F2
    Modifier and Type
    Method
    Description
    final <B, C> Trampoline<C>
    Trampoline.zipWith(Trampoline<B> b, F2<A,B,C> f)
    Combines two trampolines so they run cooperatively.
  • Uses of F2 in fj.control.parallel

    Methods in fj.control.parallel that return F2
    Modifier and Type
    Method
    Description
    <B, C> F2<Array<B>,Array<C>,P1<Array<A>>>
    Strategy.parZipArrayWith(F2<B,C,A> f)
    Lifts a given function of arity-2 so that it zips together two arrays in parallel, using this strategy, calling the function once for each corresponding pair in the arrays, position-wise.
    <B, C> F2<List<B>,List<C>,P1<List<A>>>
    Strategy.parZipListWith(F2<B,C,A> f)
    Lifts a given function of arity-2 so that it zips together two lists in parallel, using this strategy, calling the function once for each corresponding pair in the lists, position-wise.
    <A, B, C> F2<A,B,Promise<C>>
    ParModule.promise(F2<A,B,C> f)
    Promotes the given function to a concurrent function that returns a Promise.
    Methods in fj.control.parallel with parameters of type F2
    Modifier and Type
    Method
    Description
    <B, C> F<B,F<C,P1<A>>>
    Strategy.concurry(F2<B,C,A> f)
    Promotes a function of arity-2 to a concurrent function.
    <B, C> F2<Array<B>,Array<C>,P1<Array<A>>>
    Strategy.parZipArrayWith(F2<B,C,A> f)
    Lifts a given function of arity-2 so that it zips together two arrays in parallel, using this strategy, calling the function once for each corresponding pair in the arrays, position-wise.
    <B, C> F2<List<B>,List<C>,P1<List<A>>>
    Strategy.parZipListWith(F2<B,C,A> f)
    Lifts a given function of arity-2 so that it zips together two lists in parallel, using this strategy, calling the function once for each corresponding pair in the lists, position-wise.
    <B, C> P1<Array<A>>
    Strategy.parZipWith(F2<B,C,A> f, Array<B> bs, Array<C> cs)
    Zips together two arrays in parallel using a given function, with this strategy.
    <B, C> P1<List<A>>
    Strategy.parZipWith(F2<B,C,A> f, List<B> bs, List<C> cs)
    Zips together two lists in parallel using a given function, with this strategy.
    <A, B, C> F2<A,B,Promise<C>>
    ParModule.promise(F2<A,B,C> f)
    Promotes the given function to a concurrent function that returns a Promise.
  • Uses of F2 in fj.data

    Methods in fj.data that return F2
    Modifier and Type
    Method
    Description
    static <A, B, C> F2<A,B,C>
    Java8.BiFunction_F2(BiFunction<A,B,C> f)
     
    static <A> F2<A,List<A>,List<A>>
    List.cons_()
     
    static <A> F2<F<Tree<A>,Boolean>,TreeZipper<A>,Option<TreeZipper<A>>>
    TreeZipper.findChild()
    A first-class version of the findChild function.
    static <A> F2<F<A,Boolean>,A,Option<A>>
    Option.iif()
    First-class version of the iif function.
    static <A, B> F2<List<P2<A,B>>,A,Option<B>>
    List.lookup(Equal<A> e)
    Returns a partially applied version of List.lookup(Equal, List, Object).
    final <B> F2<Ord<B>,F<A,Set<B>>,Set<Option<B>>>
    Option.traverseSet()
     
    Methods in fj.data that return types with arguments of type F2
    Modifier and Type
    Method
    Description
    static <A, B, C> F<BiFunction<A,B,C>,F2<A,B,C>>
     
    static <A, B, C> F<F2<A,B,C>,BiFunction<A,B,C>>
     
    Methods in fj.data with parameters of type F2
    Modifier and Type
    Method
    Description
    final <B, C> Validation<List<E>,C>
    Validation.accumulate(Validation<E,B> v2, F2<T,B,C> f)
     
    final <A, B> Validation<E,B>
    Validation.accumulate(Semigroup<E> s, Validation<E,A> va, F2<T,A,B> f)
    Accumulates errors on the failing side of this or any given validation if one or more are encountered, or applies the given function if all succeeded and returns that value on the successful side.
    <B, C> Array<C>
    Array.bind(Array<B> sb, F2<A,B,C> f)
    Binds the given function across each element of this array and the given array with a final join.
    final <B, C> List<C>
    List.bind(List<B> lb, F2<A,B,C> f)
    Binds the given function across each element of this list and the given list with a final join.
    final <B, C> Stream<C>
    Stream.bind(Stream<B> sb, F2<A,B,C> f)
    Binds the given function across each element of this stream and the given stream with a final join.
    static <A, B, C> BiFunction<A,B,C>
    Java8.F2_BiFunction(F2<A,B,C> f)
     
    <B> B
    Array.foldLeft(F2<B,A,B> f, B b)
    Performs a left-fold reduction across this array.
    final <B> B
    List.foldLeft(F2<B,A,B> f, B b)
    Performs a left-fold reduction across this list.
    <B> B
    Seq.foldLeft(F2<B,A,B> f, B z)
     
    final <B> B
    Stream.foldLeft(F2<B,A,B> f, B b)
    Performs a left-fold reduction across this stream.
    IterableW.foldLeft1(F2<A,A,A> f)
    Takes the first 2 elements of the iterable and applies the function to them, then applies the function to the result and the third element and so on.
    final A
    List.foldLeft1(F2<A,A,A> f)
    Takes the first 2 elements of the list and applies the function to them, then applies the function to the result and the third element and so on.
    final A
    NonEmptyList.foldLeft1(F2<A,A,A> f)
    Performs a left-fold reduction across this list.
    final A
    Stream.foldLeft1(F2<A,A,A> f)
    Takes the first 2 elements of the stream and applies the function to them, then applies the function to the result and the third element and so on.
    <B> B
    Array.foldRight(F2<A,B,B> f, B b)
    Performs a right-fold reduction across this array.
    <B> B
    IterableW.foldRight(F2<A,B,B> f, B z)
    The catamorphism for Iterables, implemented as a right fold.
    final <B> B
    List.foldRight(F2<A,B,B> f, B b)
    Performs a right-fold reduction across this list.
    <B> B
    Seq.foldRight(F2<A,B,B> f, B z)
     
    final <B> B
    Stream.foldRight(F2<A,P1<B>,B> f, B b)
    Performs a right-fold reduction across this stream.
    final A
    NonEmptyList.foldRight1(F2<A,A,A> f)
    Performs a right-fold reduction across this list.
    final <B> B
    Stream.foldRight1(F2<A,B,B> f, B b)
    Performs a right-fold reduction across this stream.
    final <B> Trampoline<B>
    List.foldRightC(F2<A,B,B> f, B b)
    Performs a right-fold reduction across this list in O(1) stack space.
    final <B, C, D> TreeMap<B,D>
    List.groupBy(F<A,B> keyFunction, F<A,C> valueFunction, D groupingIdentity, F2<C,D,D> groupingAcc, Ord<B> keyOrd)
    Groups the elements of this list by a given keyFunction, applies the valueFunction and accumulates the mapped values with the given grouping accumulator function on the grouping identity.
    static <A, B, C> IO<C>
    IOFunctions.liftM2(IO<A> ioa, IO<B> iob, F2<A,B,C> f)
     
    final <B, C> Option<C>
    Option.liftM2(Option<B> ob, F2<A,B,C> f)
    Lift the function of arity-2 through options.
    <B> Array<B>
    Array.scanLeft(F2<B,A,B> f, B b)
    Performs a left-fold accummulating and returns an array of the intermediate results.
    Array.scanLeft1(F2<A,A,A> f)
    Performs a left-fold accummulating using first array element as a starting value and returns an array of the intermediate results.
    <B> Array<B>
    Array.scanRight(F2<A,B,B> f, B b)
    Performs a right-fold accummulating and returns an array of the intermediate results.
    Array.scanRight1(F2<A,A,A> f)
    Performs a right-fold accummulating using last array element as a starting value and returns an array of the intermediate results.
    final <B> B
    List.uncons(F2<A,List<A>,B> cons, B nil)
     
    <B> B
    PriorityQueue.unqueue(B empty, F2<P2<K,A>,PriorityQueue<K,A>,B> topDequeue)
    Performs a reduction on this priority queue using the given arguments.
    <B, C> Array<C>
    Array.zipWith(Array<B> bs, F2<A,B,C> f)
    Zips this array with the given array using the given function to produce a new array.
    <B, C> Iterable<C>
    IterableW.zipWith(Iterable<B> bs, F2<A,B,C> f)
    Zips this iterable with the given iterable using the given function to produce a new iterable.
    final <B, C> List<C>
    List.zipWith(List<B> bs, F2<A,B,C> f)
    Zips this list with the given list using the given function to produce a new list.
    <B, C> NonEmptyList<C>
    NonEmptyList.zipWith(List<B> bs, F2<A,B,C> f)
    Zips this non empty list with the given non empty list using the given function to produce a new list.
    final <B, C> Stream<C>
    Stream.zipWith(Stream<B> bs, F2<A,B,C> f)
    Zips this stream with the given stream using the given function to produce a new stream.
    <B, C> Tree<C>
    Tree.zipWith(Tree<B> bs, F2<A,B,C> f)
    Zips this tree with another, using the given function.
    <B, C> TreeZipper<C>
    TreeZipper.zipWith(TreeZipper<B> bs, F2<A,B,C> f)
    Zips this TreeZipper with another, applying the given function lock-step over both zippers in all directions.
    <B, C> Zipper<C>
    Zipper.zipWith(Zipper<B> bs, F2<A,B,C> f)
    Zips this Zipper with another, applying the given function lock-step over both zippers in both directions.
  • Uses of F2 in fj.data.fingertrees

    Methods in fj.data.fingertrees with parameters of type F2
    Modifier and Type
    Method
    Description
    final <B> B
    FingerTree.foldLeft(F2<B,A,B> f, B z)
     
    final <B> B
    FingerTree.foldRight(F2<A,B,B> f, B z)
     
    final <B> B
    FingerTree.uncons(B nil, F2<A,FingerTree<V,A>,B> cons)
    Performs a reduction on this finger tree using the given arguments.
  • Uses of F2 in fj.data.hamt

    Methods in fj.data.hamt with parameters of type F2
    Modifier and Type
    Method
    Description
    <A> A
    BitSet.foldLeft(F2<A,Boolean,A> f, A acc)
     
    <B> B
    HashArrayMappedTrie.foldLeft(F2<B,P2<K,V>,B> f, B b)
    Performs a left-fold reduction across this trie.
    <B> B
    HashArrayMappedTrie.foldLeft(F2<B,P2<K,V>,B> f, F2<B,HashArrayMappedTrie<K,V>,B> g, B b)
    Performs a left-fold reduction across this trie.
    <B> B
    HashArrayMappedTrie.foldLeftOnNode(F2<B,Node<K,V>,B> f, B b)
    Performs a left-fold reduction across this trie.
    <A> A
    BitSet.foldRight(F2<Boolean,A,A> f, A acc)
     
  • Uses of F2 in fj.data.hlist

    Fields in fj.data.hlist declared as F2
    Modifier and Type
    Field
    Description
    private final F2<A,B,C>
    HList.HAppend.append
     
    Constructors in fj.data.hlist with parameters of type F2
    Modifier
    Constructor
    Description
    private
    HAppend(F2<A,B,C> f)
     
  • Uses of F2 in fj.data.vector

    Methods in fj.data.vector that return F2
    Modifier and Type
    Method
    Description
    static <A> F2<A,A,V2<A>>
    V.v2()
    Returns a function that puts elements in a vector-2.
  • Uses of F2 in fj.function

    Methods in fj.function that return F2
    Modifier and Type
    Method
    Description
    default F2<A,B,Unit>
    Effect2.toF2()
     
  • Uses of F2 in fj.java.util

    Methods in fj.java.util with parameters of type F2
    Modifier and Type
    Method
    Description
    static <A, B> B
    ListUtil.fold(List<A> list, F2<B,A,B> f, B b)