Frame

Abstract Value Members

abstract def colIndex: Index[Col]

The column keys' index.
abstract def columnsAsSeries: Series[Col, UntypedColumn]

A column-oriented view of this frame.
A column-oriented view of this frame. Largely used internally.
abstract def isColOriented: Boolean

Returns true if this frame can be treated as column oriented.
Returns true if this frame can be treated as column oriented. This is largely for optimization purposes.
abstract def isRowOriented: Boolean

Returns true if this frame can be treated as row oriented.
Returns true if this frame can be treated as row oriented. This is largely for optimization purposes.
abstract def rowIndex: Index[Row]

The row keys' index.
abstract def rowsAsSeries: Series[Row, UntypedColumn]

A row-oriented view of this frame.
A row-oriented view of this frame. Largely used internally.
abstract def transpose: Frame[Col, Row]

Transposes the rows and columns of this frame.
Transposes the rows and columns of this frame. All rows in this frame becomes the columns of the new frame.
abstract def withColIndex[C1](index: Index[C1]): Frame[Row, C1]

Replaces the column index with index.
abstract def withRowIndex[R1](index: Index[R1]): Frame[R1, Col]

Replaces the row index with index.

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit information
This member is added by an implicit conversion from Frame[Row, Col] to any2stringadd[Frame[Row, Col]] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
def ->[B](y: B): (Frame[Row, Col], B)

Implicit information
This member is added by an implicit conversion from Frame[Row, Col] to ArrowAssoc[Frame[Row, Col]] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def appendCols(that: Frame[Row, Col]): Frame[Row, Col]

Appends the columns in that to the end of the columns in this.
Appends the columns in that to the end of the columns in this. This will force the rows into sorted order.
def appendRows(that: Frame[Row, Col]): Frame[Row, Col]

Appends the rows in that to the end of the rows in this.
Appends the rows in that to the end of the rows in this. This will force the columns into sorted order.
def apply[A](rowKey: Row, colKey: Col)(implicit arg0: ColumnTyper[A]): Cell[A]

Returns the value of the cell at row rowKey and column colKey as the type A.
Returns the value of the cell at row rowKey and column colKey as the type A. If the value doesn't exist, then NA is returned. If the value is not meaningful as an instance of A, then NM is returned.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit def colClassTag: ClassTag[Col]
def colKeys: Set[Col]

Returns the set of all unique column keys.
implicit def colOrder: Order[Col]
def cols: Int

Returns the number of cols in this frame.
def column[T](col: Col)(implicit arg0: ColumnTyper[T]): Series[Row, T]

Returns a single column from this Frame cast to type T.
def dropColumns(cols: Col*): Frame[Row, Col]

Drop the columns cols from the column index.
Drop the columns cols from the column index. This simply removes the columns from the column index and does not modify the actual columns.
def dropRows(rows: Row*): Frame[Row, Col]

Drop the rows rows from the row index.
Drop the rows rows from the row index. This simply removes the rows from the index and does not modify the actual columns.
def ensuring(cond: (Frame[Row, Col]) ⇒ Boolean, msg: ⇒ Any): Frame[Row, Col]

Implicit information
This member is added by an implicit conversion from Frame[Row, Col] to Ensuring[Frame[Row, Col]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (Frame[Row, Col]) ⇒ Boolean): Frame[Row, Col]

Implicit information
This member is added by an implicit conversion from Frame[Row, Col] to Ensuring[Frame[Row, Col]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): Frame[Row, Col]

Implicit information
This member is added by an implicit conversion from Frame[Row, Col] to Ensuring[Frame[Row, Col]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): Frame[Row, Col]

Implicit information
This member is added by an implicit conversion from Frame[Row, Col] to Ensuring[Frame[Row, Col]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
Frame → AnyRef → Any
def filter[A](rows: Rows[Row, A])(p: (A) ⇒ Boolean): Frame[Row, Col]

Filter this frame using rows extract values and the predicate p.
Filter this frame using rows extract values and the predicate p. If, for a given column, p is false, then that column will be removed from the frame. Any NA and NM columns will also be removed.
def filter[A](cols: Cols[Col, A])(p: (A) ⇒ Boolean): Frame[Row, Col]

Filter this frame using cols extract values and the predicate p.
Filter this frame using cols extract values and the predicate p. If, for a given row, p is false, then that row will be removed from the frame. Any NA and NM rows will also be removed.
def filterColKeys(p: (Col) ⇒ Boolean): Frame[Row, Col]

Removes rows whose row key is true for the predicate p.
def filterRowKeys(p: (Row) ⇒ Boolean): Frame[Row, Col]

Removes rows whose row key is true for the predicate p.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def formatted(fmtstr: String): String

Implicit information
This member is added by an implicit conversion from Frame[Row, Col] to StringFormat[Frame[Row, Col]] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
def get[A](cols: Cols[Col, A]): Series[Row, A]

Extract values from the rows of the series using cols and returns them in a Series.
def get[A](rows: Rows[Row, A]): Series[Col, A]

Extract values from the columns of the series using rows and returns them in a Series.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getCol(key: Col): Option[Rec[Row]]
def getColumnGroup(col: Col): Frame[Row, Col]
def getRow(key: Row): Option[Rec[Col]]
def getRowGroup(row: Row): Frame[Row, Col]
def group[A](rows: Rows[Row, A])(implicit arg0: Order[A], arg1: ClassTag[A]): Frame[Row, A]

This "groups" the frame cols using the Rows extractor to determine the group for each column.
This "groups" the frame cols using the Rows extractor to determine the group for each column. Each column is then re-keyed using its group.
This is equivalent to, but more efficient than, frame.sortBy(rows).reindex(rows).
def group[A](cols: Cols[Col, A])(implicit arg0: Order[A], arg1: ClassTag[A]): Frame[A, Col]

This "groups" the frame rows using the Cols extractor to determine the group for each row.
This "groups" the frame rows using the Cols extractor to determine the group for each row. Each row is then re-keyed using its group.
This is equivalent to, but more efficient than, frame.sortBy(cols).reindex(cols).
def hashCode(): Int

Definition Classes
Frame → AnyRef → Any
def isEmpty: Boolean

Returns true if this frame is logically empty.
Returns true if this frame is logically empty. A frame is logically empty if none of its rows or columns contain a value, though they may contain NAs or NMs.
TODO: I think an NM should also count as a "value".
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def join[L <: HList](them: L)(join: Join)(implicit folder: SeriesJoinFolder[L, Row, Col]): Frame[Row, Col]
def join[T](col: Col, that: Series[Row, T])(joinStrategy: Join)(implicit arg0: ClassTag[T]): Frame[Row, Col]
def join(that: Frame[Row, Col])(joinStrategy: Join): Frame[Row, Col]
def map[A, B](cols: Cols[Col, A], to: Col)(f: (A) ⇒ B)(implicit arg0: ClassTag[B]): Frame[Row, Col]

Extracts a column from this frame using Cols, then merges it back into this frame as the column to.
Extracts a column from this frame using Cols, then merges it back into this frame as the column to. If to doesn't exist then a new column will be appended onto the frame, otherwise the columns(s) with key to will be removed first.
This is equivalent to, but may be more efficient than frame.merge(to, frame.get(cols))(Merge.Outer).
def map[A, B](rows: Rows[Row, A], to: Row)(f: (A) ⇒ B)(implicit arg0: ClassTag[B]): Frame[Row, Col]

Extracts a row from this frame using Rows, then merges it back into this frame as the row to.
Extracts a row from this frame using Rows, then merges it back into this frame as the row to. If to doesn't exist then a new row will be appended onto the frame, otherwise the row(s) with key to will be removed first.
def mapColKeys[C](f: (Col) ⇒ C)(implicit arg0: Order[C], arg1: ClassTag[C]): Frame[Row, C]

Map the column index using f.
Map the column index using f. This retains the traversal order of the columns.
def mapRowGroups[R1, C1](f: (Row, Frame[Row, Col]) ⇒ Frame[R1, C1])(implicit arg0: ClassTag[R1], arg1: Order[R1], arg2: ClassTag[C1], arg3: Order[C1]): Frame[R1, C1]
def mapRowKeys[R](f: (Row) ⇒ R)(implicit arg0: Order[R], arg1: ClassTag[R]): Frame[R, Col]

Map the row index using f.
Map the row index using f. This retains the traversal order of the rows.
def mapWithIndex[A, B](cols: Cols[Col, A], to: Col)(f: (Row, A) ⇒ B)(implicit arg0: ClassTag[B]): Frame[Row, Col]

Maps each column to a value using cols, then maps the result with the row key using f and stores it in the column to.
Maps each column to a value using cols, then maps the result with the row key using f and stores it in the column to. If to doesn't exist then a new column will be appended onto the frame, otherwise the columns(s) with key to will be removed first.
def mapWithIndex[A, B](rows: Rows[Row, A], to: Row)(f: (Col, A) ⇒ B)(implicit arg0: ClassTag[B]): Frame[Row, Col]

Maps each row to a value using rows, then maps the result with the column key using f and stores it in the row to.
Maps each row to a value using rows, then maps the result with the column key using f and stores it in the row to. If to doesn't exist then a new row will be appended onto the frame, otherwise the row(s) with key to will be removed first.
def merge[L <: HList](them: L)(merge: Merge)(implicit folder: SeriesMergeFolder[L, Row, Col]): Frame[Row, Col]
def merge[T](col: Col, that: Series[Row, T])(mergeStrategy: Merge)(implicit arg0: ClassTag[T]): Frame[Row, Col]
def merge(that: Frame[Row, Col])(mergeStrategy: Merge): Frame[Row, Col]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def reduce[A, B](rows: Rows[Row, A], to: Row)(reducer: Reducer[A, B])(implicit arg0: ClassTag[B]): Frame[Row, Col]

Reduces this frame using rows and joins the result back into the frame.
Reduces this frame using rows and joins the result back into the frame. This doesn't remove any columns from the frame; the reduced result is duplicated for each column. This will replace the to row if it exists, otherwise it creates a new row to at the end.
```
scala&gt; val f = Frame.fromColumns("a" :: 2 :: HNil, "b" :: 3 :: HNil)
scala&gt; f.reduce(Cols(1).as[Int], 1)(reduce.Sum)
res0: framian.Frame[Int,Int] =
    0 . 1
0 : a | b
1 : 5 | 5
```
def reduce[A, B](cols: Cols[Col, A], to: Col)(reducer: Reducer[A, B])(implicit arg0: ClassTag[B]): Frame[Row, Col]

Reduces this frame using cols and joins the result back into the frame.
Reduces this frame using cols and joins the result back into the frame. This doesn't remove any rows from the frame; the reduced result is duplicated for each row. This will replace the to column if it exists, otherwise it creates a new column to at the end.
```
scala&gt; val f = Frame.fromRows("a" :: 2 :: HNil, "b" :: 3 :: HNil)
scala&gt; f.reduce(Cols(1).as[Int], 1)(reduce.Sum)
res0: Frame[Int, Int] =
    0 . 1
0 : a | 5
1 : b | 5
```
def reduceByKey[A, B](rows: Rows[Row, A], to: Row)(reducer: Reducer[A, B])(implicit arg0: ClassTag[B]): Frame[Row, Col]

Reduces this frame, by column key groups, using rows and joins the result back into the frame.
Reduces this frame, by column key groups, using rows and joins the result back into the frame. Within each column key group, the reduced result is duplicated for each column. If to exists it will be replaced, otherwise it will be added to the end of the rows.
def reduceByKey[A, B](cols: Cols[Col, A], to: Col)(reducer: Reducer[A, B])(implicit arg0: ClassTag[B]): Frame[Row, Col]

Reduces this frame, by row key groups, using cols and joins the result back into the frame.
Reduces this frame, by row key groups, using cols and joins the result back into the frame. Within each row key group, the reduced result is duplicated for each row. If to exists it will be replaced, otherwise it will be added to the end of the columns.
def reduceFrame[V, R](reducer: Reducer[V, R])(implicit arg0: ColumnTyper[V], arg1: ClassTag[R], arg2: ColumnTyper[R]): Series[Col, R]

The following methods allow a user to apply reducers directly across a frame.
The following methods allow a user to apply reducers directly across a frame. In particular, this API demands that we specify the type that the reducer accepts and it will only apply it in the case that there exists a type conversion for a given column.
def reduceFrameByKey[V, R](reducer: Reducer[V, R])(implicit arg0: ColumnTyper[V], arg1: ClassTag[R], arg2: ColumnTyper[R]): Frame[Row, Col]
def reduceFrameWithCol[A, B, C](col: Col)(reducer: Reducer[(A, B), C])(implicit arg0: ColumnTyper[A], arg1: ColumnTyper[B], arg2: ClassTag[C]): Series[Col, C]
def reindex[A](rows: Rows[Row, A])(implicit arg0: Order[A], arg1: ClassTag[A]): Frame[Row, A]

Re-indexes the frame using the extractor rows to define the new row keys.
Re-indexes the frame using the extractor rows to define the new row keys. This will not re-order the frame cols, just replace the keys. This will drop any columns where rows extracts a NonValue.
To retain NAs or NMs in the index, you'll need to recover your Rows with some other value. For example,
```
frame.reindex(rows.map(Value(_)).recover { case nonValue => nonValue })
```
def reindex[A](cols: Cols[Col, A])(implicit arg0: Order[A], arg1: ClassTag[A]): Frame[A, Col]

Re-indexes the frame using the extractor cols to define the new row keys.
Re-indexes the frame using the extractor cols to define the new row keys. This will not re-order the frame rows, just replace the keys. This will drop any rows where cols extracts a NonValue.
To retain NAs or NMs in the index, you'll need to recover your Cols with some other value. For example,
```
frame.reindex(cols.map(Value(_)).recover { case nonValue => nonValue })
```
def retainColumns(cols: Col*): Frame[Row, Col]

Retain only the cols in cols, dropping all others.
def retainRows(rows: Row*): Frame[Row, Col]

Retain only the rows in rows, dropping all others.
def reverseColumns: Frame[Row, Col]

Reverse the traversal order of the columns in this frame.
def reverseRows: Frame[Row, Col]

Reverse the traversal order of the rows in this frame.
def row[T](row: Row)(implicit arg0: ColumnTyper[T]): Series[Col, T]

Returns a single row from this Frame cast to type T.
implicit def rowClassTag: ClassTag[Row]
def rowKeys: Set[Row]

Returns the set of all unique row keys.
implicit def rowOrder: Order[Row]
def rows: Int

Returns the number of rows in this frame.
def sortBy[A](cols: Cols[Col, A])(implicit arg0: Order[A]): Frame[Row, Col]

Sorts the frame using the order for the Cols provided.
Sorts the frame using the order for the Cols provided. This will only ever permute the rows of the frame and will not remove/add anything.
cols
The row value extractor to get the sort key
def sortBy[A](rows: Rows[Row, A])(implicit arg0: Order[A]): Frame[Row, Col]

Sorts the frame using the order for the Rows provided.
Sorts the frame using the order for the Rows provided. This will only ever permute the cols of the frame and will not remove/add anything.
rows
The column value extractor to get the sort key
def sortColumns: Frame[Row, Col]

Put the columns in sorted order.
Put the columns in sorted order. This affects only the traversal order of the columns.
def sortRows: Frame[Row, Col]

Put the rows in sorted order.
Put the rows in sorted order. This affects only the traversal order of the rows.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
Frame → AnyRef → Any
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )
def →[B](y: B): (Frame[Row, Col], B)

Implicit information
This member is added by an implicit conversion from Frame[Row, Col] to ArrowAssoc[Frame[Row, Col]] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd from Frame[Row, Col] to any2stringadd[Frame[Row, Col]]

Inherited by implicit conversion StringFormat from Frame[Row, Col] to StringFormat[Frame[Row, Col]]

Inherited by implicit conversion Ensuring from Frame[Row, Col] to Ensuring[Frame[Row, Col]]

Inherited by implicit conversion ArrowAssoc from Frame[Row, Col] to ArrowAssoc[Frame[Row, Col]]

Ungrouped

Related Docs: object Frame | package framian

trait Frame[Row, Col] extends AnyRef

Abstract Value Members

abstract def colIndex: Index[Col]

abstract def columnsAsSeries: Series[Col, UntypedColumn]

abstract def isColOriented: Boolean

abstract def isRowOriented: Boolean

abstract def rowIndex: Index[Row]

abstract def rowsAsSeries: Series[Row, UntypedColumn]

abstract def transpose: Frame[Col, Row]

abstract def withColIndex[C1](index: Index[C1]): Frame[Row, C1]

abstract def withRowIndex[R1](index: Index[R1]): Frame[R1, Col]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Frame[Row, Col], B)

final def ==(arg0: Any): Boolean

def appendCols(that: Frame[Row, Col]): Frame[Row, Col]

def appendRows(that: Frame[Row, Col]): Frame[Row, Col]

def apply[A](rowKey: Row, colKey: Col)(implicit arg0: ColumnTyper[A]): Cell[A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

implicit def colClassTag: ClassTag[Col]

def colKeys: Set[Col]

implicit def colOrder: Order[Col]

def cols: Int

def column[T](col: Col)(implicit arg0: ColumnTyper[T]): Series[Row, T]

def dropColumns(cols: Col*): Frame[Row, Col]

def dropRows(rows: Row*): Frame[Row, Col]

def ensuring(cond: (Frame[Row, Col]) ⇒ Boolean, msg: ⇒ Any): Frame[Row, Col]

def ensuring(cond: (Frame[Row, Col]) ⇒ Boolean): Frame[Row, Col]

def ensuring(cond: Boolean, msg: ⇒ Any): Frame[Row, Col]

def ensuring(cond: Boolean): Frame[Row, Col]

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def filter[A](rows: Rows[Row, A])(p: (A) ⇒ Boolean): Frame[Row, Col]

def filter[A](cols: Cols[Col, A])(p: (A) ⇒ Boolean): Frame[Row, Col]

def filterColKeys(p: (Col) ⇒ Boolean): Frame[Row, Col]

def filterRowKeys(p: (Row) ⇒ Boolean): Frame[Row, Col]

def finalize(): Unit

def formatted(fmtstr: String): String

def get[A](cols: Cols[Col, A]): Series[Row, A]

def get[A](rows: Rows[Row, A]): Series[Col, A]

final def getClass(): Class[_]

def getCol(key: Col): Option[Rec[Row]]

def getColumnGroup(col: Col): Frame[Row, Col]

def getRow(key: Row): Option[Rec[Col]]

def getRowGroup(row: Row): Frame[Row, Col]

def group[A](rows: Rows[Row, A])(implicit arg0: Order[A], arg1: ClassTag[A]): Frame[Row, A]

def group[A](cols: Cols[Col, A])(implicit arg0: Order[A], arg1: ClassTag[A]): Frame[A, Col]

def hashCode(): Int

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def join[L <: HList](them: L)(join: Join)(implicit folder: SeriesJoinFolder[L, Row, Col]): Frame[Row, Col]

def join[T](col: Col, that: Series[Row, T])(joinStrategy: Join)(implicit arg0: ClassTag[T]): Frame[Row, Col]

def join(that: Frame[Row, Col])(joinStrategy: Join): Frame[Row, Col]

def map[A, B](cols: Cols[Col, A], to: Col)(f: (A) ⇒ B)(implicit arg0: ClassTag[B]): Frame[Row, Col]

def map[A, B](rows: Rows[Row, A], to: Row)(f: (A) ⇒ B)(implicit arg0: ClassTag[B]): Frame[Row, Col]

def mapColKeys[C](f: (Col) ⇒ C)(implicit arg0: Order[C], arg1: ClassTag[C]): Frame[Row, C]

def mapRowGroups[R1, C1](f: (Row, Frame[Row, Col]) ⇒ Frame[R1, C1])(implicit arg0: ClassTag[R1], arg1: Order[R1], arg2: ClassTag[C1], arg3: Order[C1]): Frame[R1, C1]

def mapRowKeys[R](f: (Row) ⇒ R)(implicit arg0: Order[R], arg1: ClassTag[R]): Frame[R, Col]

def mapWithIndex[A, B](cols: Cols[Col, A], to: Col)(f: (Row, A) ⇒ B)(implicit arg0: ClassTag[B]): Frame[Row, Col]

def mapWithIndex[A, B](rows: Rows[Row, A], to: Row)(f: (Col, A) ⇒ B)(implicit arg0: ClassTag[B]): Frame[Row, Col]

def merge[L <: HList](them: L)(merge: Merge)(implicit folder: SeriesMergeFolder[L, Row, Col]): Frame[Row, Col]

def merge[T](col: Col, that: Series[Row, T])(mergeStrategy: Merge)(implicit arg0: ClassTag[T]): Frame[Row, Col]

def merge(that: Frame[Row, Col])(mergeStrategy: Merge): Frame[Row, Col]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def reduce[A, B](rows: Rows[Row, A], to: Row)(reducer: Reducer[A, B])(implicit arg0: ClassTag[B]): Frame[Row, Col]

def reduce[A, B](cols: Cols[Col, A], to: Col)(reducer: Reducer[A, B])(implicit arg0: ClassTag[B]): Frame[Row, Col]

def reduceByKey[A, B](rows: Rows[Row, A], to: Row)(reducer: Reducer[A, B])(implicit arg0: ClassTag[B]): Frame[Row, Col]

def reduceByKey[A, B](cols: Cols[Col, A], to: Col)(reducer: Reducer[A, B])(implicit arg0: ClassTag[B]): Frame[Row, Col]

def reduceFrame[V, R](reducer: Reducer[V, R])(implicit arg0: ColumnTyper[V], arg1: ClassTag[R], arg2: ColumnTyper[R]): Series[Col, R]

def reduceFrameByKey[V, R](reducer: Reducer[V, R])(implicit arg0: ColumnTyper[V], arg1: ClassTag[R], arg2: ColumnTyper[R]): Frame[Row, Col]

def reduceFrameWithCol[A, B, C](col: Col)(reducer: Reducer[(A, B), C])(implicit arg0: ColumnTyper[A], arg1: ColumnTyper[B], arg2: ClassTag[C]): Series[Col, C]

def reindex[A](rows: Rows[Row, A])(implicit arg0: Order[A], arg1: ClassTag[A]): Frame[Row, A]

def reindex[A](cols: Cols[Col, A])(implicit arg0: Order[A], arg1: ClassTag[A]): Frame[A, Col]