org.scalatest.prop.TableFor12

A table with 12 columns.

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

This table is a sequence of Tuple12 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 TableFor12 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"),
    (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )

Because you supplied 12 members in each tuple, the type you'll get back will be a TableFor12.

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

forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l) =>
  a + b + c + d + e + f + g + h + i + j + k + l should equal (a * 12)
}

Because TableFor12 is a Seq[(A, B, C, D, E, F, G, H, I, J, K, L)], 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)], IndexedSeqLike[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]], Seq[(A, B, C, D, E, F, G, H, I, J, K, L)], SeqLike[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]], GenSeq[(A, B, C, D, E, F, G, H, I, J, K, L)], GenSeqLike[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]], Iterable[(A, B, C, D, E, F, G, H, I, J, K, L)], IterableLike[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]], Equals, GenIterable[(A, B, C, D, E, F, G, H, I, J, K, L)], GenIterableLike[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]], Traversable[(A, B, C, D, E, F, G, H, I, J, K, L)], GenTraversable[(A, B, C, D, E, F, G, H, I, J, K, L)], GenericTraversableTemplate[(A, B, C, D, E, F, G, H, I, J, K, L), IndexedSeq], TraversableLike[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]], GenTraversableLike[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]], Parallelizable[(A, B, C, D, E, F, G, H, I, J, K, L), ParSeq[(A, B, C, D, E, F, G, H, I, J, K, L)]], TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L)], GenTraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L)], FilterMonadic[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]], HasNewBuilder[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]], PartialFunction[Int, (A, B, C, D, E, F, G, H, I, J, K, L)], (Int) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L), AnyRef, Any

Ordering

Alphabetic
By inheritance

Inherited

Hide All
Show all

TableFor12
IndexedSeq
IndexedSeqLike
Seq
SeqLike
GenSeq
GenSeqLike
Iterable
IterableLike
Equals
GenIterable
GenIterableLike
Traversable
GenTraversable
GenericTraversableTemplate
TraversableLike
GenTraversableLike
Parallelizable
TraversableOnce
GenTraversableOnce
FilterMonadic
HasNewBuilder
PartialFunction
Function1
AnyRef
Any

Visibility

Public
All

Instance Constructors

new TableFor12 (heading: (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)*)

heading
a tuple containing string names of the columns in this table
rows
a variable length parameter list of Tuple12s containing the data of this table

Type Members

type Self = TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Attributes
protected
Definition Classes
TraversableLike

Value Members

def != (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def != (arg0: Any): Boolean

Attributes
final
Definition Classes
Any
def ## (): Int

Attributes
final
Definition Classes
AnyRef → Any
def ++ [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (that: TraversableOnce[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
TraversableLike
Annotations
@bridge()
def ++ [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def ++: [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (that: Traversable[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
TraversableLike
def ++: [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (that: TraversableOnce[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
TraversableLike
def +: [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (elem: B)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
SeqLike → GenSeqLike
def /: [B] (z: B)(op: (B, (A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def /:\ [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L)] (z: A1)(op: (A1, A1) ⇒ A1): A1

Definition Classes
GenTraversableOnce
def :+ [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (elem: B)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
SeqLike → GenSeqLike
def :\ [B] (z: B)(op: ((A, B, C, D, E, F, G, H, I, J, K, L), B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def == (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def == (arg0: Any): Boolean

Attributes
final
Definition Classes
Any
def addString (b: StringBuilder): StringBuilder

Definition Classes
TraversableOnce
def addString (b: StringBuilder, sep: String): StringBuilder

Definition Classes
TraversableOnce
def addString (b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Definition Classes
TraversableOnce
def aggregate [B] (z: B)(seqop: (B, (A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B, combop: (B, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def andThen [C] (k: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ C): PartialFunction[Int, C]

Definition Classes
PartialFunction → Function1
def apply (fun: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ Unit): Unit

Applies the passed property check function to each row of this TableFor12.
Applies the passed property check function to each row of this TableFor12.
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 TableFor12
def apply (idx: Int): (A, B, C, D, E, F, G, H, I, J, K, L)

Selects a row of data by its index.
Selects a row of data by its index.

Definition Classes
TableFor12 → SeqLike → GenSeqLike → Function1
def asInstanceOf [T0] : T0

Attributes
final
Definition Classes
Any
def canEqual (that: Any): Boolean

Definition Classes
IterableLike → Equals
def clone (): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def collect [B, That] (pf: PartialFunction[(A, B, C, D, E, F, G, H, I, J, K, L), B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def collectFirst [B] (pf: PartialFunction[(A, B, C, D, E, F, G, H, I, J, K, L), B]): Option[B]

Definition Classes
TraversableOnce
def combinations (n: Int): Iterator[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Definition Classes
SeqLike
def companion : GenericCompanion[IndexedSeq]

Definition Classes
IndexedSeq → Seq → GenSeq → Iterable → GenIterable → Traversable → GenTraversable → GenericTraversableTemplate
def compose [A] (g: (A) ⇒ Int): (A) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L)

Definition Classes
Function1
def contains (elem: Any): Boolean

Definition Classes
SeqLike
def containsSlice [B] (that: Seq[B]): Boolean

Definition Classes
SeqLike
Annotations
@bridge()
def containsSlice [B] (that: GenSeq[B]): Boolean

Definition Classes
SeqLike
def copyToArray [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (xs: Array[B], start: Int, len: Int): Unit

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def copyToArray [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (xs: Array[B]): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToArray [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (xs: Array[B], start: Int): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToBuffer [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (dest: Buffer[B]): Unit

Definition Classes
TraversableOnce
def corresponds [B] (that: Seq[B])(p: ((A, B, C, D, E, F, G, H, I, J, K, L), B) ⇒ Boolean): Boolean

Definition Classes
SeqLike
Annotations
@bridge()
def corresponds [B] (that: GenSeq[B])(p: ((A, B, C, D, E, F, G, H, I, J, K, L), B) ⇒ Boolean): Boolean

Definition Classes
SeqLike → GenSeqLike
def count (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): Int

Definition Classes
TraversableOnce → GenTraversableOnce
def diff [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: Seq[B]): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
SeqLike
Annotations
@bridge()
def diff [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: GenSeq[B]): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
SeqLike → GenSeqLike
def distinct : TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
SeqLike → GenSeqLike
def drop (n: Int): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def dropRight (n: Int): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
IterableLike
def dropWhile (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
TraversableLike → GenTraversableLike
def endsWith [B] (that: Seq[B]): Boolean

Definition Classes
SeqLike
Annotations
@bridge()
def endsWith [B] (that: GenSeq[B]): Boolean

Definition Classes
SeqLike → GenSeqLike
def eq (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def equals (that: Any): Boolean

Definition Classes
GenSeqLike → Equals → AnyRef → Any
def exists (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): Boolean

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def filter (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
TraversableLike → GenTraversableLike
def filterNot (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
TraversableLike → GenTraversableLike
def finalize (): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def find (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): Option[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def flatMap [B, That] (f: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
def flatten [B] (implicit asTraversable: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ TraversableOnce[B]): Traversable[B]

Definition Classes
Traversable → GenericTraversableTemplate
Annotations
@bridge()
def fold [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L)] (z: A1)(op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def foldLeft [B] (z: B)(op: (B, (A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def foldRight [B] (z: B)(op: ((A, B, C, D, E, F, G, H, I, J, K, L), B) ⇒ B): B

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def forall (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): Boolean

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def foreach [U] (f: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ U): Unit

Definition Classes
IterableLike → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic
def genericBuilder [B] : Builder[B, IndexedSeq[B]]

Definition Classes
GenericTraversableTemplate
def getClass (): java.lang.Class[_]

Attributes
final
Definition Classes
AnyRef
def groupBy [K] (f: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ K): Map[K, TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Definition Classes
TraversableLike → GenTraversableLike
def grouped (size: Int): Iterator[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Definition Classes
IterableLike
def hasDefiniteSize : Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def hashCode (): Int

Definition Classes
GenSeqLike → AnyRef → Any
def head : (A, B, C, D, E, F, G, H, I, J, K, L)

Definition Classes
IterableLike → GenIterableLike → TraversableLike → GenTraversableLike
def headOption : Option[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
TraversableLike
val heading : (String, String, String, String, String, String, String, String, String, String, String, String)

a tuple containing string names of the columns in this table
def indexOf [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (elem: B, from: Int): Int

Definition Classes
GenSeqLike
def indexOf [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (elem: B): Int

Definition Classes
GenSeqLike
def indexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: Seq[B], from: Int): Int

Definition Classes
SeqLike
Annotations
@bridge()
def indexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: GenSeq[B], from: Int): Int

Definition Classes
SeqLike
def indexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: Seq[B]): Int

Definition Classes
SeqLike
Annotations
@bridge()
def indexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: GenSeq[B]): Int

Definition Classes
SeqLike
def indexWhere (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean, from: Int): Int

Definition Classes
SeqLike → GenSeqLike
def indexWhere (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): Int

Definition Classes
GenSeqLike
def indices : Range

Definition Classes
SeqLike
def init : TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
TraversableLike
def inits : Iterator[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Definition Classes
TraversableLike
def intersect [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: Seq[B]): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
SeqLike
Annotations
@bridge()
def intersect [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: GenSeq[B]): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
SeqLike → GenSeqLike
def isDefinedAt (idx: Int): Boolean

Definition Classes
GenSeqLike
def isEmpty : Boolean

Definition Classes
IterableLike → GenIterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def isInstanceOf [T0] : Boolean

Attributes
final
Definition Classes
Any
def isTraversableAgain : Boolean

Attributes
final
Definition Classes
GenTraversableLike → GenTraversableOnce
def iterator : Iterator[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
IndexedSeqLike → IterableLike → GenIterableLike
def last : (A, B, C, D, E, F, G, H, I, J, K, L)

Definition Classes
TraversableLike
def lastIndexOf [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (elem: B, end: Int): Int

Definition Classes
GenSeqLike
def lastIndexOf [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (elem: B): Int

Definition Classes
GenSeqLike
def lastIndexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: Seq[B], end: Int): Int

Definition Classes
SeqLike
Annotations
@bridge()
def lastIndexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: GenSeq[B], end: Int): Int

Definition Classes
SeqLike
def lastIndexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: Seq[B]): Int

Definition Classes
SeqLike
Annotations
@bridge()
def lastIndexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: GenSeq[B]): Int

Definition Classes
SeqLike
def lastIndexWhere (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean, end: Int): Int

Definition Classes
SeqLike → GenSeqLike
def lastIndexWhere (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): Int

Definition Classes
GenSeqLike
def lastOption : Option[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
TraversableLike
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
TableFor12 → SeqLike → GenSeqLike
def lengthCompare (len: Int): Int

Definition Classes
SeqLike
def lift : (Int) ⇒ Option[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
PartialFunction
def map [B, That] (f: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
def max [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (implicit cmp: Ordering[B]): (A, B, C, D, E, F, G, H, I, J, K, L)

Definition Classes
TraversableOnce → GenTraversableOnce
def maxBy [B] (f: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B)(implicit cmp: Ordering[B]): (A, B, C, D, E, F, G, H, I, J, K, L)

Definition Classes
TraversableOnce → GenTraversableOnce
def min [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (implicit cmp: Ordering[B]): (A, B, C, D, E, F, G, H, I, J, K, L)

Definition Classes
TraversableOnce → GenTraversableOnce
def minBy [B] (f: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B)(implicit cmp: Ordering[B]): (A, B, C, D, E, F, G, H, I, J, K, L)

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString : String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString (sep: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString (start: String, sep: String, end: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
def ne (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def newBuilder : Builder[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Creates a new Builder for TableFor12s.
Creates a new Builder for TableFor12s.

Attributes
protected[this]
Definition Classes
TableFor12 → GenericTraversableTemplate → TraversableLike → HasNewBuilder
def nonEmpty : Boolean

Definition Classes
TraversableOnce → GenTraversableOnce
def notify (): Unit

Attributes
final
Definition Classes
AnyRef
def notifyAll (): Unit

Attributes
final
Definition Classes
AnyRef
def orElse [A1 <: Int, B1 >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

Definition Classes
PartialFunction
def padTo [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (len: Int, elem: B)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
SeqLike → GenSeqLike
def par : ParSeq[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
Parallelizable
def parCombiner : Combiner[(A, B, C, D, E, F, G, H, I, J, K, L), ParSeq[(A, B, C, D, E, F, G, H, I, J, K, L)]]

Attributes
protected[this]
Definition Classes
SeqLike → TraversableLike → Parallelizable
def partition (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): (TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])

Definition Classes
TraversableLike → GenTraversableLike
def patch [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (from: Int, patch: Seq[B], replaced: Int)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
SeqLike
Annotations
@bridge()
def patch [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
SeqLike → GenSeqLike
def permutations : Iterator[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Definition Classes
SeqLike
def prefixLength (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): Int

Definition Classes
GenSeqLike
def product [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
def reduce [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L)] (op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceLeft [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (op: (B, (A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B): B

Definition Classes
TraversableOnce
def reduceLeftOption [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (op: (B, (A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceOption [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L)] (op: (A1, A1) ⇒ A1): Option[A1]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRight [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (op: ((A, B, C, D, E, F, G, H, I, J, K, L), B) ⇒ B): B

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def reduceRightOption [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (op: ((A, B, C, D, E, F, G, H, I, J, K, L), B) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def repr : TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
TraversableLike → GenTraversableLike
def reverse : TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
SeqLike → GenSeqLike
def reverseIterator : Iterator[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
SeqLike
def reverseMap [B, That] (f: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
SeqLike → GenSeqLike
def reversed : List[(A, B, C, D, E, F, G, H, I, J, K, L)]

Attributes
protected[this]
Definition Classes
TraversableOnce
def sameElements [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: Iterable[B]): Boolean

Definition Classes
IterableLike
Annotations
@bridge()
def sameElements [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: GenIterable[B]): Boolean

Definition Classes
IterableLike → GenIterableLike
def scan [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanLeft [B, That] (z: B)(op: (B, (A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanRight [B, That] (z: B)(op: ((A, B, C, D, E, F, G, H, I, J, K, L), B) ⇒ B)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
Annotations
@migration
Migration
def segmentLength (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean, from: Int): Int

Definition Classes
SeqLike → GenSeqLike
def seq : Seq[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
Seq → GenSeq → Iterable → GenIterable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce
def size : Int

Definition Classes
SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce
def slice (from: Int, until: Int): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def sliding [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (size: Int, step: Int): Iterator[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Definition Classes
IterableLike
def sliding [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (size: Int): Iterator[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Definition Classes
IterableLike
def sortBy [B] (f: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B)(implicit ord: Ordering[B]): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
SeqLike
def sortWith (lt: ((A, B, C, D, E, F, G, H, I, J, K, L), (A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
SeqLike
def sorted [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (implicit ord: Ordering[B]): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
SeqLike
def span (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): (TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])

Definition Classes
TraversableLike → GenTraversableLike
def splitAt (n: Int): (TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])

Definition Classes
TraversableLike → GenTraversableLike
def startsWith [B] (that: Seq[B], offset: Int): Boolean

Definition Classes
SeqLike
Annotations
@bridge()
def startsWith [B] (that: GenSeq[B], offset: Int): Boolean

Definition Classes
SeqLike → GenSeqLike
def startsWith [B] (that: Seq[B]): Boolean

Definition Classes
GenSeqLike
Annotations
@bridge()
def startsWith [B] (that: GenSeq[B]): Boolean

Definition Classes
GenSeqLike
def stringPrefix : String

Definition Classes
TraversableLike → GenTraversableLike
def sum [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
def synchronized [T0] (arg0: ⇒ T0): T0

Attributes
final
Definition Classes
AnyRef
def tail : TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
TraversableLike → GenTraversableLike
def tails : Iterator[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Definition Classes
TraversableLike
def take (n: Int): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def takeRight (n: Int): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
IterableLike
def takeWhile (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def thisCollection : IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L)]

Attributes
protected[this]
Definition Classes
IndexedSeqLike → SeqLike → IterableLike → TraversableLike
def toArray [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (implicit arg0: ClassManifest[B]): Array[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toBuffer [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L)] : Buffer[A1]

Definition Classes
IndexedSeqLike → TraversableOnce → GenTraversableOnce
def toCollection (repr: TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]): IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L)]

Attributes
protected[this]
Definition Classes
IndexedSeqLike → SeqLike → IterableLike → TraversableLike
def toIndexedSeq [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] : IndexedSeq[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterable : Iterable[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def toIterator : Iterator[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
TraversableLike → GenTraversableOnce
def toList : List[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
TraversableOnce → GenTraversableOnce
def toMap [T, U] (implicit ev: <:<[(A, B, C, D, E, F, G, H, I, J, K, L), (T, U)]): Map[T, U]

Definition Classes
TraversableOnce → GenTraversableOnce
def toSeq : Seq[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
SeqLike → GenSeqLike → TraversableOnce → GenTraversableOnce
def toSet [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] : Set[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toStream : Stream[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
IterableLike → TraversableLike → GenTraversableOnce
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
TableFor12 → SeqLike → TraversableLike → Function1 → AnyRef → Any
def toTraversable : Traversable[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def transpose [B] (implicit asTraversable: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ TraversableOnce[B]): Traversable[Traversable[B]]

Definition Classes
Traversable → GenericTraversableTemplate
Annotations
@bridge()
def union [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (that: GenSeq[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
SeqLike → GenSeqLike
def union [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (that: Seq[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
GenSeqLike
Annotations
@bridge()
def unzip [A1, A2] (implicit asPair: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])

Definition Classes
GenericTraversableTemplate
def unzip3 [A1, A2, A3] (implicit asTriple: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])

Definition Classes
GenericTraversableTemplate
def updated [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (index: Int, elem: B)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

Definition Classes
SeqLike → GenSeqLike
def view (from: Int, until: Int): SeqView[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Definition Classes
SeqLike → IterableLike → TraversableLike
def view : SeqView[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Definition Classes
SeqLike → IterableLike → TraversableLike
def wait (): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()
def wait (arg0: Long, arg1: Int): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()
def wait (arg0: Long): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()
def withFilter (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): FilterMonadic[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Definition Classes
TraversableLike → FilterMonadic
def zip [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L), B, That] (that: Iterable[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], (A1, B), That]): That

Definition Classes
IterableLike
Annotations
@bridge()
def zip [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L), B, That] (that: GenIterable[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], (A1, B), That]): That

Definition Classes
IterableLike → GenIterableLike
def zipAll [B, A1 >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], (A1, B), That]): That

Definition Classes
IterableLike
Annotations
@bridge()
def zipAll [B, A1 >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], (A1, B), That]): That

Definition Classes
IterableLike → GenIterableLike
def zipWithIndex [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], (A1, Int), That]): That

Definition Classes
IterableLike → GenIterableLike
def elements : Iterator[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
IterableLike
Annotations
@deprecated
Deprecated
use iterator' instead
def equalsWith [B] (that: Seq[B])(f: ((A, B, C, D, E, F, G, H, I, J, K, L), B) ⇒ Boolean): Boolean

Definition Classes
SeqLike
Annotations
@deprecated
Deprecated
use corresponds instead
def findIndexOf (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): Int

Definition Classes
SeqLike
Annotations
@deprecated
Deprecated
Use indexWhere(p) instead.
def findLastIndexOf (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): Int

Definition Classes
SeqLike
Annotations
@deprecated
Deprecated
use lastIndexWhere instead
def first : (A, B, C, D, E, F, G, H, I, J, K, L)

Definition Classes
IterableLike
Annotations
@deprecated
Deprecated
use head' instead
def firstOption : Option[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
IterableLike
Annotations
@deprecated
Deprecated
use headOption' instead
def projection : SeqView[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Definition Classes
SeqLike → IterableLike
Annotations
@deprecated
Deprecated
use view' instead
def reversedElements : Iterator[(A, B, C, D, E, F, G, H, I, J, K, L)]

Definition Classes
SeqLike
Annotations
@deprecated
Deprecated
use reverseIterator' instead

TableFor12

class TableFor12 [A, B, C, D, E, F, G, H, I, J, K, L] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L)] with IndexedSeqLike[(A, B, C, D, E, F, G, H, I, J, K, L), TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

Instance Constructors

new TableFor12 (heading: (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)*)

Type Members

type Self = TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

Value Members

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def ++ [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (that: TraversableOnce[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

def ++ [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

def ++: [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (that: Traversable[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

def ++: [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (that: TraversableOnce[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

def +: [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (elem: B)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

def /: [B] (z: B)(op: (B, (A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B): B

def /:\ [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L)] (z: A1)(op: (A1, A1) ⇒ A1): A1

def :+ [B >: (A, B, C, D, E, F, G, H, I, J, K, L), That] (elem: B)(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

def :\ [B] (z: B)(op: ((A, B, C, D, E, F, G, H, I, J, K, L), B) ⇒ B): B

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def addString (b: StringBuilder): StringBuilder

def addString (b: StringBuilder, sep: String): StringBuilder

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

def aggregate [B] (z: B)(seqop: (B, (A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B, combop: (B, B) ⇒ B): B

def andThen [C] (k: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ C): PartialFunction[Int, C]

def apply (fun: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ Unit): Unit

def apply (idx: Int): (A, B, C, D, E, F, G, H, I, J, K, L)

def asInstanceOf [T0] : T0

def canEqual (that: Any): Boolean

def clone (): AnyRef

def collect [B, That] (pf: PartialFunction[(A, B, C, D, E, F, G, H, I, J, K, L), B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

def collectFirst [B] (pf: PartialFunction[(A, B, C, D, E, F, G, H, I, J, K, L), B]): Option[B]

def combinations (n: Int): Iterator[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

def companion : GenericCompanion[IndexedSeq]

def compose [A] (g: (A) ⇒ Int): (A) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L)

def contains (elem: Any): Boolean

def containsSlice [B] (that: Seq[B]): Boolean

def containsSlice [B] (that: GenSeq[B]): Boolean

def copyToArray [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (xs: Array[B], start: Int, len: Int): Unit

def copyToArray [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (xs: Array[B]): Unit

def copyToArray [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (xs: Array[B], start: Int): Unit

def copyToBuffer [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (dest: Buffer[B]): Unit

def corresponds [B] (that: Seq[B])(p: ((A, B, C, D, E, F, G, H, I, J, K, L), B) ⇒ Boolean): Boolean

def corresponds [B] (that: GenSeq[B])(p: ((A, B, C, D, E, F, G, H, I, J, K, L), B) ⇒ Boolean): Boolean

def count (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): Int

def diff [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: Seq[B]): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

def diff [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: GenSeq[B]): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

def distinct : TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

def drop (n: Int): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

def dropRight (n: Int): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

def dropWhile (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

def endsWith [B] (that: Seq[B]): Boolean

def endsWith [B] (that: GenSeq[B]): Boolean

def eq (arg0: AnyRef): Boolean

def equals (that: Any): Boolean

def exists (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): Boolean

def filter (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

def filterNot (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]

def finalize (): Unit

def find (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): Option[(A, B, C, D, E, F, G, H, I, J, K, L)]

def flatMap [B, That] (f: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L], B, That]): That

def flatten [B] (implicit asTraversable: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ TraversableOnce[B]): Traversable[B]

def fold [A1 >: (A, B, C, D, E, F, G, H, I, J, K, L)] (z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft [B] (z: B)(op: (B, (A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ B): B

def foldRight [B] (z: B)(op: ((A, B, C, D, E, F, G, H, I, J, K, L), B) ⇒ B): B

def forall (p: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ Boolean): Boolean

def foreach [U] (f: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ U): Unit

def genericBuilder [B] : Builder[B, IndexedSeq[B]]

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

def groupBy [K] (f: ((A, B, C, D, E, F, G, H, I, J, K, L)) ⇒ K): Map[K, TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

def grouped (size: Int): Iterator[TableFor12[A, B, C, D, E, F, G, H, I, J, K, L]]

def hasDefiniteSize : Boolean

def hashCode (): Int

def head : (A, B, C, D, E, F, G, H, I, J, K, L)

def headOption : Option[(A, B, C, D, E, F, G, H, I, J, K, L)]

val heading : (String, String, String, String, String, String, String, String, String, String, String, String)

def indexOf [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (elem: B, from: Int): Int

def indexOf [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (elem: B): Int

def indexOfSlice [B >: (A, B, C, D, E, F, G, H, I, J, K, L)] (that: Seq[B], from: Int): Int