# Package com.jnape.palatable.lambda.functions.builtin.fn2

- Class Summary
  Class | Description
  --- | ---
  All<A> | Eagerly apply a predicate to each element in an `Iterable`, returning `true` if every element satisfies the predicate, and `false` otherwise.
  Alter<A> | Given an ``Effect`<A>` and some `A`, produce an `IO` that, when run, performs the effect on `A` and returns it.
  Any<A> | Eagerly apply a predicate to each element in an `Iterable`, returning `true` if any element satisfies the predicate, and `false` otherwise.
  AutoBracket<A extends AutoCloseable,B> | Given an `IO` yielding some `AutoCloseable` type `A` and a kleisli arrow from that type to a new `IO` of type `B`, attempt to provision the `A`, applying the body operation if provisioning was successful and ensuring that `AutoCloseable.close()` is called regardless of whether the body succeeds or fails.
  Both<A,B,C> | Given two functions `f` and `g`, produce a ``Fn1`<A, `Tuple2`<B, C>>` (the dual application of both functions).
  CartesianProduct<A,B> | Lazily compute the cartesian product of an `Iterable<A>` and `Iterable<B>`, returning an `Iterable<Tuple2<A, B>>`, the products as tuples of multiplicand `A`s and multiplier `B`s.
  CmpEq<A extends Comparable<A>> | Given two `Comparable` values of type `A`, return `true` if the first value is strictly equal to the second value (according to `Comparable.compareTo(Object)`; otherwise, return false.
  Cons<A> | Prepend an element to an `Iterable`.
  Difference<A> | Given two `Iterables` `xs` and `ys`, return the `distinct` elements of `xs` that are not in `ys`.
  Drop<A> | Lazily skip the first `n` elements from an `Iterable` by returning an `Iterable` that begins iteration after the `nth` element.
  DropWhile<A> | Lazily limit the `Iterable` by skipping the first contiguous group of elements that satisfy the predicate, beginning iteration at the first element for which the predicate evaluates to `false`.
  Eq<A> | Type-safe equality in function form; uses `Object.equals(java.lang.Object)`, not `==`.
  Filter<A> | Lazily apply a predicate to each element in an `Iterable`, returning an `Iterable` of just the elements for which the predicate evaluated to `true`.
  Find<A> | Iterate the elements in an `Iterable`, applying a predicate to each one, returning the first element that matches the predicate, wrapped in a `Maybe`.
  GroupBy<K,V> | Given an `Iterable<V>` `vs` and a key function `V -> K` `f`, fold `vs` into a `Map<K, List<V>>` by applying `f` to each element of `vs`, retaining values that map to the same key in a list, in the order they were iterated in.
  GT<A extends Comparable<A>> | Given two `Comparable` values of type `A`, return `true` if the second value is strictly greater than the first value; otherwise, return false.
  GTE<A extends Comparable<A>> | Given two `Comparable` values of type `A`, return `true` if the second value is greater than or equal to the first value according to `Comparable.compareTo(Object)`; otherwise, return false.
  InGroupsOf<A> | Lazily group the `Iterable` by returning an `Iterable` of smaller `Iterable`s of size `k`.
  Intersperse<A> | Lazily inject the provided separator value between each value in the supplied `Iterable`.
  Into<A,B,C> | Given an ``Fn2`<A, B, C>` and a ``Map.Entry`<A, B>`, destructure the entry and apply the key and value as arguments to the function, returning the result.
  Into1<A,B> | Given an ``Fn1`<A, B>` and a ``SingletonHList`<A>`, pop the head and apply it to the function, returning the result.
  Into3<A,B,C,D> | Given an ``Fn3`<A, B, C, D>` and a ``Product3`<A, B, C>`, destructure the product and apply the slots as arguments to the function, returning the result.
  Into4<A,B,C,D,E> | Given an ``Fn4`<A, B, C, D, E>` and a ``Product4`<A, B, C, D>`, destructure the product and apply the slots as arguments to the function, returning the result.
  Into5<A,B,C,D,E,F> | Given an ``Fn5`<A, B, C, D, E, F>` and a ``Product5`<A, B, C, D, E>`, destructure the product and apply the slots as arguments to the function, returning the result.
  Into6<A,B,C,D,E,F,G> | Given an ``Fn6`<A, B, C, D, E, F, G>` and a ``Product6`<A, B, C, D, E, F>`, destructure the product and apply the slots as arguments to the function, returning the result.
  Into7<A,B,C,D,E,F,G,H> | Given an ``Fn7`<A, B, C, D, E, F, G, H>` and a ``Product7`<A, B, C, D, E, F, G>`, destructure the product and apply the slots as arguments to the function, returning the result.
  Into8<A,B,C,D,E,F,G,H,I> | Given an ``Fn8`<A, B, C, D, E, F, G, H, I>` and a ``Product8`<A, B, C, D, E, F, G, H>`, destructure the product and apply the slots as arguments to the function, returning the result.
  Iterate<A> | Lazily generate an infinite `Iterable` from the successive applications of the function first to the initial seed value, then to the result, and so on; i.e., the result of `iterate(x -> x + 1, 0)` would produce an infinite `Iterable` over the elements `0, 1, 2, 3, ...`
  LazyRec<A,B> | Given a `Fn2` that receives a recursive function and an input and yields a `lazy` result, and an input, produce a `lazy` result that, when forced, will recursively invoke the function until it terminates in a stack-safe way.
  LT<A extends Comparable<A>> | Given two `Comparable` values of type `A`, return `true` if the second value is strictly less than the first value; otherwise, return false.
  LTE<A extends Comparable<A>> | Given two `Comparable` values of type `A`, return `true` if the second value is less than or equal to the first value according to `Comparable.compareTo(Object)` otherwise, return false.
  MagnetizeBy<A> | Given a binary predicate and an ``Iterable`<A>`, return an ``Iterable`<`Iterable`<A>>` of the contiguous groups of elements that match the predicate pairwise.
  Map<A,B> | Lazily apply a function to each element in an `Iterable`, producing an `Iterable` of the mapped results.
  Partition<A,B,C> | Given an `Iterable<A>` `as` and a disjoint mapping function `a -> CoProduct2<A, B>`, return a `Tuple2` over the lazily unwrapped left `A` and right `B` values in the first and second slots, respectively.
  Peek<A,FA extends Functor<A,?>> | Deprecated in favor of producing an `IO` from the given `Functor` and explicitly running it
  Peek2<A,B,FAB extends BoundedBifunctor<A,B,? super A,? super B,?>> | Deprecated in favor of producing an `IO` from the given `BoundedBifunctor` and explicitly running it
  PrependAll<A> | Lazily prepend each value with of the `Iterable` with the supplied separator value.
  ReduceLeft<A> | Given an ``Iterable`<A>` and a ``Fn2`<A, A, A>`, iteratively accumulate over the `Iterable`, returning ``Maybe`<A>`.
  ReduceRight<A> | Given an ``Iterable`<A>` and a ``Fn2`<A, A, A>`, iteratively accumulate over the `Iterable`, returning ``Maybe`<A>`.
  Replicate<A> | Produce an `Iterable` of a value `n` times.
  Sequence<A,App extends Applicative<?,App>,Trav extends Traversable<?,Trav>,TravA extends Traversable<A,Trav>,AppTrav extends Applicative<TravA,App>> | Given a `Traversable` of `Applicative`s and a pure `Applicative` constructor, traverse the elements from left to right, zipping the `Applicative`s together and collecting the results.
  Slide<A> | Given an ``Iterable`<A>`, "slide" a window of `k` elements across the `Iterable` by one element at a time, returning an ``Iterable`<`Iterable`<A>>`.
  Snoc<A> | Opposite of `Cons`: lazily append an element to the end of the given `Iterable`.
  SortBy<A,B extends Comparable<B>> | Given an `Iterable` and some mapping function from the `Iterable` element type to some `Comparable` type, produce a sorted `List` of the original elements based on sorting applied to the result of the mapping function.
  SortWith<A> | Given an `Iterable` and a `Comparator` over the `Iterable` element type, produce a sorted `List` of the original elements based on sorting applied by the `Comparator`.
  Span<A> | Given a predicate, return a `Tuple2` where the first slot is the front contiguous elements of an `Iterable` matching the predicate and the second slot is all the remaining elements.
  Take<A> | Lazily limit the `Iterable` to `n` elements by returning an `Iterable` that stops iteration after the `nth` element, or the last element of the `Iterable`, whichever comes first.
  TakeWhile<A> | Lazily limit the `Iterable` to the first group of contiguous elements that satisfy the predicate by iterating up to, but not including, the first element for which the predicate evaluates to `false`.
  ToArray<A> | Write all the elements of an `Iterable` directly into an array of the specified type.
  ToCollection<A,C extends Collection<A>> | Given an `Fn0` of some `Collection` `C`, create an instance of `C` and add all of the elements in the provided `Iterable` to the instance.
  ToMap<K,V,M extends Map<K,V>> | Given an `Fn0` of some `Map` `M`, create an instance of `M` and put all of the entries in the provided `Iterable` into the instance.
  Tupler2<A,B> | Creates a `Tuple2` from two values.
  Unfoldr<A,B> | Given an initial seed value and a function that takes the seed type and produces an ``Maybe`<`Tuple2`<X, Seed>>`, where the tuple's first slot represents the next `Iterable` element, and the second slot represents the next input to the unfolding function, unfold an `Iterable` of `X`s.
  Until<A> | Given a `predicate function` for a value of some type `A` and an `IO` that yields a value of type `A`, produce an `IO` that repeatedly executes the original `IO` until the predicate returns true when applied to the yielded value.
  Zip<A,B> | Zip together two `Iterable`s into a single `Iterable` of `Tuple2<A, B>`.