Class Tuple4<_1,_2,_3,_4>

java.lang.Object
com.jnape.palatable.lambda.adt.hlist.HList
com.jnape.palatable.lambda.adt.hlist.HList.HCons<_1, Tuple3<_2,_3,_4>>
com.jnape.palatable.lambda.adt.hlist.Tuple4<_1,_2,_3,_4>
Type Parameters:
_1 - The first slot element type
_2 - The second slot element type
_3 - The third slot element type
_4 - The fourth slot element type
All Implemented Interfaces:
Product2<_1,_2>, Product3<_1,_2,_3>, Product4<_1,_2,_3,_4>, Applicative<_4, Tuple4<_1,_2,_3,?>>, Bifunctor<_3, _4, Tuple4<_1,_2,?,?>>, BoundedBifunctor<_3, _4, Object, Object, Tuple4<_1,_2,?,?>>, Functor<_4, Tuple4<_1,_2,_3,?>>, Monad<_4, Tuple4<_1,_2,_3,?>>, MonadRec<_4, Tuple4<_1,_2,_3,?>>, Traversable<_4, Tuple4<_1,_2,_3,?>>, Map.Entry<_1,_2>
public class Tuple4<_1,_2,_3,_4> extends HList.HCons<_1, Tuple3<_2,_3,_4>> implements Product4<_1,_2,_3,_4>, MonadRec<_4, Tuple4<_1,_2,_3,?>>, Bifunctor<_3, _4, Tuple4<_1,_2,?,?>>, Traversable<_4, Tuple4<_1,_2,_3,?>>
A 4-element tuple product type, implemented as a specialized HList. Supports random access.
See Also:

  • Field Details

    • _1

      private final _1 _1

    • _2

      private final _2 _2

    • _3

      private final _3 _3

    • _4

      private final _4 _4

  • Constructor Details

  • Method Details

    • cons

      public <_0> Tuple5<_0,_1,_2,_3,_4> cons(_0 _0)
      Cons an element onto the front of this HList.
      Overrides:
      cons in class HList.HCons<_1, Tuple3<_2,_3,_4>>
      Type Parameters:
      _0 - the new head type
      Parameters:
      _0 - the new head element
      Returns:
      the updated HList

    • snoc

      public <_5> Tuple5<_1,_2,_3,_4,_5> snoc(_5 _5)
      Snoc an element onto the back of this Tuple4.
      Type Parameters:
      _5 - the new last element type
      Parameters:
      _5 - the new last element
      Returns:
      the new Tuple5

    • _1

      public _1 _1()
      Retrieve the first element.
      Specified by:
      _1 in interface Product2<_1,_2>
      Returns:
      the first element

    • _2

      public _2 _2()
      Retrieve the second element.
      Specified by:
      _2 in interface Product2<_1,_2>
      Returns:
      the second element

    • _3

      public _3 _3()
      Retrieve the third element.
      Specified by:
      _3 in interface Product3<_1,_2,_3>
      Returns:
      the third element

    • _4

      public _4 _4()
      Retrieve the fourth element.
      Specified by:
      _4 in interface Product4<_1,_2,_3,_4>
      Returns:
      the fourth element

    • rotateL4

      public Tuple4<_2,_3,_4,_1> rotateL4()
      Rotate the first four values of this product one slot to the left.
      Specified by:
      rotateL4 in interface Product4<_1,_2,_3,_4>
      Returns:
      the left-rotated product

    • rotateR4

      public Tuple4<_4,_1,_2,_3> rotateR4()
      Rotate the first four values of this product one slot to the right.
      Specified by:
      rotateR4 in interface Product4<_1,_2,_3,_4>
      Returns:
      the right-rotated product

    • rotateL3

      public Tuple4<_2,_3,_1,_4> rotateL3()
      Rotate the first three values of this product one slot to the left.
      Specified by:
      rotateL3 in interface Product3<_1,_2,_3>
      Specified by:
      rotateL3 in interface Product4<_1,_2,_3,_4>
      Returns:
      the left-rotated product

    • rotateR3

      public Tuple4<_3,_1,_2,_4> rotateR3()
      Rotate the first three values of this product one slot to the right.
      Specified by:
      rotateR3 in interface Product3<_1,_2,_3>
      Specified by:
      rotateR3 in interface Product4<_1,_2,_3,_4>
      Returns:
      the right-rotated product

    • invert

      public Tuple4<_2,_1,_3,_4> invert()
      Rotate the first two slots of this product.
      Specified by:
      invert in interface Product2<_1,_2>
      Specified by:
      invert in interface Product3<_1,_2,_3>
      Specified by:
      invert in interface Product4<_1,_2,_3,_4>
      Returns:
      the rotated product

    • fmap

      public <_4Prime> Tuple4<_1,_2,_3,_4Prime> fmap(Fn1<? super _4, ? extends _4Prime> fn)
      Covariantly transmute this functor's parameter using the given mapping function. Generally this method is specialized to return an instance of the class implementing Functor.
      Specified by:
      fmap in interface Applicative<_1,_2>
      Specified by:
      fmap in interface Functor<_1,_2>
      Specified by:
      fmap in interface Monad<_1,_2>
      Specified by:
      fmap in interface MonadRec<_1,_2>
      Specified by:
      fmap in interface Traversable<_1,_2>
      Type Parameters:
      _4Prime - the new parameter type
      Parameters:
      fn - the mapping function
      Returns:
      a functor over B (the new parameter type)

    • biMapL

      public <_3Prime> Tuple4<_1,_2,_3Prime,_4> biMapL(Fn1<? super _3, ? extends _3Prime> fn)
      Covariantly map over the left parameter.
      Specified by:
      biMapL in interface Bifunctor<_1,_2,_3>
      Specified by:
      biMapL in interface BoundedBifunctor<_3, _4, Object, Object, Tuple4<_1,_2,?,?>>
      Type Parameters:
      _3Prime - the new left parameter type
      Parameters:
      fn - the mapping function
      Returns:
      a bifunctor over C (the new left parameter) and B (the same right parameter)

    • biMapR

      public <_4Prime> Tuple4<_1,_2,_3,_4Prime> biMapR(Fn1<? super _4, ? extends _4Prime> fn)
      Covariantly map over the right parameter. For all bifunctors that are also functors, it should hold that biMapR(f) == fmap(f).
      Specified by:
      biMapR in interface Bifunctor<_1,_2,_3>
      Specified by:
      biMapR in interface BoundedBifunctor<_3, _4, Object, Object, Tuple4<_1,_2,?,?>>
      Type Parameters:
      _4Prime - the new right parameter type
      Parameters:
      fn - the mapping function
      Returns:
      a bifunctor over A (the same left parameter) and C (the new right parameter)

    • biMap

      public <_3Prime,_4Prime> Tuple4<_1,_2,_3Prime,_4Prime> biMap(Fn1<? super _3, ? extends _3Prime> lFn, Fn1<? super _4, ? extends _4Prime> rFn)
      Dually map covariantly over both the left and right parameters. This is isomorphic to biMapL(lFn).biMapR(rFn).
      Specified by:
      biMap in interface Bifunctor<_1,_2,_3>
      Specified by:
      biMap in interface BoundedBifunctor<_3, _4, Object, Object, Tuple4<_1,_2,?,?>>
      Type Parameters:
      _3Prime - the new left parameter type
      _4Prime - the new right parameter type
      Parameters:
      lFn - the left parameter mapping function
      rFn - the right parameter mapping function
      Returns:
      a bifunctor over C (the new left parameter type) and D (the new right parameter type)

    • pure

      public <_4Prime> Tuple4<_1,_2,_3,_4Prime> pure(_4Prime _4Prime)
      Lift the value b into this applicative functor.
      Specified by:
      pure in interface Applicative<_1,_2>
      Specified by:
      pure in interface Monad<_1,_2>
      Specified by:
      pure in interface MonadRec<_1,_2>
      Type Parameters:
      _4Prime - the type of the returned applicative's parameter
      Parameters:
      _4Prime - the value
      Returns:
      an instance of this applicative over b

    • zip

      public <_4Prime> Tuple4<_1,_2,_3,_4Prime> zip(Applicative<Fn1<? super _4, ? extends _4Prime>, Tuple4<_1,_2,_3,?>> 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<_1,_2>
      Specified by:
      zip in interface Monad<_1,_2>
      Specified by:
      zip in interface MonadRec<_1,_2>
      Type Parameters:
      _4Prime - the resulting applicative parameter type
      Parameters:
      appFn - the other applicative instance
      Returns:
      the mapped applicative

    • lazyZip

      public <_4Prime> Lazy<Tuple4<_1,_2,_3,_4Prime>> lazyZip(Lazy<? extends Applicative<Fn1<? super _4, ? extends _4Prime>, Tuple4<_1,_2,_3,?>>> 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<_1,_2>
      Specified by:
      lazyZip in interface Monad<_1,_2>
      Specified by:
      lazyZip in interface MonadRec<_1,_2>
      Type Parameters:
      _4Prime - the resulting applicative parameter type
      Parameters:
      lazyAppFn - the lazy other applicative instance
      Returns:
      the mapped applicative
      See Also:

    • discardL

      public <_4Prime> Tuple4<_1,_2,_3,_4Prime> discardL(Applicative<_4Prime, Tuple4<_1,_2,_3,?>> 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<_1,_2>
      Specified by:
      discardL in interface Monad<_1,_2>
      Specified by:
      discardL in interface MonadRec<_1,_2>
      Type Parameters:
      _4Prime - the type of the returned Applicative's parameter
      Parameters:
      appB - the other Applicative
      Returns:
      appB

    • discardR

      public <_4Prime> Tuple4<_1,_2,_3,_4> discardR(Applicative<_4Prime, Tuple4<_1,_2,_3,?>> 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<_1,_2>
      Specified by:
      discardR in interface Monad<_1,_2>
      Specified by:
      discardR in interface MonadRec<_1,_2>
      Type Parameters:
      _4Prime - the type of appB's parameter
      Parameters:
      appB - the other Applicative
      Returns:
      this Applicative

    • flatMap

      public <_4Prime> Tuple4<_1,_2,_3,_4Prime> flatMap(Fn1<? super _4, ? extends Monad<_4Prime, Tuple4<_1,_2,_3,?>>> f)
      Chain dependent computations that may continue or short-circuit based on previous results.
      Specified by:
      flatMap in interface Monad<_1,_2>
      Specified by:
      flatMap in interface MonadRec<_1,_2>
      Type Parameters:
      _4Prime - the resulting monad parameter type
      Parameters:
      f - the dependent computation over A
      Returns:
      the new monad instance

    • trampolineM

      public <_4Prime> Tuple4<_1,_2,_3,_4Prime> trampolineM(Fn1<? super _4, ? extends MonadRec<RecursiveResult<_4,_4Prime>, Tuple4<_1,_2,_3,?>>> fn)
      Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.

      Stack-safety depends on implementations guaranteeing that the growth of the call stack is a constant factor independent of the number of invocations of the operation. For various examples of how this can be achieved in stereotypical circumstances, see the referenced types.

      Specified by:
      trampolineM in interface MonadRec<_1,_2>
      Type Parameters:
      _4Prime - the ultimate resulting carrier type
      Parameters:
      fn - the function to internally trampoline
      Returns:
      the trampolined MonadRec
      See Also:

    • traverse

      public <_4Prime, App extends Applicative<?,App>, TravB extends Traversable<_4Prime, Tuple4<_1,_2,_3,?>>, AppTrav extends Applicative<TravB,App>> AppTrav traverse(Fn1<? super _4, ? extends Applicative<_4Prime,App>> fn, Fn1<? super TravB, ? extends AppTrav> pure)
      Apply fn to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.
      Specified by:
      traverse in interface Traversable<_1,_2>
      Type Parameters:
      _4Prime - the resulting element type
      App - the result applicative type
      TravB - this Traversable instance over B
      AppTrav - the full inferred resulting type from the traversal
      Parameters:
      fn - the function to apply
      pure - the applicative pure function
      Returns:
      the traversed Traversable, wrapped inside an applicative

    • init

      public Tuple3<_1,_2,_3> init()
      Returns a Tuple3<_1, _2, _3> of all the elements of this Tuple4<_1, _2, _3, _4> except the last.
      Returns:
      The Tuple3<_1, _2, _3> representing all but the last element

    • fill

      public static <A> Tuple4<A,A,A,A> fill(A a)
      Given a value of type A, produced an instance of this tuple with each slot set to that value.
      Type Parameters:
      A - the value type
      Parameters:
      a - the value to fill the tuple with
      Returns:
      the filled tuple
      See Also:

    • fromIterable

      public static <A> Maybe<Tuple4<A,A,A,A>> fromIterable(Iterable<A> as)
      Return just the first four elements from the given Iterable, or nothing if there are less than four elements.
      Type Parameters:
      A - the Iterable element type
      Parameters:
      as - the Iterable
      Returns:
      Maybe the first four elements of the given Iterable

    • pureTuple

      public static <_1,_2,_3> Pure<Tuple4<_1,_2,_3,?>> pureTuple(_1 _1, _2 _2, _3 _3)
      The canonical Pure instance for Tuple4.
      Type Parameters:
      _1 - the head element type
      _2 - the second element type
      _3 - the third element type
      Parameters:
      _1 - the head element
      _2 - the second element
      _3 - the third element
      Returns:
      the Pure instance