com.jnape.palatable.lambda.functions.specialized

## Interface Predicate<A>

- Type Parameters:
    `A` - The argument type
  All Superinterfaces:
    Applicative<Boolean,Fn1<A,?>>, Cartesian<A,Boolean,Fn1<?,?>>, Cocartesian<A,Boolean,Fn1<?,?>>, Contravariant<A,Profunctor<?,Boolean,Fn1<?,?>>>, Fn1<A,Boolean>, Functor<Boolean,Fn1<A,?>>, Monad<Boolean,Fn1<A,?>>, MonadReader<A,Boolean,Fn1<A,?>>, MonadRec<Boolean,Fn1<A,?>>, MonadWriter<A,Boolean,Fn1<A,?>>, Profunctor<A,Boolean,Fn1<?,?>>
  All Known Implementing Classes:
    Empty
  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 Predicate<A>
      extends Fn1<A,Boolean>

  A specialized `Fn1` that returns a `Boolean`.

- - ### Method Summary

    All Methods Static Methods Instance Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `default Predicate<A>` | `and(Predicate<? super A> other)` Left-to-right short-circuiting logical conjunction.
    `default <Y,Z> BiPredicate<Y,Z>` | `compose(Fn2<? super Y,? super Z,? extends A> before)` Right-to-left composition between different arity functions.
    `default <Z> Predicate<Z>` | `contraMap(Fn1<? super Z,? extends A> fn)` Contravariantly map `A <- B`.
    `default <Z> Predicate<Z>` | `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> Predicate<A>` | `discardR(Applicative<C,Fn1<A,?>> appB)` Sequence both this `Applicative` and `appB`, discarding `appB's` result and returning this `Applicative`.
    `static <A> Predicate<A>` | `fromPredicate(Predicate<A> predicate)` Create a `Predicate` from a java `Predicate`.
    `default Predicate<A>` | `negate()` Logical negation.
    `default Predicate<A>` | `or(Predicate<? super A> other)` Left-to-right short-circuiting logical disjunction.
    `static <A> Predicate<A>` | `predicate(Fn1<? super A,? extends Boolean> predicate)` Static factory method to create a predicate from an `Fn1`.
    `default Predicate<A>` | `toPredicate()` Convert this `Predicate` to a java `Predicate`.
    `default <Z> BiPredicate<Z,A>` | `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, apply, carry, cartesian, censor, checkedApply, 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

    - #### diMapL

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

    - #### contraMap

          default <Z> Predicate<Z> contraMap(Fn1<? super Z,? extends A> fn)

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

    - #### widen

          default <Z> BiPredicate<Z,A> 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,Boolean>`
      Type Parameters:
        `Z` - the new first argument type
      Returns:
        the widened function

    - #### discardR

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

    - #### compose

          default <Y,Z> BiPredicate<Y,Z> 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,Boolean>`
      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>

    - #### and

          default Predicate<A> and(Predicate<? super A> other)

      Left-to-right short-circuiting logical conjunction.
      Parameters:
        `other` - the predicate to test if this one succeeds
      Returns:
        a predicate representing the conjunction of this predicate and other

    - #### or

          default Predicate<A> or(Predicate<? super A> other)

      Left-to-right short-circuiting logical disjunction.
      Parameters:
        `other` - the predicate to test if this one fails
      Returns:
        a predicate representing the disjunction of this predicate and other

    - #### negate

          default Predicate<A> negate()

      Logical negation.
      Returns:
        the negation of this predicate

    - #### toPredicate

          default Predicate<A> toPredicate()

      Convert this `Predicate` to a java `Predicate`.
      Returns:
        the `Predicate`

    - #### predicate

          static <A> Predicate<A> predicate(Fn1<? super A,? extends Boolean> predicate)

      Static factory method to create a predicate from an `Fn1`.
      Type Parameters:
        `A` - the input type
      Parameters:
        `predicate` - the `Fn1`
      Returns:
        the predicate

    - #### fromPredicate

          static <A> Predicate<A> fromPredicate(Predicate<A> predicate)

      Create a `Predicate` from a java `Predicate`.
      Type Parameters:
        `A` - the input type
      Parameters:
        `predicate` - the java `Predicate`
      Returns:
        the `Predicate`