Interface Fn1<A,​B>

    • Method Summary

      All Methods Static Methods Instance Methods Abstract Methods Default Methods 
      Modifier and Type Method Description
      default <C,​D>
      Fn2<A,​C,​D>
      andThen​(Fn2<? super B,​? super C,​? extends D> after)
      Left-to-right composition between different arity functions.
      default B apply​(A a)
      Invoke this function explosively with the given argument.
      default Fn1<A,​Tuple2<A,​B>> carry()
      Pair the covariantly-positioned carrier type with the contravariantly-positioned carrier type.
      default <C> Fn1<Tuple2<C,​A>,​Tuple2<C,​B>> cartesian()
      Pair a value with the input to this function, and preserve the paired value through to the output.
      default Fn1<A,​B> censor​(Fn1<? super A,​? extends A> fn)
      Update the accumulated state.
      B checkedApply​(A a)
      Invoke this function with the given argument, potentially throwing any Throwable.
      default Fn1<A,​Choice2<A,​B>> choose()
      Choose between a successful result b or returning back the input, a.
      default <C> Fn1<Choice2<C,​A>,​Choice2<C,​B>> cocartesian()
      Choose between either applying this function or returning back a different result altogether.
      default <Y,​Z>
      Fn2<Y,​Z,​B>
      compose​(Fn2<? super Y,​? super Z,​? extends A> before)
      Right-to-left composition between different arity functions.
      default <Z> Fn1<Z,​B> contraMap​(Fn1<? super Z,​? extends A> fn)
      Contravariantly map A <- B.
      default <Z,​C>
      Fn1<Z,​C>
      diMap​(Fn1<? super Z,​? extends A> lFn, Fn1<? super B,​? extends C> rFn)
      Exercise both diMapL and diMapR over this function in the same invocation.
      default <Z> Fn1<Z,​B> 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 <C> Fn1<A,​C> diMapR​(Fn1<? super B,​? extends C> fn)
      Covariantly map over the return value of this function, producing a function that takes the same argument, and produces the new result type.
      default <C> Fn1<A,​C> discardL​(Applicative<C,​Fn1<A,​?>> appB)
      Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
      default <C> Fn1<A,​B> discardR​(Applicative<C,​Fn1<A,​?>> appB)
      Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
      default <C> Fn1<A,​C> flatMap​(Fn1<? super B,​? extends Monad<C,​Fn1<A,​?>>> f)
      Chain dependent computations that may continue or short-circuit based on previous results.
      default <C> Fn1<A,​C> fmap​(Fn1<? super B,​? extends C> f)
      Left-to-right composition.
      static <A,​B>
      Fn1<A,​B>
      fn1​(Fn1<? super A,​? extends B> fn)
      Static factory method for avoid explicit casting when using method references as Fn1s.
      static <A,​B>
      Fn1<A,​B>
      fromFunction​(java.util.function.Function<? super A,​? extends B> function)
      Static factory method for wrapping a java Function in an Fn1.
      default <C> Lazy<Fn1<A,​C>> lazyZip​(Lazy<? extends Applicative<Fn1<? super B,​? extends C>,​Fn1<A,​?>>> lazyAppFn)
      Given a lazy instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
      default <C> Fn1<A,​Tuple2<B,​C>> listens​(Fn1<? super A,​? extends C> fn)
      Map the accumulation into a value and pair it with the current output.
      default Fn1<A,​B> local​(Fn1<? super A,​? extends A> fn)
      Modify this MonadReader's environment after reading it but before running the effect.
      default <C> Fn1<A,​C> pure​(C c)
      Lift the value b into this applicative functor.
      static <A> Pure<Fn1<A,​?>> pureFn1()
      The canonical Pure instance for Fn1.
      default Fn1<A,​B> self()  
      default Fn0<B> thunk​(A a)
      Convert this Fn1 to an Fn0 by supplying an argument to this function.
      default java.util.function.Function<A,​B> toFunction()
      Convert this Fn1 to a java Function.
      default <C> Fn1<A,​C> trampolineM​(Fn1<? super B,​? extends MonadRec<RecursiveResult<B,​C>,​Fn1<A,​?>>> fn)
      Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.
      default <Z> Fn2<Z,​A,​B> widen()
      Widen this function's argument list by prepending an ignored argument of any type to the front.
      static <A,​B>
      Fn1<A,​B>
      withSelf​(Fn2<? super Fn1<? super A,​? extends B>,​? super A,​? extends B> fn)
      Construct an Fn1 that has a reference to itself in scope at the time it is executed (presumably for recursive invocations).
      default <C> Fn1<A,​C> zip​(Fn2<A,​B,​C> appFn)
      default <C> Fn1<A,​C> zip​(Applicative<Fn1<? super B,​? extends C>,​Fn1<A,​?>> appFn)
      Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
      • Methods inherited from interface com.jnape.palatable.lambda.functor.Functor

        coerce
    • Method Detail

      • apply

        default B apply​(A a)
        Invoke this function explosively with the given argument.
        Parameters:
        a - the argument
        Returns:
        the result of the function application
      • checkedApply

        B checkedApply​(A a)
                throws java.lang.Throwable
        Invoke this function with the given argument, potentially throwing any Throwable.
        Parameters:
        a - the argument
        Returns:
        the result of the function application
        Throws:
        java.lang.Throwable - anything possibly thrown by the function
      • thunk

        default Fn0<B> thunk​(A a)
        Convert this Fn1 to an Fn0 by supplying an argument to this function. Useful for fixing an argument now, but deferring application until a later time.
        Parameters:
        a - the argument
        Returns:
        an Fn0
      • widen

        default <Z> Fn2<Z,​A,​B> widen()
        Widen this function's argument list by prepending an ignored argument of any type to the front.
        Type Parameters:
        Z - the new first argument type
        Returns:
        the widened function
      • toFunction

        default java.util.function.Function<A,​B> toFunction()
        Convert this Fn1 to a java Function.
        Returns:
        the Function
      • local

        default Fn1<A,​B> local​(Fn1<? super A,​? extends A> fn)
        Modify this MonadReader's environment after reading it but before running the effect.
        Specified by:
        local in interface MonadReader<A,​B,​Fn1<A,​?>>
        Parameters:
        fn - the modification function
        Returns:
        the MonadReader with a modified environment
      • listens

        default <C> Fn1<A,​Tuple2<B,​C>> listens​(Fn1<? super A,​? extends C> fn)
        Map the accumulation into a value and pair it with the current output.
        Specified by:
        listens in interface MonadWriter<A,​B,​Fn1<A,​?>>
        Type Parameters:
        C - the mapped output
        Parameters:
        fn - the mapping function
        Returns:
        the updated MonadWriter
      • censor

        default Fn1<A,​B> censor​(Fn1<? super A,​? extends A> fn)
        Update the accumulated state.
        Specified by:
        censor in interface MonadWriter<A,​B,​Fn1<A,​?>>
        Parameters:
        fn - the update function
        Returns:
        the updated MonadWriter
      • flatMap

        default <C> Fn1<A,​C> flatMap​(Fn1<? super B,​? extends Monad<C,​Fn1<A,​?>>> f)
        Chain dependent computations that may continue or short-circuit based on previous results.
        Specified by:
        flatMap in interface Monad<A,​B>
        Specified by:
        flatMap in interface MonadReader<A,​B,​Fn1<A,​?>>
        Specified by:
        flatMap in interface MonadRec<A,​B>
        Specified by:
        flatMap in interface MonadWriter<A,​B,​Fn1<A,​?>>
        Type Parameters:
        C - the resulting monad parameter type
        Parameters:
        f - the dependent computation over A
        Returns:
        the new monad instance
      • fmap

        default <C> Fn1<A,​C> fmap​(Fn1<? super B,​? extends C> f)
        Left-to-right composition.
        Specified by:
        fmap in interface Applicative<A,​B>
        Specified by:
        fmap in interface Functor<A,​B>
        Specified by:
        fmap in interface Monad<A,​B>
        Specified by:
        fmap in interface MonadReader<A,​B,​Fn1<A,​?>>
        Specified by:
        fmap in interface MonadRec<A,​B>
        Specified by:
        fmap in interface MonadWriter<A,​B,​Fn1<A,​?>>
        Type Parameters:
        C - the return type of the next function to invoke
        Parameters:
        f - the function to invoke with this function's return value
        Returns:
        a function representing the composition of this function and f
      • pure

        default <C> Fn1<A,​C> pure​(C c)
        Lift the value b into this applicative functor.
        Specified by:
        pure in interface Applicative<A,​B>
        Specified by:
        pure in interface Monad<A,​B>
        Specified by:
        pure in interface MonadReader<A,​B,​Fn1<A,​?>>
        Specified by:
        pure in interface MonadRec<A,​B>
        Specified by:
        pure in interface MonadWriter<A,​B,​Fn1<A,​?>>
        Type Parameters:
        C - the type of the returned applicative's parameter
        Parameters:
        c - the value
        Returns:
        an instance of this applicative over b
      • zip

        default <C> Fn1<A,​C> zip​(Applicative<Fn1<? super B,​? extends C>,​Fn1<A,​?>> appFn)
        Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
        Specified by:
        zip in interface Applicative<A,​B>
        Specified by:
        zip in interface Monad<A,​B>
        Specified by:
        zip in interface MonadReader<A,​B,​Fn1<A,​?>>
        Specified by:
        zip in interface MonadRec<A,​B>
        Specified by:
        zip in interface MonadWriter<A,​B,​Fn1<A,​?>>
        Type Parameters:
        C - the resulting applicative parameter type
        Parameters:
        appFn - the other applicative instance
        Returns:
        the mapped applicative
      • zip

        default <C> Fn1<A,​C> zip​(Fn2<A,​B,​C> appFn)
      • lazyZip

        default <C> Lazy<Fn1<A,​C>> lazyZip​(Lazy<? extends Applicative<Fn1<? super B,​? extends C>,​Fn1<A,​?>>> lazyAppFn)
        Given a lazy instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports. This is useful for applicatives that support lazy evaluation and early termination.
        Specified by:
        lazyZip in interface Applicative<A,​B>
        Specified by:
        lazyZip in interface Monad<A,​B>
        Specified by:
        lazyZip in interface MonadReader<A,​B,​Fn1<A,​?>>
        Specified by:
        lazyZip in interface MonadRec<A,​B>
        Specified by:
        lazyZip in interface MonadWriter<A,​B,​Fn1<A,​?>>
        Type Parameters:
        C - the resulting applicative parameter type
        Parameters:
        lazyAppFn - the lazy other applicative instance
        Returns:
        the mapped applicative
        See Also:
        Maybe, Either
      • discardL

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

        default <C> Fn1<A,​B> discardR​(Applicative<C,​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<A,​B>
        Specified by:
        discardR in interface Monad<A,​B>
        Specified by:
        discardR in interface MonadReader<A,​B,​Fn1<A,​?>>
        Specified by:
        discardR in interface MonadRec<A,​B>
        Specified by:
        discardR in interface MonadWriter<A,​B,​Fn1<A,​?>>
        Type Parameters:
        C - the type of appB's parameter
        Parameters:
        appB - the other Applicative
        Returns:
        this Applicative
      • diMapL

        default <Z> Fn1<Z,​B> 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,​B,​Fn1<?,​?>>
        Specified by:
        diMapL in interface Cocartesian<A,​B,​Fn1<?,​?>>
        Specified by:
        diMapL in interface Profunctor<A,​B,​Fn1<?,​?>>
        Type Parameters:
        Z - the new argument type
        Parameters:
        fn - the contravariant argument mapping function
        Returns:
        an Fn1<Z, B>
      • diMapR

        default <C> Fn1<A,​C> diMapR​(Fn1<? super B,​? extends C> fn)
        Covariantly map over the return value of this function, producing a function that takes the same argument, and produces the new result type.
        Specified by:
        diMapR in interface Cartesian<A,​B,​Fn1<?,​?>>
        Specified by:
        diMapR in interface Cocartesian<A,​B,​Fn1<?,​?>>
        Specified by:
        diMapR in interface Profunctor<A,​B,​Fn1<?,​?>>
        Type Parameters:
        C - the new result type
        Parameters:
        fn - the covariant result mapping function
        Returns:
        an Fn1<A, C>
      • diMap

        default <Z,​C> Fn1<Z,​C> diMap​(Fn1<? super Z,​? extends A> lFn,
                                                 Fn1<? super B,​? extends C> rFn)
        Exercise both diMapL and diMapR over this function in the same invocation.
        Specified by:
        diMap in interface Cartesian<A,​B,​Fn1<?,​?>>
        Specified by:
        diMap in interface Cocartesian<A,​B,​Fn1<?,​?>>
        Specified by:
        diMap in interface Profunctor<A,​B,​Fn1<?,​?>>
        Type Parameters:
        Z - the new argument type
        C - the new result type
        Parameters:
        lFn - the contravariant argument mapping function
        rFn - the covariant result mapping function
        Returns:
        an Fn1<Z, C>
      • cartesian

        default <C> Fn1<Tuple2<C,​A>,​Tuple2<C,​B>> cartesian()
        Pair a value with the input to this function, and preserve the paired value through to the output.
        Specified by:
        cartesian in interface Cartesian<A,​B,​Fn1<?,​?>>
        Type Parameters:
        C - the paired value
        Returns:
        the strengthened Fn1
      • carry

        default Fn1<A,​Tuple2<A,​B>> carry()
        Pair the covariantly-positioned carrier type with the contravariantly-positioned carrier type. This can be thought of as "carrying" or "inspecting" the left parameter.
        Specified by:
        carry in interface Cartesian<A,​B,​Fn1<?,​?>>
        Returns:
        the profunctor with the first parameter carried
      • cocartesian

        default <C> Fn1<Choice2<C,​A>,​Choice2<C,​B>> cocartesian()
        Choose between either applying this function or returning back a different result altogether.
        Specified by:
        cocartesian in interface Cocartesian<A,​B,​Fn1<?,​?>>
        Type Parameters:
        C - the potentially different result
        Returns:
        teh strengthened Fn1
      • choose

        default Fn1<A,​Choice2<A,​B>> choose()
        Choose between a successful result b or returning back the input, a.
        Specified by:
        choose in interface Cocartesian<A,​B,​Fn1<?,​?>>
        Returns:
        an Fn1 that chooses between its input (in case of failure) or its output.
      • contraMap

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

        default <Y,​Z> Fn2<Y,​Z,​B> compose​(Fn2<? super Y,​? super Z,​? extends A> before)
        Right-to-left composition between different arity functions. Preserves highest arity in the return type.
        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>
      • andThen

        default <C,​D> Fn2<A,​C,​D> andThen​(Fn2<? super B,​? super C,​? extends D> after)
        Left-to-right composition between different arity functions. Preserves highest arity in the return type.
        Type Parameters:
        C - the resulting function's second argument type
        D - the resulting function's return type
        Parameters:
        after - the function to invoke on this function's return value
        Returns:
        an Fn2<A, C, D>
      • self

        default Fn1<A,​B> self()
      • fn1

        static <A,​B> Fn1<A,​B> fn1​(Fn1<? super A,​? extends B> fn)
        Static factory method for avoid explicit casting when using method references as Fn1s.
        Type Parameters:
        A - the input type
        B - the output type
        Parameters:
        fn - the function to adapt
        Returns:
        the Fn1
      • fromFunction

        static <A,​B> Fn1<A,​B> fromFunction​(java.util.function.Function<? super A,​? extends B> function)
        Static factory method for wrapping a java Function in an Fn1.
        Type Parameters:
        A - the input type
        B - the output type
        Parameters:
        function - the function
        Returns:
        the Fn1
      • pureFn1

        static <A> Pure<Fn1<A,​?>> pureFn1()
        The canonical Pure instance for Fn1.
        Type Parameters:
        A - the input type
        Returns:
        the Pure instance
      • withSelf

        static <A,​B> Fn1<A,​B> withSelf​(Fn2<? super Fn1<? super A,​? extends B>,​? super A,​? extends B> fn)
        Construct an Fn1 that has a reference to itself in scope at the time it is executed (presumably for recursive invocations).
        Type Parameters:
        A - the input type
        B - the output type
        Parameters:
        fn - the body of the function, with access to itself
        Returns:
        the Fn1