SingleColumn<*> in ColumnSelectionDsl. reworked ColumnSelectionDsl tests

Author: Jolanrensen

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",
     ),