com.jnape.palatable.lambda.functions

## Interface Fn2<A,B,C>

- Type Parameters:
    `A` - The first argument type
    `B` - The second argument type
    `C` - The return type
  All Superinterfaces:
    Applicative<Fn1<B,C>,Fn1<A,?>>, Cartesian<A,Fn1<B,C>,Fn1<?,?>>, Cocartesian<A,Fn1<B,C>,Fn1<?,?>>, Contravariant<A,Profunctor<?,Fn1<B,C>,Fn1<?,?>>>, Fn1<A,Fn1<B,C>>, Functor<Fn1<B,C>,Fn1<A,?>>, Monad<Fn1<B,C>,Fn1<A,?>>, MonadReader<A,Fn1<B,C>,Fn1<A,?>>, MonadRec<Fn1<B,C>,Fn1<A,?>>, MonadWriter<A,Fn1<B,C>,Fn1<A,?>>, Profunctor<A,Fn1<B,C>,Fn1<?,?>>
  All Known Subinterfaces:
    BiMonoidFactory<A,B,C>, BiPredicate<A,B>, BiSemigroupFactory<A,B,C>, Fn3<A,B,C,D>, Fn4<A,B,C,D,E>, Fn5<A,B,C,D,E,F>, Fn6<A,B,C,D,E,F,G>, Fn7<A,B,C,D,E,F,G,H>, Fn8<A,B,C,D,E,F,G,H,I>, Monoid<A>, MonoidFactory<A,B>, Semigroup<A>, SemigroupFactory<A,B>
  All Known Implementing Classes:
    Absent, AddAll, All, Alter, And, Any, AutoBracket, Between, Both, Bracket, CartesianProduct, Clamp, CmpEq, CmpEqBy, Collapse, Collapse, Compose, Compose, Concat, Cons, Constantly, Difference, Drop, DropWhile, Endo, EndoK, Eq, Filter, Find, First, FoldLeft, FoldRight, GroupBy, GT, GTBy, GTE, GTEBy, IfThenElse, InGroupsOf, Intersection, Intersperse, Into, Into1, Into3, Into4, Into5, Into6, Into7, Into8, Iterate, Join, Last, LazyRec, LeftAll, LeftAll, LeftAny, LeftAny, LiftA2, LiftA3, LiftA4, LiftA5, LiftA6, LiftA7, LT, LTBy, LTE, LTEBy, MagnetizeBy, Map, Matching, Max, MaxBy, Merge, Merge, MergeMaps, Min, MinBy, Not, Or, Over, Partition, Peek, Peek2, PrependAll, Present, PutAll, RateLimit, ReduceLeft, ReduceRight, Replicate, RightAll, RightAll, RightAny, RightAny, RunAll, RunAll, ScanLeft, Sequence, Set, Slide, Snoc, SortBy, SortWith, Span, Take, TakeWhile, Times, ToArray, ToCollection, ToMap, Trampoline, Trivial, Tupler2, Under, Unfoldr, Union, Until, View, Xor, Zip, ZipWith
  Functional Interface:
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

      @FunctionalInterface
      public interface Fn2<A,B,C>
      extends Fn1<A,Fn1<B,C>>

  A function taking two arguments.

  Note that defining `Fn2` in terms of `Fn1` provides a reasonable approximation of currying in the form of multiple `apply(A, B)` overloads that take different numbers of arguments.

  See Also:
    `Fn1`

- - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `default Fn1<B,C>` | `apply(A a)` Partially apply this function by passing its first argument.
    `default C` | `apply(A a, B b)` Invoke this function with the given arguments.
    `default Fn1<B,C>` | `checkedApply(A a)` Invoke this function with the given argument, potentially throwing any `Throwable`.
    `C` | `checkedApply(A a, B b)`
    `default <Y,Z> Fn3<Y,Z,B,C>` | `compose(Fn2<? super Y,? super Z,? extends A> before)` Right-to-left composition between different arity functions.
    `default <Z> Fn2<Z,B,C>` | `contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `static <A,B,C> Fn2<A,B,C>` | `curried(Fn1<A,Fn1<B,C>> curriedFn1)` Static factory method for wrapping a curried `Fn1` in an `Fn2`.
    `static <A,B,C> Fn2<A,B,C>` | `curry(Fn1<? super Tuple2<A,B>,? extends C> uncurriedFn1)` Static factory method for wrapping an uncurried `Fn1` in an `Fn2`.
    `default <Z> Fn2<Z,B,C>` | `diMapL(Fn1<? super Z,? extends A> fn)` Contravariantly map over the argument to this function, producing a function that takes the new argument type, and produces the same result.
    `default <D> Fn2<A,B,C>` | `discardR(Applicative<D,Fn1<A,?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `default Fn2<B,A,C>` | `flip()` Flip the order of the arguments.
    `static <A,B,C> Fn2<A,B,C>` | `fn2(Fn2<A,B,C> fn2)` Static method to aid inference.
    `static <A,B,C> Fn2<A,B,C>` | `fromBiFunction(BiFunction<? super A,? super B,? extends C> biFunction)` Static factory method for wrapping a `BiFunction` in an `Fn2`.
    `default BiFunction<A,B,C>` | `toBiFunction()` View this `Fn2` as a `BiFunction`.
    `default Fn1<? super Product2<? extends A,? extends B>,C>` | `uncurry()` Returns an `Fn1` that takes the arguments as a ``Product2`<A, B>`.
    `default <Z> Fn3<Z,A,B,C>` | `widen()` Widen this function's argument list by prepending an ignored argument of any type to the front.

    - ### Methods inherited from interface com.jnape.palatable.lambda.functions.Fn1

      `andThen, carry, cartesian, censor, choose, cocartesian, diMap, diMapR, discardL, flatMap, fmap, fn1, fromFunction, lazyZip, listens, local, pure, pureFn1, thunk, toFunction, trampolineM, zip, zip`

    - ### Methods inherited from interface com.jnape.palatable.lambda.monad.Monad

      `join`

    - ### Methods inherited from interface com.jnape.palatable.lambda.functor.Functor

      `coerce`

- - ### Method Detail

    - #### checkedApply

          C checkedApply(A a,
                         B b)
                  throws Throwable

      Throws:
        `Throwable`

    - #### apply

          default C apply(A a,
                          B b)

      Invoke this function with the given arguments.
      Parameters:
        `a` - the first argument
        `b` - the second argument
      Returns:
        the result of the function application

    - #### checkedApply

          default Fn1<B,C> checkedApply(A a)
                                 throws Throwable

      Invoke this function with the given argument, potentially throwing any `Throwable`.
      Specified by:
        `checkedApply` in interface `Fn1<A,Fn1<B,C>>`
      Parameters:
        `a` - the argument
      Returns:
        the result of the function application
      Throws:
        `Throwable` - anything possibly thrown by the function

    - #### widen

          default <Z> Fn3<Z,A,B,C> widen()

      Widen this function's argument list by prepending an ignored argument of any type to the front.
      Specified by:
        `widen` in interface `Fn1<A,Fn1<B,C>>`
      Type Parameters:
        `Z` - the new first argument type
      Returns:
        the widened function

    - #### apply

          default Fn1<B,C> apply(A a)

      Partially apply this function by passing its first argument.
      Specified by:
        `apply` in interface `Fn1<A,Fn1<B,C>>`
      Parameters:
        `a` - the first argument
      Returns:
        an `Fn1`<B, C>

    - #### flip

          default Fn2<B,A,C> flip()

      Flip the order of the arguments.
      Returns:
        an `Fn2`<B, A, C>

    - #### uncurry

          default Fn1<? super Product2<? extends A,? extends B>,C> uncurry()

      Returns an `Fn1` that takes the arguments as a ``Product2`<A, B>`.
      Returns:
        an `Fn1` taking a `Product2`

    - #### toBiFunction

          default BiFunction<A,B,C> toBiFunction()

      View this `Fn2` as a `BiFunction`.
      Returns:
        the same logic as a `BiFunction`
      See Also:
        `BiFunction`

    - #### discardR

          default <D> Fn2<A,B,C> discardR(Applicative<D,Fn1<A,?>> appB)

      Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`. This is generally useful for sequentially performing side-effects.
      Specified by:
        `discardR` in interface `Applicative<Fn1<B,C>,Fn1<A,?>>`
      Specified by:
        `discardR` in interface `Fn1<A,Fn1<B,C>>`
      Specified by:
        `discardR` in interface `Monad<Fn1<B,C>,Fn1<A,?>>`
      Specified by:
        `discardR` in interface `MonadReader<A,Fn1<B,C>,Fn1<A,?>>`
      Specified by:
        `discardR` in interface `MonadRec<Fn1<B,C>,Fn1<A,?>>`
      Specified by:
        `discardR` in interface `MonadWriter<A,Fn1<B,C>,Fn1<A,?>>`
      Type Parameters:
        `D` - the type of appB's parameter
      Parameters:
        `appB` - the other Applicative
      Returns:
        this Applicative

    - #### diMapL

          default <Z> Fn2<Z,B,C> diMapL(Fn1<? super Z,? extends A> fn)

      Contravariantly map over the argument to this function, producing a function that takes the new argument type, and produces the same result.
      Specified by:
        `diMapL` in interface `Cartesian<A,Fn1<B,C>,Fn1<?,?>>`
      Specified by:
        `diMapL` in interface `Cocartesian<A,Fn1<B,C>,Fn1<?,?>>`
      Specified by:
        `diMapL` in interface `Fn1<A,Fn1<B,C>>`
      Specified by:
        `diMapL` in interface `Profunctor<A,Fn1<B,C>,Fn1<?,?>>`
      Type Parameters:
        `Z` - the new argument type
      Parameters:
        `fn` - the contravariant argument mapping function
      Returns:
        an `Fn1`<Z, B>

    - #### contraMap

          default <Z> Fn2<Z,B,C> contraMap(Fn1<? super Z,? extends A> fn)

      Contravariantly map `A <- B`.
      Specified by:
        `contraMap` in interface `Cartesian<A,Fn1<B,C>,Fn1<?,?>>`
      Specified by:
        `contraMap` in interface `Cocartesian<A,Fn1<B,C>,Fn1<?,?>>`
      Specified by:
        `contraMap` in interface `Contravariant<A,Profunctor<?,Fn1<B,C>,Fn1<?,?>>>`
      Specified by:
        `contraMap` in interface `Fn1<A,Fn1<B,C>>`
      Specified by:
        `contraMap` in interface `Profunctor<A,Fn1<B,C>,Fn1<?,?>>`
      Type Parameters:
        `Z` - the new parameter type
      Parameters:
        `fn` - the mapping function
      Returns:
        the mapped Contravariant functor instance

    - #### compose

          default <Y,Z> Fn3<Y,Z,B,C> compose(Fn2<? super Y,? super Z,? extends A> before)

      Right-to-left composition between different arity functions. Preserves highest arity in the return type.
      Specified by:
        `compose` in interface `Fn1<A,Fn1<B,C>>`
      Type Parameters:
        `Y` - the resulting function's first argument type
        `Z` - the resulting function's second argument type
      Parameters:
        `before` - the function to pass its return value to this function's input
      Returns:
        an `Fn2`<Y, Z, B>

    - #### fromBiFunction

          static <A,B,C> Fn2<A,B,C> fromBiFunction(BiFunction<? super A,? super B,? extends C> biFunction)

      Static factory method for wrapping a `BiFunction` in an `Fn2`.
      Type Parameters:
        `A` - the first input argument type
        `B` - the second input argument type
        `C` - the output type
      Parameters:
        `biFunction` - the biFunction to adapt
      Returns:
        the `Fn2`

    - #### curried

          static <A,B,C> Fn2<A,B,C> curried(Fn1<A,Fn1<B,C>> curriedFn1)

      Static factory method for wrapping a curried `Fn1` in an `Fn2`.
      Type Parameters:
        `A` - the first input argument type
        `B` - the second input argument type
        `C` - the output type
      Parameters:
        `curriedFn1` - the curried fn1 to adapt
      Returns:
        the `Fn2`

    - #### curry

          static <A,B,C> Fn2<A,B,C> curry(Fn1<? super Tuple2<A,B>,? extends C> uncurriedFn1)

      Static factory method for wrapping an uncurried `Fn1` in an `Fn2`.
      Type Parameters:
        `A` - the first input argument type
        `B` - the second input argument type
        `C` - the output type
      Parameters:
        `uncurriedFn1` - the uncurried `Fn1` to adapt
      Returns:
        the `Fn2`

    - #### fn2

          static <A,B,C> Fn2<A,B,C> fn2(Fn2<A,B,C> fn2)

      Static method to aid inference.
      Type Parameters:
        `A` - the first input type
        `B` - the second input type
        `C` - the output type
      Parameters:
        `fn2` - the `Fn2`
      Returns:
        the `Fn2`