org.scalatest.prop

# TableFor6

#### class TableFor6 [A, B, C, D, E, F] extends IndexedSeq[(A, B, C, D, E, F)] with IndexedSeqLike[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]]

A table with 6 columns.

For an introduction to using tables, see the documentation for traitTableDrivenPropertyChecks.

This table is a sequence of `Tuple6` objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.

A handy way to create a `TableFor6` is via an `apply` factory method in the `Table`singleton object provided by the `Tables` trait. Here's an example:

    val examples =
      Table(
        ("a", "b", "c", "d", "e", "f"),
        (  0,   0,   0,   0,   0,   0),
        (  1,   1,   1,   1,   1,   1),
        (  2,   2,   2,   2,   2,   2),
        (  3,   3,   3,   3,   3,   3),
        (  4,   4,   4,   4,   4,   4),
        (  5,   5,   5,   5,   5,   5),
        (  6,   6,   6,   6,   6,   6),
        (  7,   7,   7,   7,   7,   7),
        (  8,   8,   8,   8,   8,   8),
        (  9,   9,   9,   9,   9,   9)
      )

Because you supplied 6 members in each tuple, the type you'll get back will be a `TableFor6`.

The table provides an `apply` method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The `apply` method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the `apply` method will complete abruptly with a`TableDrivenPropertyCheckFailedException` that wraps the exception thrown by the supplied property function.

The usual way you'd invoke the `apply` method that checks a property is via a `forAll` method provided by trait `TableDrivenPropertyChecks`. The `forAll` method takes a `TableFor6` as its first argument, then in a curried argument list takes the property check function. It invokes `apply` on the `TableFor6`, passing in the property check function. Here's an example:

    forAll (examples) { (a, b, c, d, e, f) =>
      a + b + c + d + e + f should equal (a * 6)
    }

Because `TableFor6` is a `Seq[(A, B, C, D, E, F)]`, you can use it as a `Seq`. For example, here's how you could get a sequence of optional exceptions for each row of the table, indicating whether a property check succeeded or failed on each row of the table:

    for (row <- examples) yield {
      failureOf { row._1 should not equal (7) }
    }

Note: the `failureOf` method, contained in the `FailureOf` trait, will execute the supplied code (a by-name parameter) and catch any exception. If no exception is thrown by the code, `failureOf` will result in `None`, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, `failureOf` will result in a `Some` wrapping that exception. For example, the previous for expression would give you:

    Vector(None, None, None, None, None, None, None,
        Some(org.scalatest.TestFailedException: 7 equaled 7), None, None)

This shows that all the property checks succeeded, except for the one at index 7.

go to: companion
linear super types: IndexedSeq[(A, B, C, D, E, F)], IndexedSeqLike[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]], Seq[(A, B, C, D, E, F)], SeqLike[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]], Iterable[(A, B, C, D, E, F)], IterableLike[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]], Equals, Traversable[(A, B, C, D, E, F)], GenericTraversableTemplate[(A, B, C, D, E, F), IndexedSeq], TraversableLike[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]], TraversableOnce[(A, B, C, D, E, F)], FilterMonadic[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]], HasNewBuilder[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]], PartialFunction[Int, (A, B, C, D, E, F)], (Int) ⇒ (A, B, C, D, E, F), AnyRef, Any
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. Hide All
2. Show all

1. TableFor6
2. IndexedSeq
3. IndexedSeqLike
4. Seq
5. SeqLike
6. Iterable
7. IterableLike
8. Equals
9. Traversable
10. GenericTraversableTemplate
11. TraversableLike
12. TraversableOnce
13. FilterMonadic
14. HasNewBuilder
15. PartialFunction
16. Function1
17. AnyRef
18. Any

Visibility

1. Public
2. All

Impl.

1. Concrete
2. Abstract

### Instance constructors

1. #### new TableFor6 (heading: (String, String, String, String, String, String), rows: (A, B, C, D, E, F)*)

   heading

     a tuple containing string names of the columns in this table

   rows

     a variable length parameter list of `Tuple6`s containing the data of this table

### Type Members

1. #### type Self = TableFor6[A, B, C, D, E, F]

   attributes: protected
   definition classes: TraversableLike

### Value Members

1. #### def != (arg0: AnyRef) : Boolean

   attributes: final
   definition classes: AnyRef

2. #### def != (arg0: Any) : Boolean

   `o != arg0` is the same as `!(o == (arg0))`.

   `o != arg0` is the same as `!(o == (arg0))`.

   arg0

     the object to compare against this object for dis-equality.

   returns

     `false` if the receiver object is equivalent to the argument; `true` otherwise.

   attributes: final
   definition classes: Any

3. #### def ## () : Int

   attributes: final
   definition classes: AnyRef → Any

4. #### def $asInstanceOf [T0] () : T0

   attributes: final
   definition classes: AnyRef

5. #### def $isInstanceOf [T0] () : Boolean

   attributes: final
   definition classes: AnyRef

6. #### def ++ [B >: A, That] (that: TraversableOnce[B])(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], B, That]) : That

   definition classes: TraversableLike

7. #### def +: [B >: A, That] (elem: B)(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], B, That]) : That

   definition classes: SeqLike

8. #### def /: [B] (z: B)(op: (B, (A, B, C, D, E, F)) ⇒ B) : B

   definition classes: TraversableOnce

9. #### def :+ [B >: A, That] (elem: B)(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], B, That]) : That

   definition classes: SeqLike

10. #### def :\ [B] (z: B)(op: ((A, B, C, D, E, F), B) ⇒ B) : B

    definition classes: TraversableOnce

11. #### def == (arg0: AnyRef) : Boolean

    `o == arg0` is the same as `if (o eq null) arg0 eq null else o.equals(arg0)`.

    `o == arg0` is the same as `if (o eq null) arg0 eq null else o.equals(arg0)`.

    arg0

      the object to compare against this object for equality.

    returns

      `true` if the receiver object is equivalent to the argument; `false` otherwise.

    attributes: final
    definition classes: AnyRef

12. #### def == (arg0: Any) : Boolean

    `o == arg0` is the same as `o.equals(arg0)`.

    `o == arg0` is the same as `o.equals(arg0)`.

    arg0

      the object to compare against this object for equality.

    returns

      `true` if the receiver object is equivalent to the argument; `false` otherwise.

    attributes: final
    definition classes: Any

13. #### def addString (b: StringBuilder) : StringBuilder

    definition classes: TraversableOnce

14. #### def addString (b: StringBuilder, sep: String) : StringBuilder

    definition classes: TraversableOnce

15. #### def addString (b: StringBuilder, start: String, sep: String, end: String) : StringBuilder

    definition classes: TraversableOnce

16. #### def andThen [C] (k: ((A, B, C, D, E, F)) ⇒ C) : PartialFunction[Int, C]

    definition classes: PartialFunction → Function1

17. #### def apply (fun: (A, B, C, D, E, F) ⇒ Unit) : Unit

    Applies the passed property check function to each row of this `TableFor6`.

    Applies the passed property check function to each row of this `TableFor6`.

    If the property checks for all rows succeed (the property check function returns normally when passed the data for each row), this `apply` method returns normally. If the property check function completes abruptly with an exception for any row, this `apply` method wraps that exception in a `TableDrivenPropertyCheckFailedException` and completes abruptly with that exception. Once the property check function throws an exception for a row, this `apply` method will complete abruptly immediately and subsequent rows will not be checked against the function.

    fun

      the property check function to apply to each row of this `TableFor6`

18. #### def apply (idx: Int) : (A, B, C, D, E, F)

    Selects a row of data by its index.

    Selects a row of data by its index.

    definition classes: TableFor6 → SeqLike → Function1

19. #### def asInstanceOf [T0] : T0

    This method is used to cast the receiver object to be of type `T0`.

    This method is used to cast the receiver object to be of type `T0`.

    Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression`1.asInstanceOf[String]` will throw a `ClassCastException` at runtime, while the expression`List(1).asInstanceOf[List[String]]` will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested typed.

    returns

      the receiver object.

    attributes: final
    definition classes: Any

20. #### def canEqual (that: Any) : Boolean

    definition classes: IterableLike → Equals

21. #### def clone () : AnyRef

    This method creates and returns a copy of the receiver object.

    This method creates and returns a copy of the receiver object.

    The default implementation of the `clone` method is platform dependent.

    returns

      a copy of the receiver object.

    attributes: protected
    definition classes: AnyRef

22. #### def collect [B, That] (pf: PartialFunction[(A, B, C, D, E, F), B])(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], B, That]) : That

    definition classes: TraversableLike

23. #### def companion : GenericCompanion[IndexedSeq]

    definition classes: IndexedSeq → Seq → Iterable → Traversable → GenericTraversableTemplate

24. #### def compose [A] (g: (A) ⇒ Int) : (A) ⇒ (A, B, C, D, E, F)

    definition classes: Function1

25. #### def contains (elem: Any) : Boolean

    definition classes: SeqLike

26. #### def containsSlice [B] (that: Seq[B]) : Boolean

    definition classes: SeqLike

27. #### def copyToArray [B >: A] (xs: Array[B], start: Int, len: Int) : Unit

    definition classes: IterableLike → TraversableLike → TraversableOnce

28. #### def copyToArray [B >: A] (xs: Array[B]) : Unit

    definition classes: TraversableOnce

29. #### def copyToArray [B >: A] (xs: Array[B], start: Int) : Unit

    definition classes: TraversableOnce

30. #### def copyToBuffer [B >: A] (dest: Buffer[B]) : Unit

    definition classes: TraversableOnce

31. #### def corresponds [B] (that: Seq[B])(p: ((A, B, C, D, E, F), B) ⇒ Boolean) : Boolean

    definition classes: SeqLike

32. #### def count (p: ((A, B, C, D, E, F)) ⇒ Boolean) : Int

    definition classes: TraversableOnce

33. #### def diff [B >: A] (that: Seq[B]) : TableFor6[A, B, C, D, E, F]

    definition classes: SeqLike

34. #### def distinct : TableFor6[A, B, C, D, E, F]

    definition classes: SeqLike

35. #### def drop (n: Int) : TableFor6[A, B, C, D, E, F]

    definition classes: TraversableLike

36. #### def dropRight (n: Int) : TableFor6[A, B, C, D, E, F]

    definition classes: IterableLike

37. #### def dropWhile (p: ((A, B, C, D, E, F)) ⇒ Boolean) : TableFor6[A, B, C, D, E, F]

    definition classes: TraversableLike

38. #### def elements : Iterator[(A, B, C, D, E, F)]

    definition classes: IterableLike
    deprecated:

    1. use `iterator' instead`

39. #### def endsWith [B] (that: Seq[B]) : Boolean

    definition classes: SeqLike

40. #### def eq (arg0: AnyRef) : Boolean

    This method is used to test whether the argument (`arg0`) is a reference to the receiver object (`this`).

    This method is used to test whether the argument (`arg0`) is a reference to the receiver object (`this`).

    The `eq` method implements an [http://en.wikipedia.org/wiki/Equivalence_relation equivalence relation] on non-null instances of `AnyRef`: * It is reflexive: for any non-null instance `x` of type `AnyRef`, `x.eq(x)` returns `true`. * It is symmetric: for any non-null instances `x` and `y` of type `AnyRef`, `x.eq(y)` returns `true` if and only if `y.eq(x)` returns `true`. * It is transitive: for any non-null instances `x`, `y`, and `z` of type `AnyRef` if `x.eq(y)` returns `true` and `y.eq(z)` returns `true`, then `x.eq(z)` returns `true`.

    Additionally, the `eq` method has three other properties. * It is consistent: for any non-null instances `x` and `y` of type `AnyRef`, multiple invocations of `x.eq(y)` consistently returns `true` or consistently returns `false`. * For any non-null instance `x` of type `AnyRef`, `x.eq(null)` and `null.eq(x)` returns `false`. * `null.eq(null)` returns `true`.

    When overriding the `equals` or `hashCode` methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (`o1 eq o2`), they should be equal to each other (`o1 == o2`) and they should hash to the same value (`o1.hashCode == o2.hashCode`).

    arg0

      the object to compare against this object for reference equality.

    returns

      `true` if the argument is a reference to the receiver object; `false` otherwise.

    attributes: final
    definition classes: AnyRef

41. #### def equals (that: Any) : Boolean

    This method is used to compare the receiver object (`this`) with the argument object (`arg0`) for equivalence.

    This method is used to compare the receiver object (`this`) with the argument object (`arg0`) for equivalence.

    The default implementations of this method is an [http://en.wikipedia.org/wiki/Equivalence_relation equivalence relation]: * It is reflexive: for any instance `x` of type `Any`, `x.equals(x)` should return `true`. * It is symmetric: for any instances `x` and `y` of type `Any`, `x.equals(y)` should return `true` if and only if `y.equals(x)` returns `true`. * It is transitive: for any instances `x`, `y`, and `z` of type `AnyRef` if `x.equals(y)` returns `true` and `y.equals(z)` returns `true`, then `x.equals(z)` should return `true`.

    If you override this method, you should verify that your implementation remains an equivalence relation. Additionally, when overriding this method it is often necessary to override `hashCode` to ensure that objects that are "equal" (`o1.equals(o2)` returns `true`) hash to the same scala.Int (`o1.hashCode.equals(o2.hashCode)`).

    returns

      `true` if the receiver object is equivalent to the argument; `false` otherwise.

    definition classes: SeqLike → Equals → AnyRef → Any

42. #### def equalsWith [B] (that: Seq[B])(f: ((A, B, C, D, E, F), B) ⇒ Boolean) : Boolean

    definition classes: SeqLike
    deprecated:

    1. use `corresponds` instead

43. #### def exists (p: ((A, B, C, D, E, F)) ⇒ Boolean) : Boolean

    definition classes: IterableLike → TraversableLike → TraversableOnce

44. #### def filter (p: ((A, B, C, D, E, F)) ⇒ Boolean) : TableFor6[A, B, C, D, E, F]

    definition classes: TraversableLike

45. #### def filterNot (p: ((A, B, C, D, E, F)) ⇒ Boolean) : TableFor6[A, B, C, D, E, F]

    definition classes: TraversableLike

46. #### def finalize () : Unit

    This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.

    This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.

    The details of when and if the `finalize` method are invoked, as well as the interaction between `finalize`and non-local returns and exceptions, are all platform dependent.

    attributes: protected
    definition classes: AnyRef

47. #### def find (p: ((A, B, C, D, E, F)) ⇒ Boolean) : Option[(A, B, C, D, E, F)]

    definition classes: IterableLike → TraversableLike → TraversableOnce

48. #### def findIndexOf (p: ((A, B, C, D, E, F)) ⇒ Boolean) : Int

    definition classes: SeqLike

49. #### def findLastIndexOf (p: ((A, B, C, D, E, F)) ⇒ Boolean) : Int

    definition classes: SeqLike
    deprecated:

    1. use `lastIndexWhere` instead

50. #### def first : (A, B, C, D, E, F)

    definition classes: IterableLike
    deprecated:

    1. use `head' instead`

51. #### def firstOption : Option[(A, B, C, D, E, F)]

    definition classes: IterableLike
    deprecated:

    1. use `headOption' instead`

52. #### def flatMap [B, That] (f: ((A, B, C, D, E, F)) ⇒ Traversable[B])(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], B, That]) : That

    definition classes: TraversableLike → FilterMonadic

53. #### def flatten [B] (implicit asTraversable: ((A, B, C, D, E, F)) ⇒ Traversable[B]) : IndexedSeq[B]

    definition classes: GenericTraversableTemplate

54. #### def foldLeft [B] (z: B)(op: (B, (A, B, C, D, E, F)) ⇒ B) : B

    definition classes: TraversableOnce

55. #### def foldRight [B] (z: B)(op: ((A, B, C, D, E, F), B) ⇒ B) : B

    definition classes: IterableLike → TraversableOnce

56. #### def forall (p: ((A, B, C, D, E, F)) ⇒ Boolean) : Boolean

    definition classes: IterableLike → TraversableLike → TraversableOnce

57. #### def foreach [U] (f: ((A, B, C, D, E, F)) ⇒ U) : Unit

    definition classes: IterableLike → TraversableLike → TraversableOnce → FilterMonadic

58. #### def genericBuilder [B] : Builder[B, IndexedSeq[B]]

    definition classes: GenericTraversableTemplate

59. #### def getClass () : java.lang.Class[_]

    Returns a representation that corresponds to the dynamic class of the receiver object.

    Returns a representation that corresponds to the dynamic class of the receiver object.

    The nature of the representation is platform dependent.

    returns

      a representation that corresponds to the dynamic class of the receiver object.

    attributes: final
    definition classes: AnyRef

60. #### def groupBy [K] (f: ((A, B, C, D, E, F)) ⇒ K) : Map[K, TableFor6[A, B, C, D, E, F]]

    definition classes: TraversableLike

61. #### def grouped (size: Int) : Iterator[TableFor6[A, B, C, D, E, F]]

    definition classes: IterableLike

62. #### def hasDefiniteSize : Boolean

    definition classes: TraversableLike → TraversableOnce

63. #### def hashCode () : Int

    Returns a hash code value for the object.

    Returns a hash code value for the object.

    The default hashing algorithm is platform dependent.

    Note that it is allowed for two objects to have identical hash codes (`o1.hashCode.equals(o2.hashCode)`) yet not be equal (`o1.equals(o2)` returns `false`). A degenerate implementation could always return `0`. However, it is required that if two objects are equal (`o1.equals(o2)` returns `true`) that they have identical hash codes (`o1.hashCode.equals(o2.hashCode)`). Therefore, when overriding this method, be sure to verify that the behavior is consistent with the `equals` method.

    returns

      the hash code value for the object.

    definition classes: SeqLike → AnyRef → Any

64. #### def head : (A, B, C, D, E, F)

    definition classes: IterableLike → TraversableLike

65. #### def headOption : Option[(A, B, C, D, E, F)]

    definition classes: TraversableLike

66. #### val heading : (String, String, String, String, String, String)

    a tuple containing string names of the columns in this table

    a tuple containing string names of the columns in this table

67. #### def indexOf [B >: A] (elem: B, from: Int) : Int

    definition classes: SeqLike

68. #### def indexOf [B >: A] (elem: B) : Int

    definition classes: SeqLike

69. #### def indexOfSlice [B >: A] (that: Seq[B], from: Int) : Int

    definition classes: SeqLike

70. #### def indexOfSlice [B >: A] (that: Seq[B]) : Int

    definition classes: SeqLike

71. #### def indexWhere (p: ((A, B, C, D, E, F)) ⇒ Boolean, from: Int) : Int

    definition classes: SeqLike

72. #### def indexWhere (p: ((A, B, C, D, E, F)) ⇒ Boolean) : Int

    definition classes: SeqLike

73. #### def indices : Range

    definition classes: SeqLike

74. #### def init : TableFor6[A, B, C, D, E, F]

    definition classes: TraversableLike

75. #### def intersect [B >: A] (that: Seq[B]) : TableFor6[A, B, C, D, E, F]

    definition classes: SeqLike

76. #### def isDefinedAt (idx: Int) : Boolean

    definition classes: SeqLike

77. #### def isEmpty : Boolean

    definition classes: IterableLike → TraversableLike → TraversableOnce

78. #### def isInstanceOf [T0] : Boolean

    This method is used to test whether the dynamic type of the receiver object is `T0`.

    This method is used to test whether the dynamic type of the receiver object is `T0`.

    Note that the test result of the test is modulo Scala's erasure semantics. Therefore the expression`1.isInstanceOf[String]` will return `false`, while the expression `List(1).isInstanceOf[List[String]]` will return `true`. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested typed.

    returns

      `true` if the receiver object is an instance of erasure of type `T0`; `false` otherwise.

    attributes: final
    definition classes: Any

79. #### def isTraversableAgain : Boolean

    attributes: final
    definition classes: TraversableLike → TraversableOnce

80. #### def iterator : Iterator[(A, B, C, D, E, F)]

    definition classes: IndexedSeqLike → IterableLike

81. #### def last : (A, B, C, D, E, F)

    definition classes: TraversableLike

82. #### def lastIndexOf [B >: A] (elem: B, end: Int) : Int

    definition classes: SeqLike

83. #### def lastIndexOf [B >: A] (elem: B) : Int

    definition classes: SeqLike

84. #### def lastIndexOfSlice [B >: A] (that: Seq[B], end: Int) : Int

    definition classes: SeqLike

85. #### def lastIndexOfSlice [B >: A] (that: Seq[B]) : Int

    definition classes: SeqLike

86. #### def lastIndexWhere (p: ((A, B, C, D, E, F)) ⇒ Boolean, end: Int) : Int

    definition classes: SeqLike

87. #### def lastIndexWhere (p: ((A, B, C, D, E, F)) ⇒ Boolean) : Int

    definition classes: SeqLike

88. #### def lastOption : Option[(A, B, C, D, E, F)]

    definition classes: TraversableLike

89. #### def length : Int

    The number of rows of data in the table.

    The number of rows of data in the table. (This does not include the `heading` tuple)

    definition classes: TableFor6 → SeqLike

90. #### def lengthCompare (len: Int) : Int

    definition classes: SeqLike

91. #### def lift : (Int) ⇒ Option[(A, B, C, D, E, F)]

    definition classes: PartialFunction

92. #### def map [B, That] (f: ((A, B, C, D, E, F)) ⇒ B)(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], B, That]) : That

    definition classes: TraversableLike → FilterMonadic

93. #### def max [B >: A] (implicit cmp: Ordering[B]) : (A, B, C, D, E, F)

    definition classes: TraversableOnce

94. #### def min [B >: A] (implicit cmp: Ordering[B]) : (A, B, C, D, E, F)

    definition classes: TraversableOnce

95. #### def mkString : String

    definition classes: TraversableOnce

96. #### def mkString (sep: String) : String

    definition classes: TraversableOnce

97. #### def mkString (start: String, sep: String, end: String) : String

    definition classes: TraversableOnce

98. #### def ne (arg0: AnyRef) : Boolean

    `o.ne(arg0)` is the same as `!(o.eq(arg0))`.

    `o.ne(arg0)` is the same as `!(o.eq(arg0))`.

    arg0

      the object to compare against this object for reference dis-equality.

    returns

      `false` if the argument is not a reference to the receiver object; `true` otherwise.

    attributes: final
    definition classes: AnyRef

99. #### def newBuilder : Builder[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]]

    Creates a new `Builder` for `TableFor6`s.

    Creates a new `Builder` for `TableFor6`s.

    attributes: protected[this]
    definition classes: TableFor6 → GenericTraversableTemplate → TraversableLike → HasNewBuilder

100. #### def nonEmpty : Boolean

     definition classes: TraversableOnce

101. #### def notify () : Unit

     Wakes up a single thread that is waiting on the receiver object's monitor.

     Wakes up a single thread that is waiting on the receiver object's monitor.

     attributes: final
     definition classes: AnyRef

102. #### def notifyAll () : Unit

     Wakes up all threads that are waiting on the receiver object's monitor.

     Wakes up all threads that are waiting on the receiver object's monitor.

     attributes: final
     definition classes: AnyRef

103. #### def orElse [A1 <: A, B1 >: B] (that: PartialFunction[A1, B1]) : PartialFunction[A1, B1]

     definition classes: PartialFunction

104. #### def padTo [B >: A, That] (len: Int, elem: B)(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], B, That]) : That

     definition classes: SeqLike

105. #### def partition (p: ((A, B, C, D, E, F)) ⇒ Boolean) : (TableFor6[A, B, C, D, E, F], TableFor6[A, B, C, D, E, F])

     definition classes: TraversableLike

106. #### def patch [B >: A, That] (from: Int, patch: Seq[B], replaced: Int)(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], B, That]) : That

     definition classes: SeqLike

107. #### def prefixLength (p: ((A, B, C, D, E, F)) ⇒ Boolean) : Int

     definition classes: SeqLike

108. #### def product [B >: A] (implicit num: Numeric[B]) : B

     definition classes: TraversableOnce

109. #### def projection : SeqView[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]]

     definition classes: SeqLike → IterableLike
     deprecated:

     1. use `view' instead`

110. #### def reduceLeft [B >: A] (op: (B, (A, B, C, D, E, F)) ⇒ B) : B

     definition classes: TraversableOnce

111. #### def reduceLeftOption [B >: A] (op: (B, (A, B, C, D, E, F)) ⇒ B) : Option[B]

     definition classes: TraversableOnce

112. #### def reduceRight [B >: A] (op: ((A, B, C, D, E, F), B) ⇒ B) : B

     definition classes: IterableLike → TraversableOnce

113. #### def reduceRightOption [B >: A] (op: ((A, B, C, D, E, F), B) ⇒ B) : Option[B]

     definition classes: TraversableOnce

114. #### def repr : TableFor6[A, B, C, D, E, F]

     definition classes: TraversableLike

115. #### def reverse : TableFor6[A, B, C, D, E, F]

     definition classes: SeqLike

116. #### def reverseIterator : Iterator[(A, B, C, D, E, F)]

     definition classes: SeqLike

117. #### def reverseMap [B, That] (f: ((A, B, C, D, E, F)) ⇒ B)(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], B, That]) : That

     definition classes: SeqLike

118. #### def reversed : List[(A, B, C, D, E, F)]

     attributes: protected[this]
     definition classes: TraversableOnce

119. #### def reversedElements : Iterator[(A, B, C, D, E, F)]

     definition classes: SeqLike
     deprecated:

     1. use `reverseIterator' instead`

120. #### def sameElements [B >: A] (that: Iterable[B]) : Boolean

     definition classes: IterableLike

121. #### def scanLeft [B, That] (z: B)(op: (B, (A, B, C, D, E, F)) ⇒ B)(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], B, That]) : That

     definition classes: TraversableLike

122. #### def scanRight [B, That] (z: B)(op: ((A, B, C, D, E, F), B) ⇒ B)(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], B, That]) : That

     definition classes: TraversableLike

123. #### def segmentLength (p: ((A, B, C, D, E, F)) ⇒ Boolean, from: Int) : Int

     definition classes: SeqLike

124. #### def size : Int

     definition classes: SeqLike → TraversableOnce

125. #### def slice (from: Int, until: Int) : TableFor6[A, B, C, D, E, F]

     definition classes: IterableLike → TraversableLike

126. #### def sliding [B >: A] (size: Int, step: Int) : Iterator[TableFor6[A, B, C, D, E, F]]

     definition classes: IterableLike

127. #### def sliding [B >: A] (size: Int) : Iterator[TableFor6[A, B, C, D, E, F]]

     definition classes: IterableLike

128. #### def sortBy [B] (f: ((A, B, C, D, E, F)) ⇒ B)(implicit ord: Ordering[B]) : TableFor6[A, B, C, D, E, F]

     definition classes: SeqLike

129. #### def sortWith (lt: ((A, B, C, D, E, F), (A, B, C, D, E, F)) ⇒ Boolean) : TableFor6[A, B, C, D, E, F]

     definition classes: SeqLike

130. #### def sorted [B >: A] (implicit ord: Ordering[B]) : TableFor6[A, B, C, D, E, F]

     definition classes: SeqLike

131. #### def span (p: ((A, B, C, D, E, F)) ⇒ Boolean) : (TableFor6[A, B, C, D, E, F], TableFor6[A, B, C, D, E, F])

     definition classes: TraversableLike

132. #### def splitAt (n: Int) : (TableFor6[A, B, C, D, E, F], TableFor6[A, B, C, D, E, F])

     definition classes: TraversableLike

133. #### def startsWith [B] (that: Seq[B]) : Boolean

     definition classes: SeqLike

134. #### def startsWith [B] (that: Seq[B], offset: Int) : Boolean

     definition classes: SeqLike

135. #### def stringPrefix : String

     definition classes: TraversableLike

136. #### def sum [B >: A] (implicit num: Numeric[B]) : B

     definition classes: TraversableOnce

137. #### def synchronized [T0] (arg0: T0) : T0

     attributes: final
     definition classes: AnyRef

138. #### def tail : TableFor6[A, B, C, D, E, F]

     definition classes: TraversableLike

139. #### def take (n: Int) : TableFor6[A, B, C, D, E, F]

     definition classes: IterableLike → TraversableLike

140. #### def takeRight (n: Int) : TableFor6[A, B, C, D, E, F]

     definition classes: IterableLike

141. #### def takeWhile (p: ((A, B, C, D, E, F)) ⇒ Boolean) : TableFor6[A, B, C, D, E, F]

     definition classes: IterableLike → TraversableLike

142. #### def thisCollection : IndexedSeq[(A, B, C, D, E, F)]

     attributes: protected[this]
     definition classes: IndexedSeqLike → SeqLike → IterableLike → TraversableLike

143. #### def toArray [B >: A] (implicit arg0: ClassManifest[B]) : Array[B]

     definition classes: TraversableOnce

144. #### def toBuffer [B >: A] : Buffer[B]

     definition classes: TraversableOnce

145. #### def toCollection (repr: TableFor6[A, B, C, D, E, F]) : IndexedSeq[(A, B, C, D, E, F)]

     attributes: protected[this]
     definition classes: IndexedSeqLike → SeqLike → IterableLike → TraversableLike

146. #### def toIndexedSeq [B >: A] : IndexedSeq[B]

     definition classes: TraversableOnce

147. #### def toIterable : Iterable[(A, B, C, D, E, F)]

     definition classes: IterableLike → TraversableOnce

148. #### def toIterator : Iterator[(A, B, C, D, E, F)]

     definition classes: TraversableLike → TraversableOnce

149. #### def toList : List[(A, B, C, D, E, F)]

     definition classes: TraversableOnce

150. #### def toMap [T, U] (implicit ev: <:<[(A, B, C, D, E, F), (T, U)]) : Map[T, U]

     definition classes: TraversableOnce

151. #### def toSeq : Seq[(A, B, C, D, E, F)]

     definition classes: SeqLike → IterableLike → TraversableOnce

152. #### def toSet [B >: A] : Set[B]

     definition classes: TraversableOnce

153. #### def toStream : Stream[(A, B, C, D, E, F)]

     definition classes: IterableLike → TraversableLike → TraversableOnce

154. #### def toString () : String

     A string representation of this object, which includes the heading strings as well as the rows of data.

     A string representation of this object, which includes the heading strings as well as the rows of data.@return a string representation of the object. */

     definition classes: TableFor6 → SeqLike → TraversableLike → Function1 → AnyRef → Any

155. #### def toTraversable : Traversable[(A, B, C, D, E, F)]

     definition classes: TraversableLike → TraversableOnce

156. #### def transpose [B] (implicit asTraversable: ((A, B, C, D, E, F)) ⇒ Traversable[B]) : IndexedSeq[IndexedSeq[B]]

     definition classes: GenericTraversableTemplate

157. #### def union [B >: A, That] (that: Seq[B])(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], B, That]) : That

     definition classes: SeqLike

158. #### def unzip [A1, A2] (implicit asPair: ((A, B, C, D, E, F)) ⇒ (A1, A2)) : (IndexedSeq[A1], IndexedSeq[A2])

     definition classes: GenericTraversableTemplate

159. #### def updated [B >: A, That] (index: Int, elem: B)(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], B, That]) : That

     definition classes: SeqLike

160. #### def view (from: Int, until: Int) : SeqView[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]]

     definition classes: SeqLike → IterableLike → TraversableLike

161. #### def view : SeqView[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]]

     definition classes: SeqLike → IterableLike → TraversableLike

162. #### def wait () : Unit

     attributes: final
     definition classes: AnyRef

163. #### def wait (arg0: Long, arg1: Int) : Unit

     attributes: final
     definition classes: AnyRef

164. #### def wait (arg0: Long) : Unit

     attributes: final
     definition classes: AnyRef

165. #### def withFilter (p: ((A, B, C, D, E, F)) ⇒ Boolean) : FilterMonadic[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]]

     definition classes: TraversableLike → FilterMonadic

166. #### def zip [A1 >: A, B, That] (that: Iterable[B])(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], (A1, B), That]) : That

     definition classes: IterableLike

167. #### def zipAll [B, A1 >: A, That] (that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], (A1, B), That]) : That

     definition classes: IterableLike

168. #### def zipWithIndex [A1 >: A, That] (implicit bf: CanBuildFrom[TableFor6[A, B, C, D, E, F], (A1, Int), That]) : That

     definition classes: IterableLike

### Inherited from IndexedSeq[(A, B, C, D, E, F)]

### Inherited from IndexedSeqLike[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]]

### Inherited from Seq[(A, B, C, D, E, F)]

### Inherited from SeqLike[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]]

### Inherited from Iterable[(A, B, C, D, E, F)]

### Inherited from IterableLike[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]]

### Inherited from Equals

### Inherited from Traversable[(A, B, C, D, E, F)]

### Inherited from GenericTraversableTemplate[(A, B, C, D, E, F), IndexedSeq]

### Inherited from TraversableLike[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]]

### Inherited from TraversableOnce[(A, B, C, D, E, F)]

### Inherited from FilterMonadic[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]]

### Inherited from HasNewBuilder[(A, B, C, D, E, F), TableFor6[A, B, C, D, E, F]]

### Inherited from PartialFunction[Int, (A, B, C, D, E, F)]

### Inherited from (Int) ⇒ (A, B, C, D, E, F)

### Inherited from AnyRef

### Inherited from Any