SingleColumn<*> in ColumnSelectionDsl. reworked ColumnSelectionDsl tests

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt

@@ -285,7 +285,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  * @throws [NoSuchElementException] if no column adheres to the given [condition].
  * @see [last]
  */
- public fun SingleColumn<AnyRow>.first(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+ public fun SingleColumn<*>.first(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
  all().first(condition)
 
  /**
@@ -388,7 +388,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  * @throws [NoSuchElementException] if no column adheres to the given [condition].
  * @see [first]
  */
- public fun SingleColumn<AnyRow>.last(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+ public fun SingleColumn<*>.last(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
  all().last(condition)
 
  /**
@@ -491,7 +491,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  * @throws [NoSuchElementException] if no column adheres to the given [condition].
  * @throws [IllegalArgumentException] if more than one column adheres to the given [condition].
  */
- public fun SingleColumn<AnyRow>.single(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
+ public fun SingleColumn<*>.single(condition: ColumnFilter<*> = { true }): SingleColumn<*> =
  all().single(condition)
 
  /**
@@ -1053,7 +1053,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  */
  public fun <C> ColumnGroupReference.col(property: KProperty<C>): ColumnAccessor<C> = column(property)
 
- public fun SingleColumn<AnyRow>.col(index: Int): SingleColumn<Any?> = getChildrenAt(index).singleImpl()
+ public fun SingleColumn<*>.col(index: Int): SingleColumn<Any?> = getChildrenAt(index).singleImpl()
 
  public operator fun <C> ColumnSet<C>.get(index: Int): SingleColumn<C> = getAt(index)
 
@@ -1946,7 +1946,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
  * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
  */
- public fun SingleColumn<AnyRow>.cols(
+ public fun SingleColumn<*>.cols(
  predicate: ColumnFilter<*> = { true },
  ): ColumnSet<*> = colsInternal(predicate)
 
@@ -1992,7 +1992,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  * @param [predicate] A [ColumnFilter function][org.jetbrains.kotlinx.dataframe.ColumnFilter] that takes a [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference] and returns a [Boolean].
  * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that match the given [predicate].
  */
- public operator fun SingleColumn<AnyRow>.get(
+ public operator fun SingleColumn<*>.get(
  predicate: ColumnFilter<*> = { true },
  ): ColumnSet<Any?> = cols(predicate)
 
@@ -2479,7 +2479,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to columns.
  * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
  */
- public fun <C> SingleColumn<AnyRow>.cols(
+ public fun <C> SingleColumn<*>.cols(
  firstCol: ColumnReference<C>,
  vararg otherCols: ColumnReference<C>,
  ): ColumnSet<C> = headPlusArray(firstCol, otherCols).let { refs ->
@@ -2524,7 +2524,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  * @param [otherCols] Optional additional [ColumnReference][org.jetbrains.kotlinx.dataframe.columns.ColumnReference]s that point to columns.
  * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
  */
- public operator fun <C> SingleColumn<AnyRow>.get(
+ public operator fun <C> SingleColumn<*>.get(
  firstCol: ColumnReference<C>,
  vararg otherCols: ColumnReference<C>,
  ): ColumnSet<C> = cols(firstCol, *otherCols)
@@ -2989,7 +2989,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  * @param [otherCols] Optional additional [String]s that point to columns.
  * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
  */
- public fun SingleColumn<AnyRow>.cols(
+ public fun SingleColumn<*>.cols(
  firstCol: String,
  vararg otherCols: String,
  ): ColumnSet<*> = headPlusArray(firstCol, otherCols).let { names ->
@@ -3030,7 +3030,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  * @param [otherCols] Optional additional [String]s that point to columns.
  * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
  */
- public operator fun SingleColumn<AnyRow>.get(
+ public operator fun SingleColumn<*>.get(
  firstCol: String,
  vararg otherCols: String,
  ): ColumnSet<*> = cols(firstCol, *otherCols)
@@ -3471,7 +3471,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  * @param [otherCols] Optional additional [KProperty]s that point to columns.
  * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
  */
- public fun <C> SingleColumn<AnyRow>.cols(
+ public fun <C> SingleColumn<*>.cols(
  firstCol: KProperty<C>,
  vararg otherCols: KProperty<C>,
  ): ColumnSet<C> = headPlusArray(firstCol, otherCols).let { props ->
@@ -3508,7 +3508,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  * @param [otherCols] Optional additional [KProperty]s that point to columns.
  * @return A [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet] containing the columns that [firstCol] and [otherCols] point to. 
  */
- public operator fun <C> SingleColumn<AnyRow>.get(
+ public operator fun <C> SingleColumn<*>.get(
  firstCol: KProperty<C>,
  vararg otherCols: KProperty<C>,
  ): ColumnSet<C> = cols(firstCol, *otherCols)
@@ -3806,7 +3806,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  vararg otherIndices: Int,
  ): ColumnSet<C> = cols(firstIndex, *otherIndices)
 
- public fun SingleColumn<AnyRow>.cols(
+ public fun SingleColumn<*>.cols(
  firstIndex: Int,
  vararg otherIndices: Int,
  ): ColumnSet<*> = headPlusArray(firstIndex, otherIndices).let { indices ->
@@ -3816,7 +3816,7 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  /**
  *
  */
- public operator fun SingleColumn<AnyRow>.get(
+ public operator fun SingleColumn<*>.get(
  firstIndex: Int,
  vararg otherIndices: Int,
  ): ColumnSet<*> = cols(firstIndex, *otherIndices)
@@ -3866,13 +3866,13 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
  public operator fun <C> ColumnSet<C>.get(range: IntRange): ColumnSet<C> = cols(range)
 
- public fun SingleColumn<AnyRow>.cols(range: IntRange): ColumnSet<*> =
+ public fun SingleColumn<*>.cols(range: IntRange): ColumnSet<*> =
  transform { it.flatMap { it.children().subList(range.first, range.last + 1) } }
 
  /**
  *
  */
- public operator fun SingleColumn<AnyRow>.get(range: IntRange): ColumnSet<*> = cols(range)
+ public operator fun SingleColumn<*>.get(range: IntRange): ColumnSet<*> = cols(range)
 
  public fun String.cols(range: IntRange): ColumnSet<*> = colGroup(this).cols(range)
 
@@ -3914,21 +3914,21 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
  @Deprecated(
  message = "dfs is deprecated, use recursively instead.",
- replaceWith = ReplaceWith("this.cols(predicate).recursively()"),
+ replaceWith = ReplaceWith("this.cols(predicate).recursively(includeTopLevel = false)"),
  level = DeprecationLevel.WARNING,
  )
  public fun <C> ColumnSet<C>.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<Any?> = dfsInternal(predicate)
 
  @Deprecated(
  message = "dfs is deprecated, use recursively instead.",
- replaceWith = ReplaceWith("this.cols(predicate).recursively()"),
+ replaceWith = ReplaceWith("this.cols(predicate).recursively(includeTopLevel = false)"),
  level = DeprecationLevel.WARNING,
  )
  public fun String.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = toColumnAccessor().dfs(predicate)
 
  @Deprecated(
  message = "dfs is deprecated, use recursively instead.",
- replaceWith = ReplaceWith("this.cols(predicate).recursively()"),
+ replaceWith = ReplaceWith("this.cols(predicate).recursively(includeTopLevel = false)"),
  level = DeprecationLevel.WARNING,
  )
  public fun <C> KProperty<C>.dfs(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> =
@@ -3949,32 +3949,51 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
  @Deprecated(
  message = "allDfs is deprecated, use recursively instead.",
- replaceWith = ReplaceWith("this.all().recursively(includeGroups)"),
+ replaceWith = ReplaceWith("this.all().recursively(includeGroups = includeGroups, includeTopLevel = false)"),
  level = DeprecationLevel.WARNING,
  )
  public fun ColumnSet<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> =
  if (includeGroups) dfs { true } else dfs { !it.isColumnGroup() }
 
  @Deprecated(
  message = "allDfs is deprecated, use recursively instead.",
- replaceWith = ReplaceWith("this.all().recursively(includeGroups)"),
+ replaceWith = ReplaceWith("this.all().recursively(includeGroups = includeGroups, includeTopLevel = false)"),
  level = DeprecationLevel.WARNING,
  )
  public fun String.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> = toColumnAccessor().allDfs(includeGroups)
 
  @Deprecated(
  message = "allDfs is deprecated, use recursively instead.",
- replaceWith = ReplaceWith("this.all().recursively(includeGroups)"),
+ replaceWith = ReplaceWith("this.all().recursively(includeGroups = includeGroups, includeTopLevel = false)"),
  level = DeprecationLevel.WARNING,
  )
  public fun KProperty<*>.allDfs(includeGroups: Boolean = false): ColumnSet<Any?> =
  toColumnAccessor().allDfs(includeGroups)
 
- public fun <C> ColumnSet<C>.recursively(includeGroups: Boolean = true): ColumnSet<C> = object : ColumnSet<C> {
+ /**
+ * Modifies the previous call to run not only on the current column set, but also on all of its children.
+ *
+ * For example:
+ *
+ * `df.`[select][DataFrame.select]` { `[colsOf][ColumnSet.colsOf]`<`[String][String]`>() }`
+ *
+ * returns all columns of type [String] in the top-level, as expected. However, what if you want ALL
+ * columns of type [String] even if they are inside a nested column group? Then you can use [recursively]:
+ *
+ * `df.`[select][DataFrame.select]` { `[colsOf][ColumnSet.colsOf]`<`[String][String]`>().`[recursively][ColumnSet.recursively]`() }`
+ *
+ * This will return all columns of type [String] in lower levels (unless [includeTopLevel]` == true`).
+ *
+ * TODO
+ */
+ public fun <C> ColumnSet<C>.recursively(
+ includeGroups: Boolean = true,
+ includeTopLevel: Boolean = true,
+ ): ColumnSet<C> = object : ColumnSet<C> {
 
  private fun flatten(columnSet: ColumnSet<*>): ColumnSet<*> = columnSet.transform { list ->
  list
- .filter { it.isColumnGroup() } // TODO should I include this from dfs?
+ .filter { includeTopLevel || it.isColumnGroup() } // TODO should I include this from dfs?
  .flatMap {
  it.children()
  .dfs()
@@ -3984,8 +4003,9 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
  override fun resolve(
  context: ColumnResolutionContext,
- ): List<ColumnWithPath<C>> = this@recursively
- .resolveAfterTransform(context = context, transform = ::flatten)
+ ): List<ColumnWithPath<C>> =
+ this@recursively
+ .resolveAfterTransform(context = context, transform = ::flatten)
 
  override fun resolveAfterTransform(
  context: ColumnResolutionContext,
@@ -3995,13 +4015,22 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  .resolveAfterTransform(context = context, transform = ::flatten)
  }
 
- public fun <C> ColumnSet<C>.rec(includeGroups: Boolean = true): ColumnSet<C> = recursively(includeGroups)
+ public fun <C> ColumnSet<C>.rec(
+ includeGroups: Boolean = true,
+ includeTopLevel: Boolean = true,
+ ): ColumnSet<C> = recursively(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
 
- public fun <C> ColumnSet<C>.allRecursively(includeGroups: Boolean = true): ColumnSet<C> =
- wrap().recursively(includeGroups = includeGroups)
+ public fun <C> ColumnSet<C>.allRecursively(
+ includeGroups: Boolean = true,
+ includeTopLevel: Boolean = true,
+ ): ColumnSet<C> =
+ wrap().recursively(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
 
- public fun <C> ColumnSet<C>.allRec(includeGroups: Boolean = true): ColumnSet<C> =
- allRecursively(includeGroups = includeGroups)
+ public fun <C> ColumnSet<C>.allRec(
+ includeGroups: Boolean = true,
+ includeTopLevel: Boolean = true,
+ ): ColumnSet<C> =
+ allRecursively(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
 
 
  // endregion
@@ -4161,10 +4190,10 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  public operator fun <C> List<DataColumn<C>>.get(range: IntRange): ColumnSet<C> =
  ColumnsList(subList(range.first, range.last + 1))
 
- public fun SingleColumn<AnyRow>.take(n: Int): ColumnSet<*> = transformSingle { it.children().take(n) }
- public fun SingleColumn<AnyRow>.takeLast(n: Int): ColumnSet<*> = transformSingle { it.children().takeLast(n) }
- public fun SingleColumn<AnyRow>.drop(n: Int): ColumnSet<*> = transformSingle { it.children().drop(n) }
- public fun SingleColumn<AnyRow>.dropLast(n: Int = 1): ColumnSet<*> = transformSingle { it.children().dropLast(n) }
+ public fun SingleColumn<*>.take(n: Int): ColumnSet<*> = transformSingle { it.children().take(n) }
+ public fun SingleColumn<*>.takeLast(n: Int): ColumnSet<*> = transformSingle { it.children().takeLast(n) }
+ public fun SingleColumn<*>.drop(n: Int): ColumnSet<*> = transformSingle { it.children().drop(n) }
+ public fun SingleColumn<*>.dropLast(n: Int = 1): ColumnSet<*> = transformSingle { it.children().dropLast(n) }
 
  public fun <C> ColumnSet<C>.drop(n: Int): ColumnSet<C> = transform { it.drop(n) }
  public fun <C> ColumnSet<C>.take(n: Int): ColumnSet<C> = transform { it.take(n) }
@@ -4180,13 +4209,13 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
  public fun <C> ColumnSet<C>.filter(predicate: Predicate<ColumnWithPath<C>>): ColumnSet<C> =
  transform { it.filter(predicate) }
 
- public fun SingleColumn<AnyRow>.nameContains(text: CharSequence): ColumnSet<*> = cols { it.name.contains(text) }
+ public fun SingleColumn<*>.nameContains(text: CharSequence): ColumnSet<*> = cols { it.name.contains(text) }
  public fun <C> ColumnSet<C>.nameContains(text: CharSequence): ColumnSet<C> = cols { it.name.contains(text) }
- public fun SingleColumn<AnyRow>.nameContains(regex: Regex): ColumnSet<*> = cols { it.name.contains(regex) }
+ public fun SingleColumn<*>.nameContains(regex: Regex): ColumnSet<*> = cols { it.name.contains(regex) }
  public fun <C> ColumnSet<C>.nameContains(regex: Regex): ColumnSet<C> = cols { it.name.contains(regex) }
- public fun SingleColumn<AnyRow>.startsWith(prefix: CharSequence): ColumnSet<*> = cols { it.name.startsWith(prefix) }
+ public fun SingleColumn<*>.startsWith(prefix: CharSequence): ColumnSet<*> = cols { it.name.startsWith(prefix) }
  public fun <C> ColumnSet<C>.startsWith(prefix: CharSequence): ColumnSet<C> = cols { it.name.startsWith(prefix) }
- public fun SingleColumn<AnyRow>.endsWith(suffix: CharSequence): ColumnSet<*> = cols { it.name.endsWith(suffix) }
+ public fun SingleColumn<*>.endsWith(suffix: CharSequence): ColumnSet<*> = cols { it.name.endsWith(suffix) }
  public fun <C> ColumnSet<C>.endsWith(suffix: CharSequence): ColumnSet<C> = cols { it.name.endsWith(suffix) }
 
  public fun <C> ColumnSet<C>.except(vararg other: ColumnSet<*>): ColumnSet<*> = except(other.toColumnSet())
@@ -4277,9 +4306,25 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
 
  public fun <C> ColumnSet<C>.distinct(): ColumnSet<C> = DistinctColumnSet(this)
 
+ @Deprecated(
+ message = "Use recursively() instead",
+ replaceWith = ReplaceWith(
+ "this.colsOf(type, predicate).recursively(includeTopLevel = false)",
+ "org.jetbrains.kotlinx.dataframe.columns.recursively",
+ "org.jetbrains.kotlinx.dataframe.api.colsOf",
+ ),
+ )
  public fun <C> String.dfsOf(type: KType, predicate: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<*> =
  toColumnAccessor().dfsOf(type, predicate)
 
+ @Deprecated(
+ message = "Use recursively() instead",
+ replaceWith = ReplaceWith(
+ "this.colsOf(type, predicate).recursively(includeTopLevel = false)",
+ "org.jetbrains.kotlinx.dataframe.columns.recursively",
+ "org.jetbrains.kotlinx.dataframe.api.colsOf",
+ ),
+ )
  public fun <C> KProperty<*>.dfsOf(type: KType, predicate: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<*> =
  toColumnAccessor().dfsOf(type, predicate)
 
@@ -4398,8 +4443,7 @@ internal fun ColumnSet<*>.dfsInternal(predicate: (ColumnWithPath<*>) -> Boolean)
 @Deprecated(
  message = "Use recursively() instead",
  replaceWith = ReplaceWith(
- "this.colsOf(type, predicate).recursively()",
- "org.jetbrains.kotlinx.dataframe.columns.recursively",
+ "this.colsOf(type, predicate).recursively(includeTopLevel = false)",
  "org.jetbrains.kotlinx.dataframe.columns.recursively",
  "org.jetbrains.kotlinx.dataframe.api.colsOf",
  ),
@@ -4410,7 +4454,7 @@ public fun <C> ColumnSet<*>.dfsOf(type: KType, predicate: (ColumnWithPath<C>) ->
 @Deprecated(
  message = "Use recursively() instead",
  replaceWith = ReplaceWith(
- "this.colsOf<C>(filter).recursively()",
+ "this.colsOf<C>(filter).recursively(includeTopLevel = false)",
  "org.jetbrains.kotlinx.dataframe.columns.recursively",
  "org.jetbrains.kotlinx.dataframe.api.colsOf",
  ),