org.scalatest.prop

# TableFor19

#### class TableFor19 [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] with IndexedSeqLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

A table with 19 columns.

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

This table is a sequence of `Tuple19` 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 `TableFor19` 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", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s"),
        (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
        (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
        (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
        (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
        (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
        (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
        (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
        (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
        (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
        (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
      )

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

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 `TableFor19` as its first argument, then in a curried argument list takes the property check function. It invokes `apply` on the `TableFor19`, passing in the property check function. Here's an example:

    forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) =>
      a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r + s should equal (a * 19)
    }

Because `TableFor19` is a `Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]`, 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.

Linear Supertypes
IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)], IndexedSeqLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]], Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)], SeqLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]], GenSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)], GenSeqLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]], Iterable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)], IterableLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]], Equals, GenIterable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)], GenIterableLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]], Traversable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)], GenTraversable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)], GenericTraversableTemplate[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), IndexedSeq], TraversableLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]], GenTraversableLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]], Parallelizable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), ParSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]], TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)], GenTraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)], FilterMonadic[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]], HasNewBuilder[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]], PartialFunction[Int, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)], (Int) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), AnyRef, Any
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. Hide All
2. Show all

1. TableFor19
2. IndexedSeq
3. IndexedSeqLike
4. Seq
5. SeqLike
6. GenSeq
7. GenSeqLike
8. Iterable
9. IterableLike
10. Equals
11. GenIterable
12. GenIterableLike
13. Traversable
14. GenTraversable
15. GenericTraversableTemplate
16. TraversableLike
17. GenTraversableLike
18. Parallelizable
19. TraversableOnce
20. GenTraversableOnce
21. FilterMonadic
22. HasNewBuilder
23. PartialFunction
24. Function1
25. AnyRef
26. Any

Visibility

1. Public
2. All

### Instance Constructors

1. #### new TableFor19 (heading: (String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String), rows: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)*)

   heading

     a tuple containing string names of the columns in this table

   rows

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

### Type Members

1. #### type Self = TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

   Attributes
     protected
   Definition Classes
     TraversableLike

### Value Members

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

   Attributes
     final
   Definition Classes
     AnyRef

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

   Attributes
     final
   Definition Classes
     Any

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

   Attributes
     final
   Definition Classes
     AnyRef → Any

4. #### def ++ [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (that: TraversableOnce[B])(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

   Definition Classes
     TraversableLike
   Annotations
     @bridge()

5. #### def ++ [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

   Definition Classes
     TraversableLike → GenTraversableLike

6. #### def ++: [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (that: Traversable[B])(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

   Definition Classes
     TraversableLike

7. #### def ++: [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (that: TraversableOnce[B])(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

   Definition Classes
     TraversableLike

8. #### def +: [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (elem: B)(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

   Definition Classes
     SeqLike → GenSeqLike

9. #### def /: [B] (z: B)(op: (B, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ B): B

   Definition Classes
     TraversableOnce → GenTraversableOnce

10. #### def /:\ [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (z: A1)(op: (A1, A1) ⇒ A1): A1

    Definition Classes
      GenTraversableOnce

11. #### def :+ [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (elem: B)(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

    Definition Classes
      SeqLike → GenSeqLike

12. #### def :\ [B] (z: B)(op: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), B) ⇒ B): B

    Definition Classes
      TraversableOnce → GenTraversableOnce

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

    Attributes
      final
    Definition Classes
      AnyRef

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

    Attributes
      final
    Definition Classes
      Any

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

    Definition Classes
      TraversableOnce

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

    Definition Classes
      TraversableOnce

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

    Definition Classes
      TraversableOnce

18. #### def aggregate [B] (z: B)(seqop: (B, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ B, combop: (B, B) ⇒ B): B

    Definition Classes
      TraversableOnce → GenTraversableOnce

19. #### def andThen [C] (k: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ C): PartialFunction[Int, C]

    Definition Classes
      PartialFunction → Function1

20. #### def apply (fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ Unit): Unit

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

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

    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 `TableFor19`

21. #### def apply (idx: Int): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

    Selects a row of data by its index.

    Selects a row of data by its index.

    Definition Classes
      TableFor19 → SeqLike → GenSeqLike → Function1

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

    Attributes
      final
    Definition Classes
      Any

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

    Definition Classes
      IterableLike → Equals

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

    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws()

25. #### def collect [B, That] (pf: PartialFunction[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), B])(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

    Definition Classes
      TraversableLike → GenTraversableLike

26. #### def collectFirst [B] (pf: PartialFunction[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), B]): Option[B]

    Definition Classes
      TraversableOnce

27. #### def combinations (n: Int): Iterator[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

    Definition Classes
      SeqLike

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

    Definition Classes
      IndexedSeq → Seq → GenSeq → Iterable → GenIterable → Traversable → GenTraversable → GenericTraversableTemplate

29. #### def compose [A] (g: (A) ⇒ Int): (A) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

    Definition Classes
      Function1

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

    Definition Classes
      SeqLike

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

    Definition Classes
      SeqLike
    Annotations
      @bridge()

32. #### def containsSlice [B] (that: GenSeq[B]): Boolean

    Definition Classes
      SeqLike

33. #### def copyToArray [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (xs: Array[B], start: Int, len: Int): Unit

    Definition Classes
      IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

34. #### def copyToArray [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (xs: Array[B]): Unit

    Definition Classes
      TraversableOnce → GenTraversableOnce

35. #### def copyToArray [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (xs: Array[B], start: Int): Unit

    Definition Classes
      TraversableOnce → GenTraversableOnce

36. #### def copyToBuffer [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (dest: Buffer[B]): Unit

    Definition Classes
      TraversableOnce

37. #### def corresponds [B] (that: Seq[B])(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), B) ⇒ Boolean): Boolean

    Definition Classes
      SeqLike
    Annotations
      @bridge()

38. #### def corresponds [B] (that: GenSeq[B])(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), B) ⇒ Boolean): Boolean

    Definition Classes
      SeqLike → GenSeqLike

39. #### def count (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): Int

    Definition Classes
      TraversableOnce → GenTraversableOnce

40. #### def diff [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: Seq[B]): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

    Definition Classes
      SeqLike
    Annotations
      @bridge()

41. #### def diff [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: GenSeq[B]): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

    Definition Classes
      SeqLike → GenSeqLike

42. #### def distinct : TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

    Definition Classes
      SeqLike → GenSeqLike

43. #### def drop (n: Int): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

    Definition Classes
      IterableLike → TraversableLike → GenTraversableLike

44. #### def dropRight (n: Int): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

    Definition Classes
      IterableLike

45. #### def dropWhile (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

    Definition Classes
      TraversableLike → GenTraversableLike

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

    Definition Classes
      SeqLike
    Annotations
      @bridge()

47. #### def endsWith [B] (that: GenSeq[B]): Boolean

    Definition Classes
      SeqLike → GenSeqLike

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

    Attributes
      final
    Definition Classes
      AnyRef

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

    Definition Classes
      GenSeqLike → Equals → AnyRef → Any

50. #### def exists (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): Boolean

    Definition Classes
      IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

51. #### def filter (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

    Definition Classes
      TraversableLike → GenTraversableLike

52. #### def filterNot (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

    Definition Classes
      TraversableLike → GenTraversableLike

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

    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws()

54. #### def find (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

    Definition Classes
      IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

55. #### def flatMap [B, That] (f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

    Definition Classes
      TraversableLike → GenTraversableLike → FilterMonadic

56. #### def flatten [B] (implicit asTraversable: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ TraversableOnce[B]): Traversable[B]

    Definition Classes
      Traversable → GenericTraversableTemplate
    Annotations
      @bridge()

57. #### def fold [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (z: A1)(op: (A1, A1) ⇒ A1): A1

    Definition Classes
      TraversableOnce → GenTraversableOnce

58. #### def foldLeft [B] (z: B)(op: (B, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ B): B

    Definition Classes
      TraversableOnce → GenTraversableOnce

59. #### def foldRight [B] (z: B)(op: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), B) ⇒ B): B

    Definition Classes
      IterableLike → TraversableOnce → GenTraversableOnce

60. #### def forall (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): Boolean

    Definition Classes
      IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

61. #### def foreach [U] (f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ U): Unit

    Definition Classes
      IterableLike → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic

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

    Definition Classes
      GenericTraversableTemplate

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

    Attributes
      final
    Definition Classes
      AnyRef

64. #### def groupBy [K] (f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ K): Map[K, TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

    Definition Classes
      TraversableLike → GenTraversableLike

65. #### def grouped (size: Int): Iterator[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

    Definition Classes
      IterableLike

66. #### def hasDefiniteSize : Boolean

    Definition Classes
      TraversableLike → TraversableOnce → GenTraversableOnce

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

    Definition Classes
      GenSeqLike → AnyRef → Any

68. #### def head : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

    Definition Classes
      IterableLike → GenIterableLike → TraversableLike → GenTraversableLike

69. #### def headOption : Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

    Definition Classes
      TraversableLike

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

    a tuple containing string names of the columns in this table

71. #### def indexOf [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (elem: B, from: Int): Int

    Definition Classes
      GenSeqLike

72. #### def indexOf [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (elem: B): Int

    Definition Classes
      GenSeqLike

73. #### def indexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: Seq[B], from: Int): Int

    Definition Classes
      SeqLike
    Annotations
      @bridge()

74. #### def indexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: GenSeq[B], from: Int): Int

    Definition Classes
      SeqLike

75. #### def indexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: Seq[B]): Int

    Definition Classes
      SeqLike
    Annotations
      @bridge()

76. #### def indexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: GenSeq[B]): Int

    Definition Classes
      SeqLike

77. #### def indexWhere (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean, from: Int): Int

    Definition Classes
      SeqLike → GenSeqLike

78. #### def indexWhere (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): Int

    Definition Classes
      GenSeqLike

79. #### def indices : Range

    Definition Classes
      SeqLike

80. #### def init : TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

    Definition Classes
      TraversableLike

81. #### def inits : Iterator[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

    Definition Classes
      TraversableLike

82. #### def intersect [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: Seq[B]): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

    Definition Classes
      SeqLike
    Annotations
      @bridge()

83. #### def intersect [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: GenSeq[B]): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

    Definition Classes
      SeqLike → GenSeqLike

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

    Definition Classes
      GenSeqLike

85. #### def isEmpty : Boolean

    Definition Classes
      IterableLike → GenIterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

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

    Attributes
      final
    Definition Classes
      Any

87. #### def isTraversableAgain : Boolean

    Attributes
      final
    Definition Classes
      GenTraversableLike → GenTraversableOnce

88. #### def iterator : Iterator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

    Definition Classes
      IndexedSeqLike → IterableLike → GenIterableLike

89. #### def last : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

    Definition Classes
      TraversableLike

90. #### def lastIndexOf [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (elem: B, end: Int): Int

    Definition Classes
      GenSeqLike

91. #### def lastIndexOf [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (elem: B): Int

    Definition Classes
      GenSeqLike

92. #### def lastIndexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: Seq[B], end: Int): Int

    Definition Classes
      SeqLike
    Annotations
      @bridge()

93. #### def lastIndexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: GenSeq[B], end: Int): Int

    Definition Classes
      SeqLike

94. #### def lastIndexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: Seq[B]): Int

    Definition Classes
      SeqLike
    Annotations
      @bridge()

95. #### def lastIndexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: GenSeq[B]): Int

    Definition Classes
      SeqLike

96. #### def lastIndexWhere (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean, end: Int): Int

    Definition Classes
      SeqLike → GenSeqLike

97. #### def lastIndexWhere (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): Int

    Definition Classes
      GenSeqLike

98. #### def lastOption : Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

    Definition Classes
      TraversableLike

99. #### 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
      TableFor19 → SeqLike → GenSeqLike

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

     Definition Classes
       SeqLike

101. #### def lift : (Int) ⇒ Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Definition Classes
       PartialFunction

102. #### def map [B, That] (f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ B)(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

     Definition Classes
       TraversableLike → GenTraversableLike → FilterMonadic

103. #### def max [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (implicit cmp: Ordering[B]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

     Definition Classes
       TraversableOnce → GenTraversableOnce

104. #### def maxBy [B] (f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ B)(implicit cmp: Ordering[B]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

     Definition Classes
       TraversableOnce → GenTraversableOnce

105. #### def min [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (implicit cmp: Ordering[B]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

     Definition Classes
       TraversableOnce → GenTraversableOnce

106. #### def minBy [B] (f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ B)(implicit cmp: Ordering[B]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

     Definition Classes
       TraversableOnce → GenTraversableOnce

107. #### def mkString : String

     Definition Classes
       TraversableOnce → GenTraversableOnce

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

     Definition Classes
       TraversableOnce → GenTraversableOnce

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

     Definition Classes
       TraversableOnce → GenTraversableOnce

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

     Attributes
       final
     Definition Classes
       AnyRef

111. #### def newBuilder : Builder[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

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

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

     Attributes
       protected[this]
     Definition Classes
       TableFor19 → GenericTraversableTemplate → TraversableLike → HasNewBuilder

112. #### def nonEmpty : Boolean

     Definition Classes
       TraversableOnce → GenTraversableOnce

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

     Attributes
       final
     Definition Classes
       AnyRef

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

     Attributes
       final
     Definition Classes
       AnyRef

115. #### def orElse [A1 <: Int, B1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

     Definition Classes
       PartialFunction

116. #### def padTo [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (len: Int, elem: B)(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

     Definition Classes
       SeqLike → GenSeqLike

117. #### def par : ParSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Definition Classes
       Parallelizable

118. #### def parCombiner : Combiner[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), ParSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]]

     Attributes
       protected[this]
     Definition Classes
       SeqLike → TraversableLike → Parallelizable

119. #### def partition (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): (TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S])

     Definition Classes
       TraversableLike → GenTraversableLike

120. #### def patch [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (from: Int, patch: Seq[B], replaced: Int)(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

     Definition Classes
       SeqLike
     Annotations
       @bridge()

121. #### def patch [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

     Definition Classes
       SeqLike → GenSeqLike

122. #### def permutations : Iterator[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

     Definition Classes
       SeqLike

123. #### def prefixLength (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): Int

     Definition Classes
       GenSeqLike

124. #### def product [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (implicit num: Numeric[B]): B

     Definition Classes
       TraversableOnce → GenTraversableOnce

125. #### def reduce [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (op: (A1, A1) ⇒ A1): A1

     Definition Classes
       TraversableOnce → GenTraversableOnce

126. #### def reduceLeft [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (op: (B, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ B): B

     Definition Classes
       TraversableOnce

127. #### def reduceLeftOption [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (op: (B, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ B): Option[B]

     Definition Classes
       TraversableOnce → GenTraversableOnce

128. #### def reduceOption [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (op: (A1, A1) ⇒ A1): Option[A1]

     Definition Classes
       TraversableOnce → GenTraversableOnce

129. #### def reduceRight [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (op: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), B) ⇒ B): B

     Definition Classes
       IterableLike → TraversableOnce → GenTraversableOnce

130. #### def reduceRightOption [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (op: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), B) ⇒ B): Option[B]

     Definition Classes
       TraversableOnce → GenTraversableOnce

131. #### def repr : TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

     Definition Classes
       TraversableLike → GenTraversableLike

132. #### def reverse : TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

     Definition Classes
       SeqLike → GenSeqLike

133. #### def reverseIterator : Iterator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Definition Classes
       SeqLike

134. #### def reverseMap [B, That] (f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ B)(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

     Definition Classes
       SeqLike → GenSeqLike

135. #### def reversed : List[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Attributes
       protected[this]
     Definition Classes
       TraversableOnce

136. #### def sameElements [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: Iterable[B]): Boolean

     Definition Classes
       IterableLike
     Annotations
       @bridge()

137. #### def sameElements [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (that: GenIterable[B]): Boolean

     Definition Classes
       IterableLike → GenIterableLike

138. #### def scan [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

     Definition Classes
       TraversableLike → GenTraversableLike

139. #### def scanLeft [B, That] (z: B)(op: (B, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ B)(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

     Definition Classes
       TraversableLike → GenTraversableLike

140. #### def scanRight [B, That] (z: B)(op: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), B) ⇒ B)(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

     Definition Classes
       TraversableLike → GenTraversableLike
     Annotations
       @migration
     Migration

141. #### def segmentLength (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean, from: Int): Int

     Definition Classes
       SeqLike → GenSeqLike

142. #### def seq : Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Definition Classes
       Seq → GenSeq → Iterable → GenIterable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce

143. #### def size : Int

     Definition Classes
       SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce

144. #### def slice (from: Int, until: Int): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

     Definition Classes
       IterableLike → TraversableLike → GenTraversableLike

145. #### def sliding [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (size: Int, step: Int): Iterator[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

     Definition Classes
       IterableLike

146. #### def sliding [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (size: Int): Iterator[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

     Definition Classes
       IterableLike

147. #### def sortBy [B] (f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ B)(implicit ord: Ordering[B]): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

     Definition Classes
       SeqLike

148. #### def sortWith (lt: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

     Definition Classes
       SeqLike

149. #### def sorted [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (implicit ord: Ordering[B]): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

     Definition Classes
       SeqLike

150. #### def span (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): (TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S])

     Definition Classes
       TraversableLike → GenTraversableLike

151. #### def splitAt (n: Int): (TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S])

     Definition Classes
       TraversableLike → GenTraversableLike

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

     Definition Classes
       SeqLike
     Annotations
       @bridge()

153. #### def startsWith [B] (that: GenSeq[B], offset: Int): Boolean

     Definition Classes
       SeqLike → GenSeqLike

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

     Definition Classes
       GenSeqLike
     Annotations
       @bridge()

155. #### def startsWith [B] (that: GenSeq[B]): Boolean

     Definition Classes
       GenSeqLike

156. #### def stringPrefix : String

     Definition Classes
       TraversableLike → GenTraversableLike

157. #### def sum [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (implicit num: Numeric[B]): B

     Definition Classes
       TraversableOnce → GenTraversableOnce

158. #### def synchronized [T0] (arg0: ⇒ T0): T0

     Attributes
       final
     Definition Classes
       AnyRef

159. #### def tail : TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

     Definition Classes
       TraversableLike → GenTraversableLike

160. #### def tails : Iterator[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

     Definition Classes
       TraversableLike

161. #### def take (n: Int): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

     Definition Classes
       IterableLike → TraversableLike → GenTraversableLike

162. #### def takeRight (n: Int): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

     Definition Classes
       IterableLike

163. #### def takeWhile (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

     Definition Classes
       IterableLike → TraversableLike → GenTraversableLike

164. #### def thisCollection : IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Attributes
       protected[this]
     Definition Classes
       IndexedSeqLike → SeqLike → IterableLike → TraversableLike

165. #### def toArray [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] (implicit arg0: ClassManifest[B]): Array[B]

     Definition Classes
       TraversableOnce → GenTraversableOnce

166. #### def toBuffer [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] : Buffer[A1]

     Definition Classes
       IndexedSeqLike → TraversableOnce → GenTraversableOnce

167. #### def toCollection (repr: TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]): IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Attributes
       protected[this]
     Definition Classes
       IndexedSeqLike → SeqLike → IterableLike → TraversableLike

168. #### def toIndexedSeq [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] : IndexedSeq[B]

     Definition Classes
       TraversableOnce → GenTraversableOnce

169. #### def toIterable : Iterable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Definition Classes
       IterableLike → TraversableOnce → GenTraversableOnce

170. #### def toIterator : Iterator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Definition Classes
       TraversableLike → GenTraversableOnce

171. #### def toList : List[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Definition Classes
       TraversableOnce → GenTraversableOnce

172. #### def toMap [T, U] (implicit ev: <:<[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), (T, U)]): Map[T, U]

     Definition Classes
       TraversableOnce → GenTraversableOnce

173. #### def toSeq : Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Definition Classes
       SeqLike → GenSeqLike → TraversableOnce → GenTraversableOnce

174. #### def toSet [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] : Set[B]

     Definition Classes
       TraversableOnce → GenTraversableOnce

175. #### def toStream : Stream[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Definition Classes
       IterableLike → TraversableLike → GenTraversableOnce

176. #### 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.

     Definition Classes
       TableFor19 → SeqLike → TraversableLike → Function1 → AnyRef → Any

177. #### def toTraversable : Traversable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Definition Classes
       TraversableLike → TraversableOnce → GenTraversableOnce

178. #### def transpose [B] (implicit asTraversable: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ TraversableOnce[B]): Traversable[Traversable[B]]

     Definition Classes
       Traversable → GenericTraversableTemplate
     Annotations
       @bridge()

179. #### def union [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (that: GenSeq[B])(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

     Definition Classes
       SeqLike → GenSeqLike

180. #### def union [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (that: Seq[B])(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

     Definition Classes
       GenSeqLike
     Annotations
       @bridge()

181. #### def unzip [A1, A2] (implicit asPair: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])

     Definition Classes
       GenericTraversableTemplate

182. #### def unzip3 [A1, A2, A3] (implicit asTriple: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])

     Definition Classes
       GenericTraversableTemplate

183. #### def updated [B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (index: Int, elem: B)(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], B, That]): That

     Definition Classes
       SeqLike → GenSeqLike

184. #### def view (from: Int, until: Int): SeqView[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

     Definition Classes
       SeqLike → IterableLike → TraversableLike

185. #### def view : SeqView[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

     Definition Classes
       SeqLike → IterableLike → TraversableLike

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

     Attributes
       final
     Definition Classes
       AnyRef
     Annotations
       @throws()

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

     Attributes
       final
     Definition Classes
       AnyRef
     Annotations
       @throws()

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

     Attributes
       final
     Definition Classes
       AnyRef
     Annotations
       @throws()

189. #### def withFilter (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): FilterMonadic[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

     Definition Classes
       TraversableLike → FilterMonadic

190. #### def zip [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), B, That] (that: Iterable[B])(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], (A1, B), That]): That

     Definition Classes
       IterableLike
     Annotations
       @bridge()

191. #### def zip [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), B, That] (that: GenIterable[B])(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], (A1, B), That]): That

     Definition Classes
       IterableLike → GenIterableLike

192. #### def zipAll [B, A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], (A1, B), That]): That

     Definition Classes
       IterableLike
     Annotations
       @bridge()

193. #### def zipAll [B, A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], (A1, B), That]): That

     Definition Classes
       IterableLike → GenIterableLike

194. #### def zipWithIndex [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), That] (implicit bf: CanBuildFrom[TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S], (A1, Int), That]): That

     Definition Classes
       IterableLike → GenIterableLike

195. #### def elements : Iterator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Definition Classes
       IterableLike
     Annotations
       @deprecated
     Deprecated

       use `iterator' instead`

196. #### def equalsWith [B] (that: Seq[B])(f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), B) ⇒ Boolean): Boolean

     Definition Classes
       SeqLike
     Annotations
       @deprecated
     Deprecated

       use `corresponds` instead

197. #### def findIndexOf (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): Int

     Definition Classes
       SeqLike
     Annotations
       @deprecated
     Deprecated

       Use indexWhere(p) instead.

198. #### def findLastIndexOf (p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) ⇒ Boolean): Int

     Definition Classes
       SeqLike
     Annotations
       @deprecated
     Deprecated

       use `lastIndexWhere` instead

199. #### def first : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

     Definition Classes
       IterableLike
     Annotations
       @deprecated
     Deprecated

       use `head' instead`

200. #### def firstOption : Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Definition Classes
       IterableLike
     Annotations
       @deprecated
     Deprecated

       use `headOption' instead`

201. #### def projection : SeqView[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

     Definition Classes
       SeqLike → IterableLike
     Annotations
       @deprecated
     Deprecated

       use `view' instead`

202. #### def reversedElements : Iterator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

     Definition Classes
       SeqLike
     Annotations
       @deprecated
     Deprecated

       use `reverseIterator' instead`

### Inherited from IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

### Inherited from IndexedSeqLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

### Inherited from Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

### Inherited from SeqLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

### Inherited from GenSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

### Inherited from GenSeqLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

### Inherited from Iterable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

### Inherited from IterableLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

### Inherited from Equals

### Inherited from GenIterable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

### Inherited from GenIterableLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

### Inherited from Traversable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

### Inherited from GenTraversable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

### Inherited from GenericTraversableTemplate[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), IndexedSeq]

### Inherited from TraversableLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

### Inherited from GenTraversableLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

### Inherited from Parallelizable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), ParSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]]

### Inherited from TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

### Inherited from GenTraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

### Inherited from FilterMonadic[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

### Inherited from HasNewBuilder[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]]

### Inherited from PartialFunction[Int, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

### Inherited from (Int) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

### Inherited from AnyRef

### Inherited from Any