Class Tuple3<_1,_2,_3>

java.lang.Object
com.jnape.palatable.lambda.adt.hlist.HList
com.jnape.palatable.lambda.adt.hlist.HList.HCons<_1, Tuple2<_2,_3>>
com.jnape.palatable.lambda.adt.hlist.Tuple3<_1,_2,_3>
Type Parameters:
_1 - The first slot element type
_2 - The second slot element type
_3 - The third slot element type
All Implemented Interfaces:
Product2<_1,_2>, Product3<_1,_2,_3>, Applicative<_3, Tuple3<_1,_2,?>>, Bifunctor<_2, _3, Tuple3<_1,?,?>>, BoundedBifunctor<_2, _3, Object, Object, Tuple3<_1,?,?>>, Functor<_3, Tuple3<_1,_2,?>>, Monad<_3, Tuple3<_1,_2,?>>, MonadRec<_3, Tuple3<_1,_2,?>>, Traversable<_3, Tuple3<_1,_2,?>>, Map.Entry<_1,_2>
public class Tuple3<_1,_2,_3> extends HList.HCons<_1, Tuple2<_2,_3>> implements Product3<_1,_2,_3>, MonadRec<_3, Tuple3<_1,_2,?>>, Bifunctor<_2, _3, Tuple3<_1,?,?>>, Traversable<_3, Tuple3<_1,_2,?>>
A 3-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

  • Constructor Details

  • Method Details

    • cons

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

    • snoc

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

    • _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

    • rotateL3

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

    • rotateR3

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

    • invert

      public Tuple3<_2,_1,_3> 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>
      Returns:
      the rotated product

    • fmap

      public <_3Prime> Tuple3<_1,_2,_3Prime> fmap(Fn1<? super _3, ? extends _3Prime> 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:
      _3Prime - the new parameter type
      Parameters:
      fn - the mapping function
      Returns:
      a functor over B (the new parameter type)

    • biMapL

      public <_2Prime> Tuple3<_1,_2Prime,_3> biMapL(Fn1<? super _2, ? extends _2Prime> fn)
      Covariantly map over the left parameter.
      Specified by:
      biMapL in interface Bifunctor<_1,_2,_3>
      Specified by:
      biMapL in interface BoundedBifunctor<_2, _3, Object, Object, Tuple3<_1,?,?>>
      Type Parameters:
      _2Prime - 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 <_3Prime> Tuple3<_1,_2,_3Prime> biMapR(Fn1<? super _3, ? extends _3Prime> 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<_2, _3, Object, Object, Tuple3<_1,?,?>>
      Type Parameters:
      _3Prime - 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 <_2Prime,_3Prime> Tuple3<_1,_2Prime,_3Prime> biMap(Fn1<? super _2, ? extends _2Prime> lFn, Fn1<? super _3, ? extends _3Prime> 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<_2, _3, Object, Object, Tuple3<_1,?,?>>
      Type Parameters:
      _2Prime - the new left parameter type
      _3Prime - 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 <_3Prime> Tuple3<_1,_2,_3Prime> pure(_3Prime _3Prime)
      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:
      _3Prime - the type of the returned applicative's parameter
      Parameters:
      _3Prime - the value
      Returns:
      an instance of this applicative over b

    • zip

      public <_3Prime> Tuple3<_1,_2,_3Prime> zip(Applicative<Fn1<? super _3, ? extends _3Prime>, Tuple3<_1,_2,?>> 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:
      _3Prime - the resulting applicative parameter type
      Parameters:
      appFn - the other applicative instance
      Returns:
      the mapped applicative

    • lazyZip

      public <_3Prime> Lazy<Tuple3<_1,_2,_3Prime>> lazyZip(Lazy<? extends Applicative<Fn1<? super _3, ? extends _3Prime>, Tuple3<_1,_2,?>>> 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:
      _3Prime - the resulting applicative parameter type
      Parameters:
      lazyAppFn - the lazy other applicative instance
      Returns:
      the mapped applicative
      See Also:

    • discardL

      public <_3Prime> Tuple3<_1,_2,_3Prime> discardL(Applicative<_3Prime, Tuple3<_1,_2,?>> 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:
      _3Prime - the type of the returned Applicative's parameter
      Parameters:
      appB - the other Applicative
      Returns:
      appB

    • discardR

      public <_3Prime> Tuple3<_1,_2,_3> discardR(Applicative<_3Prime, Tuple3<_1,_2,?>> 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:
      _3Prime - the type of appB's parameter
      Parameters:
      appB - the other Applicative
      Returns:
      this Applicative

    • flatMap

      public <_3Prime> Tuple3<_1,_2,_3Prime> flatMap(Fn1<? super _3, ? extends Monad<_3Prime, Tuple3<_1,_2,?>>> 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:
      _3Prime - the resulting monad parameter type
      Parameters:
      f - the dependent computation over A
      Returns:
      the new monad instance

    • trampolineM

      public <_3Prime> Tuple3<_1,_2,_3Prime> trampolineM(Fn1<? super _3, ? extends MonadRec<RecursiveResult<_3,_3Prime>, Tuple3<_1,_2,?>>> 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:
      _3Prime - the ultimate resulting carrier type
      Parameters:
      fn - the function to internally trampoline
      Returns:
      the trampolined MonadRec
      See Also:

    • traverse

      public <_3Prime, App extends Applicative<?,App>, TravB extends Traversable<_3Prime, Tuple3<_1,_2,?>>, AppTrav extends Applicative<TravB,App>> AppTrav traverse(Fn1<? super _3, ? extends Applicative<_3Prime,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:
      _3Prime - 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 Tuple2<_1,_2> init()
      Returns a Tuple2<_1, _2> of all the elements of this Tuple3<_1, _2, _3> except the last.
      Returns:
      The Tuple2<_1, _2> representing all but the last element

    • fill

      public static <A> Tuple3<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<Tuple3<A,A,A>> fromIterable(Iterable<A> as)
      Return just the first three elements from the given Iterable, or nothing if there are less than three elements.
      Type Parameters:
      A - the Iterable element type
      Parameters:
      as - the Iterable
      Returns:
      Maybe the first three elements of the given Iterable

    • pureTuple

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