arrow-core-data / arrow.core / Tuple8
Tuple8
data class Tuple8<out A, out B, out C, out D, out E, out F, out G, out H> : Tuple8Of<A, B, C, D, E, F, G, H>
Constructors
  
    
      | <init> | 
      Tuple8(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) | 
    
  
Properties
  
    
      | a | 
      val ~~a~~: A | 
    
    
      | b | 
      val ~~b~~: B | 
    
    
      | c | 
      val ~~c~~: C | 
    
    
      | d | 
      val ~~d~~: D | 
    
    
      | e | 
      val ~~e~~: E | 
    
    
      | eight | 
      val eight: H | 
    
    
      | f | 
      val ~~f~~: F | 
    
    
      | fifth | 
      val fifth: E | 
    
    
      | first | 
      val first: A | 
    
    
      | fourth | 
      val fourth: D | 
    
    
      | g | 
      val ~~g~~: G | 
    
    
      | h | 
      val ~~h~~: H | 
    
    
      | second | 
      val second: B | 
    
    
      | seventh | 
      val seventh: G | 
    
    
      | sixth | 
      val sixth: F | 
    
    
      | third | 
      val third: C | 
    
  
Functions
Extension Functions
  
    
      | altFold | 
      fun <T, F, A> Kind<T, A>.altFold(AF: Alternative<F>, FT: Foldable<T>): Kind<F, A> | 
    
    
      | altSum | 
      fun <T, F, A> Kind<T, Kind<F, A>>.altSum(AF: Alternative<F>, FT: Foldable<T>): Kind<F, A> | 
    
    
      | compareTo | 
      operator fun <A : Comparable<A>, B : Comparable<B>, C : Comparable<C>, D : Comparable<D>, E : Comparable<E>, F : Comparable<F>, G : Comparable<G>, H : Comparable<H>> Tuple8<A, B, C, D, E, F, G, H>.compareTo(other: Tuple8<A, B, C, D, E, F, G, H>): Int | 
    
    
      | conest | 
      fun <F, A, B> CounnestedType<F, A, B>.conest(): ConestedType<F, A, B> | 
    
    
      | fix | 
      fun <A, B, C, D, E, F, G, H> Tuple8Of<A, B, C, D, E, F, G, H>.~~fix~~(): Tuple8<A, B, C, D, E, F, G, H> |