Interface Fn3<A,B,C,D>

Type Parameters:
A - The first argument type
B - The second argument type
C - The third argument type
D - The return type
All Superinterfaces:
Applicative<Fn1<B,Fn1<C,D>>, Fn1<A,?>>, Cartesian<A, Fn1<B,Fn1<C,D>>, Fn1<?,?>>, Cocartesian<A, Fn1<B,Fn1<C,D>>, Fn1<?,?>>, Contravariant<A, Profunctor<?, Fn1<B,Fn1<C,D>>, Fn1<?,?>>>, Fn1<A, Fn1<B,Fn1<C,D>>>, Fn2<A,B,Fn1<C,D>>, Functor<Fn1<B,Fn1<C,D>>, Fn1<A,?>>, Monad<Fn1<B,Fn1<C,D>>, Fn1<A,?>>, MonadReader<A, Fn1<B,Fn1<C,D>>, Fn1<A,?>>, MonadRec<Fn1<B,Fn1<C,D>>, Fn1<A,?>>, MonadWriter<A, Fn1<B,Fn1<C,D>>, Fn1<A,?>>, Profunctor<A, Fn1<B,Fn1<C,D>>, Fn1<?,?>>
All Known Subinterfaces:
BiMonoidFactory<A,B,C>, BiSemigroupFactory<A,B,C>, 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>, MonoidFactory<A,B>, SemigroupFactory<A,B>
All Known Implementing Classes:
Absent, AddAll, Between, Both, Bracket, Clamp, CmpEqBy, CmpEqWith, Collapse, Collapse, Compare, Compose, Compose, EndoK, FoldLeft, FoldRight, GTBy, GTEBy, GTEWith, GTWith, IfThenElse, LeftAll, LeftAll, LeftAny, LeftAny, LiftA2, LiftA3, LiftA4, LiftA5, LiftA6, LiftA7, LTBy, LTEBy, LTEWith, LTWith, MaxBy, MaxWith, Merge, Merge, MergeMaps, MinBy, MinWith, Over, Peek2, Present, RateLimit, RightAll, RightAll, RightAny, RightAny, RunAll, RunAll, ScanLeft, Set, Times, Under, 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 Fn3<A,B,C,D> extends Fn2<A,B,Fn1<C,D>>
A function taking three arguments. Defined in terms of Fn2, so similarly auto-curried.
See Also:

  • Method Details

    • checkedApply

      D checkedApply(A a, B b, C c) throws Throwable
      Throws:
      Throwable

    • apply

      default D apply(A a, B b, C c)
      Invoke this function with the given arguments.
      Parameters:
      a - the first argument
      b - the second argument
      c - the third argument
      Returns:
      the result of the function application

    • checkedApply

      default Fn1<C,D> checkedApply(A a, B b) throws Throwable
      Specified by:
      checkedApply in interface Fn2<A,B,C>
      Throws:
      Throwable

    • widen

      default <Z> Fn4<Z,A,B,C,D> 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,B>
      Specified by:
      widen in interface Fn2<A,B,C>
      Type Parameters:
      Z - the new first argument type
      Returns:
      the widened function

    • apply

      default Fn2<B,C,D> apply(A a)
      Partially apply this function by taking its first argument.
      Specified by:
      apply in interface Fn1<A,B>
      Specified by:
      apply in interface Fn2<A,B,C>
      Parameters:
      a - the first argument
      Returns:
      an Fn2<B, C, D>

    • apply

      default Fn1<C,D> apply(A a, B b)
      Partially apply this function by taking its first two arguments.
      Specified by:
      apply in interface Fn2<A,B,C>
      Parameters:
      a - the first argument
      b - the second argument
      Returns:
      an Fn1<C, D>

    • flip

      default Fn3<B,A,C,D> flip()
      Flip the order of the first two arguments.
      Specified by:
      flip in interface Fn2<A,B,C>
      Returns:
      an Fn3<B, A, C, D>

    • uncurry

      default Fn2<? super Product2<? extends A, ? extends B>, C, D> uncurry()
      Returns an Fn2 that takes the first two arguments as a Product2<A, B> and the third argument.
      Specified by:
      uncurry in interface Fn2<A,B,C>
      Returns:
      an Fn2 taking a Product2 and the third argument

    • discardR

      default <E> Fn3<A,B,C,D> discardR(Applicative<E,Fn1<A,?>> appB)
      Description copied from interface: Fn2
      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<A,B>
      Specified by:
      discardR in interface Fn1<A,B>
      Specified by:
      discardR in interface Fn2<A,B,C>
      Specified by:
      discardR in interface Monad<A,B>
      Specified by:
      discardR in interface MonadReader<A,B,C>
      Specified by:
      discardR in interface MonadRec<A,B>
      Specified by:
      discardR in interface MonadWriter<A,B,C>
      Type Parameters:
      E - the type of appB's parameter
      Parameters:
      appB - the other Applicative
      Returns:
      this Applicative

    • diMapL

      default <Z> Fn3<Z,B,C,D> diMapL(Fn1<? super Z, ? extends A> fn)
      Description copied from interface: Fn2
      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,B,C>
      Specified by:
      diMapL in interface Cocartesian<A,B,C>
      Specified by:
      diMapL in interface Fn1<A,B>
      Specified by:
      diMapL in interface Fn2<A,B,C>
      Specified by:
      diMapL in interface Profunctor<A,B,C>
      Type Parameters:
      Z - the new argument type
      Parameters:
      fn - the contravariant argument mapping function
      Returns:
      an Fn1<Z, B>

    • contraMap

      default <Z> Fn3<Z,B,C,D> contraMap(Fn1<? super Z, ? extends A> fn)
      Description copied from interface: Fn2
      Contravariantly map A <- B.
      Specified by:
      contraMap in interface Cartesian<A,B,C>
      Specified by:
      contraMap in interface Cocartesian<A,B,C>
      Specified by:
      contraMap in interface Contravariant<A,B>
      Specified by:
      contraMap in interface Fn1<A,B>
      Specified by:
      contraMap in interface Fn2<A,B,C>
      Specified by:
      contraMap in interface Profunctor<A,B,C>
      Type Parameters:
      Z - the new parameter type
      Parameters:
      fn - the mapping function
      Returns:
      the mapped Contravariant functor instance

    • compose

      default <Y,Z> Fn4<Y,Z,B,C,D> compose(Fn2<? super Y, ? super Z, ? extends A> before)
      Description copied from interface: Fn2
      Right-to-left composition between different arity functions. Preserves highest arity in the return type.
      Specified by:
      compose in interface Fn1<A,B>
      Specified by:
      compose in interface Fn2<A,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>

    • fn3

      static <A,B,C,D> Fn3<A,B,C,D> fn3(Fn1<A, Fn2<B,C,D>> curriedFn1)
      Static factory method for wrapping a curried Fn1 in an Fn3.
      Type Parameters:
      A - the first input argument type
      B - the second input argument type
      C - the third input argument type
      D - the output type
      Parameters:
      curriedFn1 - the curried fn1 to adapt
      Returns:
      the Fn3

    • fn3

      static <A,B,C,D> Fn3<A,B,C,D> fn3(Fn2<A,B,Fn1<C,D>> curriedFn2)
      Static factory method for wrapping a curried Fn2 in an Fn3.
      Type Parameters:
      A - the first input argument type
      B - the second input argument type
      C - the third input argument type
      D - the output type
      Parameters:
      curriedFn2 - the curried fn2 to adapt
      Returns:
      the Fn3

    • fn3

      static <A,B,C,D> Fn3<A,B,C,D> fn3(Fn3<A,B,C,D> fn)
      Static factory method for coercing a lambda to an Fn3.
      Type Parameters:
      A - the first input argument type
      B - the second input argument type
      C - the third input argument type
      D - the output type
      Parameters:
      fn - the lambda to coerce
      Returns:
      the Fn3