From aff46512f9bb109e1f56bd6360047eba2db98e0b Mon Sep 17 00:00:00 2001 From: Jolan Rensen Date: Tue, 11 Aug 2026 14:39:41 +0200 Subject: [PATCH 1/6] updated kdoc guideline for code spans --- KDOC_GUIDELINES.md | 45 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 43 insertions(+), 2 deletions(-) diff --git a/KDOC_GUIDELINES.md b/KDOC_GUIDELINES.md index 7eaad7ac9f..f4752bbb9b 100644 --- a/KDOC_GUIDELINES.md +++ b/KDOC_GUIDELINES.md @@ -14,6 +14,7 @@ This document outlines the guidelines for writing KDocs in the Kotlin DataFrame * [URLs](#urls) * [Utils](#utils) * [Kotlin DataFrame Operations KDoc Structure](#kotlin-dataframe-operations-kdoc-structure) + * [Referring to code](#referring-to-code) * [General Template](#general-template) * [First line](#first-line) * [Body](#body) @@ -275,6 +276,46 @@ as arguments and return simple value, `DataFrame`, `DataRow` or `DataColumn`. [special notation](./core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DslGrammar.kt). Add a reference to the operation Grammar in each related class and method KDoc. +### Referring to code + +Whenever a KDoc refers to something that is code — a function, class, property, parameter, type, +keyword, literal, or a snippet of an expression — write it in a code span. + +For linked references, this means putting the link label inside `` ` `` tags: + +```kotlin +/** [`select`][DataFrame.select] */ // ✅ +/** [select][DataFrame.select] */ // ❌ +``` + +References inside `[]` are currently rendered as `` by IntelliJ, but that's an implementation +detail that may change, and it doesn't hold for Dokka. +Writing the code span explicitly keeps the rendering the same everywhere. + +Note that this only applies to labels that are actually code. +Prose labels (those that are part of the flow of the sentence) stay as they are, even when they link to code: + +```kotlin +/** ... takes the last [row][DataRow] of each group ... */ // ✅ "row" is prose here +/** ... see the [Columns Selection DSL][ColumnsSelectionDsl] ... */ // ✅ prose label +``` + +Links to [KDoc-helpers](#kodex--kdoc-helpers) are prose too: they're KDoc holders, not code, +even though they're written as Kotlin declarations. + +```kotlin +/** ### Check out: [Grammar][ConvertDocs.Grammar] */ // ✅ a KDoc-topic +/** For the full list, see [SupportedTypes][ConvertDocs.SupportedTypes]. */ // ✅ +``` + +This is about the *label*, not the target. +A grammar definition reference like `` [`colSelector`][ColumnSelectorDef] `` keeps its code span: +the label is a parameter name, the KDoc-helper just happens to be where it's described. + +Unlinked code, like `` `null` `` or `` `String` ``, gets a code span too. +Single-reference links, like `[DataFrame]`, cannot be wrapped — +`` [`DataFrame`] `` does not resolve — so leave those alone. + ### General Template The generalized template for all operations: @@ -613,8 +654,8 @@ But keep these things in mind: begins and ends with a space but does not consist entirely of whitespace, a single space is removed from the front and the back. So be careful writing things like `` ` { ` `` and add extra spaces if needed. - In IntelliJ, references inside `[]` are automatically formatted as `` when rendered to HTML at the moment. - This may change in the future, - so if you want to be sure it looks like code, you can write it like: `` [`function`][ref.to.function] `` + This may change in the future, so always write the code span yourself: + `` [`function`][ref.to.function] `` (see [Referring to code](#referring-to-code)). - Having multiple `[]` references and code spans in the same line breaks rendering in IntelliJ ([KT-55073](https://youtrack.jetbrains.com/issue/KT-55073/Improve-KDoc-experience#focus=Comments-27-6854785.0-0)). This can be avoided by providing aliases to each reference. From a490b996a3fa155bbaed5d9bdd27dbdaa2ed4fbd Mon Sep 17 00:00:00 2001 From: Jolan Rensen Date: Tue, 11 Aug 2026 15:13:34 +0200 Subject: [PATCH 2/6] Let claude write a script and apply code spans in code references in all KDoc of :core --- .../jetbrains/kotlinx/dataframe/DataColumn.kt | 2 +- .../dataframe/aggregation/AggregateDsl.kt | 22 +- .../aggregation/AggregateGroupedDsl.kt | 12 +- .../jetbrains/kotlinx/dataframe/aliases.kt | 4 +- .../dataframe/api/ColumnSelectionDsl.kt | 12 +- .../dataframe/api/ColumnsSelectionDsl.kt | 22 +- .../dataframe/api/DataColumnArithmetics.kt | 118 +++---- .../dataframe/api/NameValueProperty.kt | 16 +- .../jetbrains/kotlinx/dataframe/api/Nulls.kt | 46 +-- .../kotlinx/dataframe/api/ParserOptions.kt | 28 +- .../jetbrains/kotlinx/dataframe/api/add.kt | 8 +- .../jetbrains/kotlinx/dataframe/api/all.kt | 92 ++--- .../kotlinx/dataframe/api/allExcept.kt | 61 ++-- .../jetbrains/kotlinx/dataframe/api/and.kt | 8 +- .../jetbrains/kotlinx/dataframe/api/col.kt | 26 +- .../kotlinx/dataframe/api/colGroup.kt | 22 +- .../kotlinx/dataframe/api/colGroups.kt | 28 +- .../kotlinx/dataframe/api/colsAtAnyDepth.kt | 48 +-- .../kotlinx/dataframe/api/colsInGroups.kt | 44 +-- .../jetbrains/kotlinx/dataframe/api/colsOf.kt | 52 +-- .../kotlinx/dataframe/api/colsOfKind.kt | 20 +- .../dataframe/api/columnNameFilters.kt | 68 ++-- .../kotlinx/dataframe/api/columnRange.kt | 2 +- .../kotlinx/dataframe/api/convert.kt | 50 +-- .../kotlinx/dataframe/api/convertTo.kt | 6 +- .../jetbrains/kotlinx/dataframe/api/corr.kt | 8 +- .../jetbrains/kotlinx/dataframe/api/count.kt | 28 +- .../kotlinx/dataframe/api/countDistinct.kt | 16 +- .../jetbrains/kotlinx/dataframe/api/cumSum.kt | 2 +- .../kotlinx/dataframe/api/describe.kt | 2 +- .../kotlinx/dataframe/api/distinct.kt | 2 +- .../jetbrains/kotlinx/dataframe/api/drop.kt | 58 ++-- .../jetbrains/kotlinx/dataframe/api/expr.kt | 6 +- .../jetbrains/kotlinx/dataframe/api/filter.kt | 8 +- .../jetbrains/kotlinx/dataframe/api/first.kt | 84 ++--- .../kotlinx/dataframe/api/flatten.kt | 2 +- .../jetbrains/kotlinx/dataframe/api/format.kt | 112 +++--- .../kotlinx/dataframe/api/frameCol.kt | 22 +- .../kotlinx/dataframe/api/frameCols.kt | 30 +- .../jetbrains/kotlinx/dataframe/api/gather.kt | 22 +- .../kotlinx/dataframe/api/generateCode.kt | 10 +- .../jetbrains/kotlinx/dataframe/api/group.kt | 4 +- .../kotlinx/dataframe/api/groupBy.kt | 90 ++--- .../jetbrains/kotlinx/dataframe/api/insert.kt | 18 +- .../jetbrains/kotlinx/dataframe/api/join.kt | 8 +- .../kotlinx/dataframe/api/joinWith.kt | 2 +- .../jetbrains/kotlinx/dataframe/api/last.kt | 80 ++--- .../jetbrains/kotlinx/dataframe/api/max.kt | 320 +++++++++--------- .../jetbrains/kotlinx/dataframe/api/min.kt | 320 +++++++++--------- .../jetbrains/kotlinx/dataframe/api/move.kt | 14 +- .../jetbrains/kotlinx/dataframe/api/none.kt | 4 +- .../jetbrains/kotlinx/dataframe/api/pivot.kt | 122 +++---- .../jetbrains/kotlinx/dataframe/api/remove.kt | 2 +- .../jetbrains/kotlinx/dataframe/api/rename.kt | 20 +- .../jetbrains/kotlinx/dataframe/api/select.kt | 36 +- .../kotlinx/dataframe/api/simplify.kt | 6 +- .../jetbrains/kotlinx/dataframe/api/single.kt | 30 +- .../jetbrains/kotlinx/dataframe/api/sort.kt | 8 +- .../jetbrains/kotlinx/dataframe/api/take.kt | 64 ++-- .../kotlinx/dataframe/api/typeConversions.kt | 10 +- .../kotlinx/dataframe/api/ungroup.kt | 2 +- .../jetbrains/kotlinx/dataframe/api/update.kt | 68 ++-- .../kotlinx/dataframe/api/valueCol.kt | 20 +- .../kotlinx/dataframe/api/valueCols.kt | 30 +- .../kotlinx/dataframe/api/withoutNulls.kt | 18 +- .../codeGen/CodeWithTypeCastGenerator.kt | 2 +- .../kotlinx/dataframe/codeGen/Marker.kt | 6 +- .../dataframe/columns/ColumnAccessor.kt | 2 +- .../dataframe/columns/ColumnReference.kt | 2 +- .../kotlinx/dataframe/columns/SingleColumn.kt | 2 +- .../kotlinx/dataframe/columns/ValueColumn.kt | 4 +- .../documentation/CommonMinMaxDocs.kt | 12 +- .../documentation/CommonTakeAndDropDocs.kt | 8 +- .../CommonTakeAndDropWhileDocs.kt | 6 +- .../DslGrammarTemplateColumnsSelectionDsl.kt | 2 +- .../documentation/ExpressionsGivenColumn.kt | 4 +- .../ExpressionsGivenDataFrame.kt | 2 +- .../documentation/ExpressionsGivenRow.kt | 6 +- .../ExpressionsGivenRowAndColumn.kt | 2 +- .../kotlinx/dataframe/documentation/NA.kt | 4 +- .../kotlinx/dataframe/documentation/NaN.kt | 4 +- .../documentation/SelectingColumns.kt | 10 +- .../dataframe/documentation/SelectingRows.kt | 6 +- .../documentation/UnifyingNumbers.kt | 2 +- .../dataframe/documentation/snippets.kt | 2 +- .../kotlinx/dataframe/documentation/topics.kt | 2 +- .../kotlinx/dataframe/impl/TypeUtils.kt | 6 +- .../aggregation/aggregators/Aggregator.kt | 6 +- .../AggregatorAggregationHandler.kt | 4 +- .../aggregators/AggregatorInputHandler.kt | 4 +- .../HybridAggregationHandler.kt | 2 +- .../ReducingAggregationHandler.kt | 2 +- .../SelectingAggregationHandler.kt | 2 +- .../TwoStepMultipleColumnsHandler.kt | 2 +- .../kotlinx/dataframe/impl/api/parse.kt | 4 +- .../impl/columns/TransformableColumnSet.kt | 12 +- .../dataframe/impl/columns/constructors.kt | 2 +- .../dataframe/impl/io/FastDoubleParser.kt | 6 +- .../impl/schema/DataFrameSchemaImpl.kt | 2 +- .../kotlinx/dataframe/math/basicStats.kt | 2 +- 100 files changed, 1336 insertions(+), 1335 deletions(-) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt index d6d0ab9785..70dffb69fd 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/DataColumn.kt @@ -140,7 +140,7 @@ public interface DataColumn : BaseColumn { * For instance, when there are other [DataFrames][DataFrame] present in [values], we'll convert: * - `null` -> [DataFrame.empty]`()` * - [DataRow] -> single-row [DataFrame] - * - [List][List]`<`[DataRow][DataRow]`<*>>` -> multi-row [DataFrame] + * - [`List`][List]`<`[`DataRow`][DataRow]`<*>>` -> multi-row [DataFrame] * * to be able to create a [FrameColumn]. * There are more conversions for other types as well. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateDsl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateDsl.kt index 83bdb2c80f..12bede55a7 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateDsl.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateDsl.kt @@ -51,27 +51,27 @@ import kotlin.reflect.typeOf * * Predefined shortcuts for the most common statistical aggregation operations on [DataFrame]. * - * * [count][DataFrame.count] — calculate the number of rows + * * [`count`][DataFrame.count] — calculate the number of rows * (optionally counting only rows that satisfy the given predicate); - * * [max][DataFrame.max] / [maxOf][DataFrame.maxOf] / [maxFor][DataFrame.maxFor] — + * * [`max`][DataFrame.max] / [`maxOf`][DataFrame.maxOf] / [`maxFor`][DataFrame.maxFor] — * calculate the maximum of all values on the selected columns / by a row expression / * for each of the selected columns; - * * [min][DataFrame.min] / [minOf][DataFrame.minOf] / [minFor][DataFrame.minFor] — + * * [`min`][DataFrame.min] / [`minOf`][DataFrame.minOf] / [`minFor`][DataFrame.minFor] — * calculate the minimum of all values on the selected columns / by a row expression / * for each of the selected columns; - * * [sum][DataFrame.sum] / [sumOf][DataFrame.sumOf] / [sumFor][DataFrame.sumFor] — + * * [`sum`][DataFrame.sum] / [`sumOf`][DataFrame.sumOf] / [`sumFor`][DataFrame.sumFor] — * calculate the sum of all values on the selected columns / by a row expression / * for each of the selected columns; - * * [mean][DataFrame.mean] / [meanOf][DataFrame.meanOf] / [meanFor][DataFrame.meanFor] — + * * [`mean`][DataFrame.mean] / [`meanOf`][DataFrame.meanOf] / [`meanFor`][DataFrame.meanFor] — * calculate the mean (average) of all values on the selected columns / by a row expression / * for each of the selected columns; - * * [std][DataFrame.std] / [stdOf][DataFrame.stdOf] / [stdFor][DataFrame.stdFor] — + * * [`std`][DataFrame.std] / [`stdOf`][DataFrame.stdOf] / [`stdFor`][DataFrame.stdFor] — * calculate the standard deviation of all values on the selected columns / by a row expression / * for each of the selected columns; - * * [median][DataFrame.median] / [medianOf][DataFrame.medianOf] / [medianFor][DataFrame.medianFor] — + * * [`median`][DataFrame.median] / [`medianOf`][DataFrame.medianOf] / [`medianFor`][DataFrame.medianFor] — * calculate the median of all values on the selected columns / by a row expression / * for each of the selected columns; - * * [percentile][DataFrame.percentile] / [percentileOf][DataFrame.percentileOf] / [percentileFor][DataFrame.percentileFor] — + * * [`percentile`][DataFrame.percentile] / [`percentileOf`][DataFrame.percentileOf] / [`percentileFor`][DataFrame.percentileFor] — * calculate a specified percentile of all values on the selected columns / by a row expression / * for each of the selected columns. * @@ -81,12 +81,12 @@ internal typealias DataFrameAggregationStatistics = Nothing /** * {@get [AGGREGATE_DSL_TYPE]} allows to compute statistics on the {@get [OPERATING_COLUMNS]} - * and store the results as a new column using [into][AggregateDsl.into]. {@get [APPLY_NOTE]} + * and store the results as a new column using [`into`][AggregateDsl.into]. {@get [APPLY_NOTE]} * * * The resulting {@get [RESULT_TYPE]} has the same structure as the original * {@get [RECEIVER]}; - * instead of the groups, there are new columns of aggregated values created with [into][AggregateDsl.into]. + * instead of the groups, there are new columns of aggregated values created with [`into`][AggregateDsl.into]. * * You can use any of [DataFrame Aggregation Statistics][DataFrameAggregationStatistics] * or any custom aggregation function. @@ -97,7 +97,7 @@ internal interface AggregateDslDocs { /** * Aggregated values can be either simple values, [data rows][DataRow] or even - * [data frames][DataFrame]. Including them in the result using [into][AggregateDsl.into] will lead + * [data frames][DataFrame]. Including them in the result using [`into`][AggregateDsl.into] will lead * to creating [value column][ValueColumn], * [column group][ColumnGroup] or [frame column][FrameColumn] respectively * in the resulting {@get [RESULT_TYPE]} while preserving the original structure at higher levels. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateGroupedDsl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateGroupedDsl.kt index 4edf6074a0..4083c53851 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateGroupedDsl.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aggregation/AggregateGroupedDsl.kt @@ -18,12 +18,12 @@ import org.jetbrains.kotlinx.dataframe.documentation.ExcludeFromSources * {@set [AggregateDslDocs.RESULT_TYPE] [DataFrame]} * {@set [AggregateDslDocs.OPERATING_COLUMNS] columns within groups in [GroupBy]} * - * It allows [pivoting][DataFrame.pivot] inside [aggregate][Grouped.aggregate] via corresponding methods: - * * [pivot][AggregateGroupedDsl.pivot] - * * [pivotCounts][AggregateGroupedDsl.pivotCounts] - * * [pivotMatches][AggregateGroupedDsl.pivotMatches] + * It allows [pivoting][DataFrame.pivot] inside [`aggregate`][Grouped.aggregate] via corresponding methods: + * * [`pivot`][AggregateGroupedDsl.pivot] + * * [`pivotCounts`][AggregateGroupedDsl.pivotCounts] + * * [`pivotMatches`][AggregateGroupedDsl.pivotMatches] * - * Pivoting inside [aggregate][Grouped.aggregate] is useful for counting + * Pivoting inside [`aggregate`][Grouped.aggregate] is useful for counting * cross-group matrix-like statistics. */ @ExcludeFromSources @@ -31,7 +31,7 @@ internal typealias AggregateGroupedDslDocsSnippet = Nothing /** * A specialized [AggregateDsl] - * used in [GroupBy.aggregate][Grouped.aggregate] method; allows + * used in [`GroupBy.aggregate`][Grouped.aggregate] method; allows * [pivoting][DataFrame.pivot] inside its body. * * {@include [AggregateGroupedDslDocsSnippet]} diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt index 14d0d6e1a9..a35e6ba501 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/aliases.kt @@ -143,8 +143,8 @@ public typealias ColumnsSelector = Selector, Column * The lambda has access to the [`DataRow`][DataRow] both as `this` and as `it`, * enabling concise and readable conditions. * - * Commonly used in operations such as [filter][org.jetbrains.kotlinx.dataframe.api.filter], - * [drop][org.jetbrains.kotlinx.dataframe.api.drop], and others. + * Commonly used in operations such as [`filter`][org.jetbrains.kotlinx.dataframe.api.filter], + * [`drop`][org.jetbrains.kotlinx.dataframe.api.drop], and others. * * Equivalent to: * ```kotlin diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnSelectionDsl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnSelectionDsl.kt index 37dc367648..b520edcc4e 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnSelectionDsl.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnSelectionDsl.kt @@ -24,7 +24,7 @@ public interface ColumnSelectionDsl : ColumnsContainer { * Retrieves the value of this [ColumnReference] or [-Accessor][ColumnAccessor] from * the [DataFrame]. * - * This is a shorthand for [get][ColumnsContainer.get]`(myColumn)`. + * This is a shorthand for [`get`][ColumnsContainer.get]`(myColumn)`. * @throws [IllegalArgumentException] if the column is not found. */ private typealias CommonColumnReferenceInvokeDocs = Nothing @@ -49,7 +49,7 @@ public interface ColumnSelectionDsl : ColumnsContainer { /** * Retrieves the value of this [ColumnPath] from the [DataFrame]. - * This is a shorthand for [getColumn][ColumnsContainer.getColumn]`(myColumnPath)` and + * This is a shorthand for [`getColumn`][ColumnsContainer.getColumn]`(myColumnPath)` and * is most often used in combination with `operator fun String.get(column: String)`, {@comment cannot point to the right function.} * for instance: * ```kotlin @@ -65,7 +65,7 @@ public interface ColumnSelectionDsl : ColumnsContainer { /** * Retrieves the value of this [KProperty Accessor][KProperty] from the [DataFrame]. * - * This is a shorthand for [get][ColumnsContainer.get]`(MyType::myColumn)`. + * This is a shorthand for [`get`][ColumnsContainer.get]`(MyType::myColumn)`. * @throws [IllegalArgumentException] if the column is not found. */ private typealias CommonKPropertyInvokeDocs = Nothing @@ -99,7 +99,7 @@ public interface ColumnSelectionDsl : ColumnsContainer { * * This is a shorthand for * - * [get][ColumnsContainer.get]`(MyType::myColumnGroup).`[asColumnGroup][asColumnGroup]`().`[get][ColumnsContainer.get]`(MyOtherType::myOtherColumn)` + * [`get`][ColumnsContainer.get]`(MyType::myColumnGroup).`[`asColumnGroup`][asColumnGroup]`().`[`get`][ColumnsContainer.get]`(MyOtherType::myOtherColumn)` * * and can instead be written as * @@ -170,7 +170,7 @@ public interface ColumnSelectionDsl : ColumnsContainer { /** * Retrieves the value of the column with this name from the [DataFrame]. This can be * both typed and untyped. - * This is a shorthand for [get][ColumnsContainer.get]`("myColumnName")` and can be + * This is a shorthand for [`get`][ColumnsContainer.get]`("myColumnName")` and can be * written as `"myColumnName"()` instead. * * @throws [IllegalArgumentException] if there is no column with this name. @@ -184,7 +184,7 @@ public interface ColumnSelectionDsl : ColumnsContainer { /** * Retrieves the value of the column with this name from the [DataFrame]. This can be * both typed and untyped. - * This is a shorthand for [get][ColumnsContainer.get]`("myColumnName")` and can be + * This is a shorthand for [`get`][ColumnsContainer.get]`("myColumnName")` and can be * written as `"myColumnName"()` instead. * * @throws [IllegalArgumentException] if there is no column with this name. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt index 52a1bc7696..ed957295b5 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt @@ -37,7 +37,7 @@ public annotation class ColumnsSelectionDslMarker /** * ## Columns Selection DSL * {@include [SelectingColumns.ColumnsSelectionDsl.ColumnsSelectionDslWithExample]} - * {@set [SelectingColumns.OPERATION] [select][DataFrame.select]} + * {@set [SelectingColumns.OPERATION] [`select`][DataFrame.select]} * * @comment This interface be safely cast to [SingleColumn] across the library because it's always * implemented in combination with [DataFrameReceiver] which is a [SingleColumn] itself. @@ -391,9 +391,9 @@ public interface ColumnsSelectionDsl : // SingleColumn> * @include [SelectColumnsSelectionDsl.CommonSelectDocs] * @set [SelectColumnsSelectionDsl.CommonSelectDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColGroup.`[`select`][SingleColumn.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`select`][SingleColumn.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` * - * `df.`[select][DataFrame.select]` { myColGroup `[`{`][SingleColumn.select]` colA `[and][ColumnsSelectionDsl.and]` colB `[`}`][SingleColumn.select]` }` + * `df.`[`select`][DataFrame.select]` { myColGroup `[`{`][SingleColumn.select]` colA `[`and`][ColumnsSelectionDsl.and]` colB `[`}`][SingleColumn.select]` }` */ public operator fun SingleColumn>.invoke(selector: ColumnsSelector): ColumnSet = select(selector) @@ -402,9 +402,9 @@ public interface ColumnsSelectionDsl : // SingleColumn> * @include [SelectColumnsSelectionDsl.CommonSelectDocs] * @set [SelectColumnsSelectionDsl.CommonSelectDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { Type::myColGroup.`[`select`][KProperty.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` + * `df.`[`select`][DataFrame.select]` { Type::myColGroup.`[`select`][KProperty.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColGroup `[`{`][KProperty.select]` colA `[`and`][ColumnsSelectionDsl.and]` colB `[`}`][KProperty.select]` }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColGroup `[`{`][KProperty.select]` colA `[`and`][ColumnsSelectionDsl.and]` colB `[`}`][KProperty.select]` }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -415,9 +415,9 @@ public interface ColumnsSelectionDsl : // SingleColumn> * @include [SelectColumnsSelectionDsl.CommonSelectDocs] * @set [SelectColumnsSelectionDsl.CommonSelectDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColGroup".`[`select`][String.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` + * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`select`][String.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` * - * `df.`[select][DataFrame.select]` { "myColGroup" `[`{`][String.select]` colA `[`and`][ColumnsSelectionDsl.and]` colB `[`}`][String.select]` }` + * `df.`[`select`][DataFrame.select]` { "myColGroup" `[`{`][String.select]` colA `[`and`][ColumnsSelectionDsl.and]` colB `[`}`][String.select]` }` */ public operator fun String.invoke(selector: ColumnsSelector<*, R>): ColumnSet = select(selector) @@ -425,13 +425,13 @@ public interface ColumnsSelectionDsl : // SingleColumn> * @include [SelectColumnsSelectionDsl.CommonSelectDocs] * @set [SelectColumnsSelectionDsl.CommonSelectDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColGroup"].`[`select`][ColumnPath.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColGroup"].`[`select`][ColumnPath.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` * - * `df.`[select][DataFrame.select]` { "pathTo"["myColGroup"] `[`{`][ColumnPath.select]` colA `[`and`][ColumnsSelectionDsl.and]` colB `[`}`][ColumnPath.select]` }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColGroup"] `[`{`][ColumnPath.select]` colA `[`and`][ColumnsSelectionDsl.and]` colB `[`}`][ColumnPath.select]` }` * - * `df.`[select][DataFrame.select]` { `[`pathOf`][pathOf]`("pathTo", "myColGroup").`[`select`][ColumnPath.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` + * `df.`[`select`][DataFrame.select]` { `[`pathOf`][pathOf]`("pathTo", "myColGroup").`[`select`][ColumnPath.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` * - * `df.`[select][DataFrame.select]` { `[`pathOf`][pathOf]`("pathTo", "myColGroup")`[`() {`][ColumnPath.select]` someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() `[`}`][ColumnPath.select]` }` + * `df.`[`select`][DataFrame.select]` { `[`pathOf`][pathOf]`("pathTo", "myColGroup")`[`() {`][ColumnPath.select]` someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() `[`}`][ColumnPath.select]` }` */ public operator fun ColumnPath.invoke(selector: ColumnsSelector<*, R>): ColumnSet = select(selector) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt index f8017a8d44..b2762f9b0f 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/DataColumnArithmetics.kt @@ -179,22 +179,22 @@ private interface ColumnPlusNumberDocs { /** * @include [ColumnPlusNumberDocs] - * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ public operator fun DataColumn.plus(value: Int): DataColumn = map { it + value } /** * @include [ColumnPlusNumberDocs] * @set [COLUMN_PLUS_NUMBER_COLUMN_TYPE] [ColumnReference] - * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [minus][ColumnReference.minus], - * [times][ColumnReference.times], [div][ColumnReference.div] + * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [`minus`][ColumnReference.minus], + * [`times`][ColumnReference.times], [`div`][ColumnReference.div] */ public operator fun ColumnReference.plus(value: Int): ColumnReference = map { it + value } /** * @include [ColumnPlusNumberDocs] * @set [COLUMN_PLUS_NUMBER_NULL_NOTE] `null` values are not changed by this operation. - * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ @JvmName("plusIntNullable") public operator fun DataColumn.plus(value: Int): DataColumn = map { it?.plus(value) } @@ -202,14 +202,14 @@ public operator fun DataColumn.plus(value: Int): DataColumn = map { /** * @include [ColumnPlusNumberDocs] * @set [COLUMN_PLUS_NUMBER_EXAMPLE_NUMBER] 10.0 - * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ @JvmName("plusInt") public operator fun DataColumn.plus(value: Double): DataColumn = map { it + value } /** * @include [ColumnPlusNumberDocs] - * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ @JvmName("plusDouble") public operator fun DataColumn.plus(value: Int): DataColumn = map { it + value } @@ -217,21 +217,21 @@ public operator fun DataColumn.plus(value: Int): DataColumn = ma /** * @include [ColumnPlusNumberDocs] * @set [COLUMN_PLUS_NUMBER_EXAMPLE_NUMBER] 10L - * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ public operator fun DataColumn.plus(value: Long): DataColumn = map { it + value } /** * @include [ColumnPlusNumberDocs] * @set [COLUMN_PLUS_NUMBER_EXAMPLE_NUMBER] 10.0 - * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ public operator fun DataColumn.plus(value: Double): DataColumn = map { it + value } /** * @include [ColumnPlusNumberDocs] * @set [COLUMN_PLUS_NUMBER_EXAMPLE_NUMBER] BigDecimal("12.03") - * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [COLUMN_PLUS_NUMBER_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ public operator fun DataColumn.plus(value: BigDecimal): DataColumn = map { it + value } @@ -240,7 +240,7 @@ public operator fun DataColumn.plus(value: BigDecimal): DataColumn.plus(value: BigInteger): DataColumn = map { it + value } @@ -292,15 +292,15 @@ private interface NumberPlusColumnDocs { /** * @include [NumberPlusColumnDocs] - * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ public operator fun Int.plus(column: DataColumn): DataColumn = column.map { this + it } /** * @include [NumberPlusColumnDocs] * @set [NUMBER_PLUS_COLUMN_COLUMN_TYPE] [ColumnReference] - * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [minus][ColumnReference.minus], - * [times][ColumnReference.times], [div][ColumnReference.div] + * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [`minus`][ColumnReference.minus], + * [`times`][ColumnReference.times], [`div`][ColumnReference.div] */ public operator fun Int.plus(column: ColumnReference): ColumnReference = column.map { this + it } @@ -308,7 +308,7 @@ public operator fun Int.plus(column: ColumnReference): ColumnReference * @include [NumberPlusColumnDocs] * @set [NUMBER_PLUS_COLUMN_NULL_NOTE] `null` values from the original [column] * remain `null` values in the resulting [DataColumn]. - * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ @JvmName("plusNullable") public operator fun Int.plus(column: DataColumn): DataColumn = column.map { it?.plus(this) } @@ -317,14 +317,14 @@ public operator fun Int.plus(column: DataColumn): DataColumn = colum * @include [NumberPlusColumnDocs] * @set [NUMBER_PLUS_COLUMN_NUMBER_TYPE] [Double] * @set [NUMBER_PLUS_COLUMN_EXAMPLE_NUMBER] 10.0 - * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ @JvmName("doublePlus") public operator fun Double.plus(column: DataColumn): DataColumn = column.map { this + it } /** * @include [NumberPlusColumnDocs] - * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ @JvmName("intPlus") public operator fun Int.plus(column: DataColumn): DataColumn = column.map { this + it } @@ -333,7 +333,7 @@ public operator fun Int.plus(column: DataColumn): DataColumn = c * @include [NumberPlusColumnDocs] * @set [NUMBER_PLUS_COLUMN_NUMBER_TYPE] [Double] * @set [NUMBER_PLUS_COLUMN_EXAMPLE_NUMBER] 10.0 - * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ public operator fun Double.plus(column: DataColumn): DataColumn = column.map { this + it } @@ -341,7 +341,7 @@ public operator fun Double.plus(column: DataColumn): DataColumn * @include [NumberPlusColumnDocs] * @set [NUMBER_PLUS_COLUMN_NUMBER_TYPE] [Long] * @set [NUMBER_PLUS_COLUMN_EXAMPLE_NUMBER] 10L - * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ public operator fun Long.plus(column: DataColumn): DataColumn = column.map { this + it } @@ -349,7 +349,7 @@ public operator fun Long.plus(column: DataColumn): DataColumn = colu * @include [NumberPlusColumnDocs] * @set [NUMBER_PLUS_COLUMN_NUMBER_TYPE] [BigDecimal] * @set [NUMBER_PLUS_COLUMN_EXAMPLE_NUMBER] BigDecimal("12.03") - * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ public operator fun BigDecimal.plus(column: DataColumn): DataColumn = column.map { this + it } @@ -359,7 +359,7 @@ public operator fun BigDecimal.plus(column: DataColumn): DataColumn< * @set [NUMBER_PLUS_COLUMN_EXAMPLE] // Given the current disk usage in bits, * // and a DataFrame of file sizes in bits, compute the total disk usage if each file is added * val diskUsage = BigInteger("12345678900") + df.fileSize - * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [minus][DataColumn.minus], [times][DataColumn.times], [div][DataColumn.div] + * @set [NUMBER_PLUS_COLUMN_SEE_ALSO] [`minus`][DataColumn.minus], [`times`][DataColumn.times], [`div`][DataColumn.div] */ public operator fun BigInteger.plus(column: DataColumn): DataColumn = column.map { this + it } @@ -382,7 +382,7 @@ public operator fun BigInteger.plus(column: DataColumn): DataColumn< * df.temperature + " °C" * ``` * - * See also {@get [COLUMN_PLUS_STRING_SEE_ALSO] [plus][DataColumn.plus]}. + * See also {@get [COLUMN_PLUS_STRING_SEE_ALSO] [`plus`][DataColumn.plus]}. * * @param [\str] The [String] to append to each element of this {@get [COLUMN_PLUS_STRING_RECEIVER] [AnyCol]}. * @@ -432,7 +432,7 @@ public operator fun ColumnReference.plus(str: String): ColumnReference.minus(value: Int): DataColumn = map { i /** * @include [ColumnMinusNumberDocs] * @set [COLUMN_MINUS_NUMBER_COLUMN_TYPE] [ColumnReference] - * @set [COLUMN_MINUS_NUMBER_SEE_ALSO] [plus][ColumnReference.plus], - * [times][ColumnReference.times], [div][ColumnReference.div] + * @set [COLUMN_MINUS_NUMBER_SEE_ALSO] [`plus`][ColumnReference.plus], + * [`times`][ColumnReference.times], [`div`][ColumnReference.div] */ public operator fun ColumnReference.minus(value: Int): ColumnReference = map { it - value } @@ -530,7 +530,7 @@ public operator fun DataColumn.minus(value: BigInteger): DataColumn< * val remainingBudget = {@get [NUMBER_MINUS_COLUMN_EXAMPLE_NUMBER] 1000} - df.expenses} * ``` * - * See also {@get [NUMBER_MINUS_COLUMN_SEE_ALSO] [plus][DataColumn.plus], [times][DataColumn.times], [div][DataColumn.div]}. + * See also {@get [NUMBER_MINUS_COLUMN_SEE_ALSO] [`plus`][DataColumn.plus], [`times`][DataColumn.times], [`div`][DataColumn.div]}. * * @param [\column] A {@get [NUMBER_MINUS_COLUMN_COLUMN_TYPE] [DataColumn]} containing the elements to subtract * from this {@get [NUMBER_MINUS_COLUMN_NUMBER_TYPE] [Int]}. @@ -566,7 +566,7 @@ public operator fun Int.minus(column: DataColumn): DataColumn = column /** * @include [NumberMinusColumnDocs] * @set [NUMBER_MINUS_COLUMN_COLUMN_TYPE] [ColumnReference] - * @set [NUMBER_MINUS_COLUMN_SEE_ALSO] [plus][ColumnReference.plus], [times][ColumnReference.times], [div][ColumnReference.div] + * @set [NUMBER_MINUS_COLUMN_SEE_ALSO] [`plus`][ColumnReference.plus], [`times`][ColumnReference.times], [`div`][ColumnReference.div] */ public operator fun Int.minus(column: ColumnReference): ColumnReference = column.map { this - it } @@ -739,21 +739,21 @@ private interface TimesDocs { /** * @include [TimesDocs] - * @set [TIMES_SEE_ALSO] [div][DataColumn.div], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [TIMES_SEE_ALSO] [`div`][DataColumn.div], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ public operator fun DataColumn.times(value: Int): DataColumn = map { it * value } /** * @include [TimesDocs] * @set [TIMES_COLUMN_TYPE] [ColumnReference] - * @set [TIMES_SEE_ALSO] [div][ColumnReference.div], [plus][ColumnReference.plus], [minus][ColumnReference.minus] + * @set [TIMES_SEE_ALSO] [`div`][ColumnReference.div], [`plus`][ColumnReference.plus], [`minus`][ColumnReference.minus] */ public operator fun ColumnReference.times(value: Int): ColumnReference = map { it * value } /** * @include [TimesDocs] * @set [TIMES_NULL_NOTE] `null` values are not changed by this operation. - * @set [TIMES_SEE_ALSO] [div][DataColumn.div], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [TIMES_SEE_ALSO] [`div`][DataColumn.div], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ @JvmName("timesIntNullable") public operator fun DataColumn.times(value: Int): DataColumn = map { it?.times(value) } @@ -761,14 +761,14 @@ public operator fun DataColumn.times(value: Int): DataColumn = map { /** * @include [TimesDocs] * @set [TIMES_EXAMPLE_NUMBER] 1000.0 - * @set [TIMES_SEE_ALSO] [div][DataColumn.div], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [TIMES_SEE_ALSO] [`div`][DataColumn.div], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ @JvmName("timesInt") public operator fun DataColumn.times(value: Double): DataColumn = map { it * value } /** * @include [TimesDocs] - * @set [TIMES_SEE_ALSO] [div][DataColumn.div], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [TIMES_SEE_ALSO] [`div`][DataColumn.div], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ @JvmName("timesDouble") public operator fun DataColumn.times(value: Int): DataColumn = map { it * value } @@ -776,14 +776,14 @@ public operator fun DataColumn.times(value: Int): DataColumn = m /** * @include [TimesDocs] * @set [TIMES_EXAMPLE_NUMBER] 1000.0 - * @set [TIMES_SEE_ALSO] [div][DataColumn.div], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [TIMES_SEE_ALSO] [`div`][DataColumn.div], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ public operator fun DataColumn.times(value: Double): DataColumn = map { it * value } /** * @include [TimesDocs] * @set [TIMES_EXAMPLE_NUMBER] 1000L - * @set [TIMES_SEE_ALSO] [div][DataColumn.div], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [TIMES_SEE_ALSO] [`div`][DataColumn.div], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ public operator fun DataColumn.times(value: Long): DataColumn = map { it * value } @@ -791,7 +791,7 @@ public operator fun DataColumn.times(value: Long): DataColumn = map * @include [TimesDocs] * @set [TIMES_EXAMPLE] // In a DataFrame of product prices, compute the price including a 20% tax * val priceWithTax = df.price * BigDecimal("1.20") - * @set [TIMES_SEE_ALSO] [div][DataColumn.div], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [TIMES_SEE_ALSO] [`div`][DataColumn.div], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ public operator fun DataColumn.times(value: BigDecimal): DataColumn = map { it * value } @@ -799,7 +799,7 @@ public operator fun DataColumn.times(value: BigDecimal): DataColumn< * @include [TimesDocs] * @set [TIMES_EXAMPLE] // In a DataFrame of file sizes in bits, compute the total size of multiple copies of each file * val totalSize = df.fileSize * BigInteger("12345") - * @set [TIMES_SEE_ALSO] [div][DataColumn.div], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [TIMES_SEE_ALSO] [`div`][DataColumn.div], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ public operator fun DataColumn.times(value: BigInteger): DataColumn = map { it * value } @@ -854,22 +854,22 @@ private interface ColumnDivNumberDocs { /** * @include [ColumnDivNumberDocs] - * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ public operator fun DataColumn.div(value: Int): DataColumn = map { it / value } /** * @include [ColumnDivNumberDocs] * @set [COLUMN_DIV_NUMBER_COLUMN_TYPE] [ColumnReference] - * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [times][ColumnReference.times], - * [plus][ColumnReference.plus], [minus][ColumnReference.minus] + * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [`times`][ColumnReference.times], + * [`plus`][ColumnReference.plus], [`minus`][ColumnReference.minus] */ public operator fun ColumnReference.div(value: Int): ColumnReference = map { it / value } /** * @include [ColumnDivNumberDocs] * @set [COLUMN_DIV_NUMBER_NULL_NOTE] `null` values are not changed by this operation. - * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ @JvmName("divIntNullable") public operator fun DataColumn.div(value: Int): DataColumn = map { it?.div(value) } @@ -879,7 +879,7 @@ public operator fun DataColumn.div(value: Int): DataColumn = map { i * @set [COLUMN_DIV_NUMBER_INT_NOTE] * @set [COLUMN_DIV_NUMBER_EXAMPLE] // In a DataFrame of distances in meters, convert them to kilometers * val distanceKm = df.distanceMeters / 1000.0 - * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] * @set [COLUMN_DIV_NUMBER_ZERO_ERROR] */ @JvmName("divInt") @@ -891,7 +891,7 @@ public operator fun DataColumn.div(value: Double): DataColumn = map * @set [COLUMN_DIV_NUMBER_EXAMPLE] * // In a DataFrame of hourly travel distances, compute the average distance traveled per minute * val distancePerMinute = df.distancePerHour / 60 - * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] * @set [COLUMN_DIV_NUMBER_ZERO_ERROR] */ @JvmName("divDouble") @@ -902,7 +902,7 @@ public operator fun DataColumn.div(value: Int): DataColumn = map * @set [COLUMN_DIV_NUMBER_INT_NOTE] * @set [COLUMN_DIV_NUMBER_EXAMPLE] // In a DataFrame of distances in meters, convert them to kilometers * val distanceKm = df.distanceMeters / 1000.0 - * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] * @set [COLUMN_DIV_NUMBER_ZERO_ERROR] */ public operator fun DataColumn.div(value: Double): DataColumn = map { it / value } @@ -912,7 +912,7 @@ public operator fun DataColumn.div(value: Double): DataColumn = * @set [COLUMN_DIV_NUMBER_EXAMPLE] // In a DataFrame of item counts, * // compute how many full boxes of 10 items can be formed * val fullBoxes = df.itemCount / 10L - * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ public operator fun DataColumn.div(value: Long): DataColumn = map { it / value } @@ -921,7 +921,7 @@ public operator fun DataColumn.div(value: Long): DataColumn = map { * @set [COLUMN_DIV_NUMBER_INT_NOTE] * @set [COLUMN_DIV_NUMBER_EXAMPLE] // In a DataFrame of distances in miles, convert them to kilometers * val distanceKm = df.distanceMiles / BigDecimal("0.62137") - * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [COLUMN_DIV_NUMBER_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ public operator fun DataColumn.div(value: BigDecimal): DataColumn = map { it / value } @@ -930,7 +930,7 @@ public operator fun DataColumn.div(value: BigDecimal): DataColumn.div(value: BigInteger): DataColumn = map { it / value } @@ -989,15 +989,15 @@ private interface NumberDivColumnDocs { /** * @include [NumberDivColumnDocs] - * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ public operator fun Int.div(column: DataColumn): DataColumn = column.map { this / it } /** * @include [NumberDivColumnDocs] * @set [NUMBER_DIV_COLUMN_COLUMN_TYPE] [ColumnReference] - * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [times][ColumnReference.times], - * [plus][ColumnReference.plus], [minus][ColumnReference.minus] + * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [`times`][ColumnReference.times], + * [`plus`][ColumnReference.plus], [`minus`][ColumnReference.minus] */ public operator fun Int.div(column: ColumnReference): ColumnReference = column.map { this / it } @@ -1005,7 +1005,7 @@ public operator fun Int.div(column: ColumnReference): ColumnReference * @include [NumberDivColumnDocs] * @set [NUMBER_DIV_COLUMN_NULL_NOTE] If an element of [column] is `null`, * the corresponding value in the resulting [DataColumn] is also `null`. - * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ @JvmName("divNullable") public operator fun Int.div(column: DataColumn): DataColumn = column.map { it?.let { this / it } } @@ -1017,7 +1017,7 @@ public operator fun Int.div(column: DataColumn): DataColumn = column * @set [NUMBER_DIV_COLUMN_EXAMPLE] // Given a marketing budget of 1,000 euros, * // compute the cost per acquired customer for each campaign * val costPerCustomer = 1000.0 / df.acquiredCustomers - * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] * @set [NUMBER_DIV_COLUMN_ZERO_ERROR] */ @JvmName("doubleDiv") @@ -1029,7 +1029,7 @@ public operator fun Double.div(column: DataColumn): DataColumn = co * @set [NUMBER_DIV_COLUMN_EXAMPLE] // In a DataFrame of prices of a square meter in different places, * // compute how many square meters can be bought with a budget of 500 thousand euros * val squareMeters = 500_000 / df.pricePerSquareMeter - * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] * @set [NUMBER_DIV_COLUMN_ZERO_ERROR] */ @JvmName("intDiv") @@ -1042,7 +1042,7 @@ public operator fun Int.div(column: DataColumn): DataColumn = co * @set [NUMBER_DIV_COLUMN_EXAMPLE] // In a DataFrame of prices of a square meter in different places, * // compute how many square meters can be bought with a budget of 500 thousand euros * val squareMeters = 500_000.0 / df.pricePerSquareMeter - * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] * @set [NUMBER_DIV_COLUMN_ZERO_ERROR] */ public operator fun Double.div(column: DataColumn): DataColumn = column.map { this / it } @@ -1053,7 +1053,7 @@ public operator fun Double.div(column: DataColumn): DataColumn = * @set [NUMBER_DIV_COLUMN_EXAMPLE] // In a DataFrame of file sizes in bits, * // compute how many copies of each file can fit into the given storage capacity * val fileCopies = 10_000_000_000L / df.fileSize - * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ public operator fun Long.div(column: DataColumn): DataColumn = column.map { this / it } @@ -1064,7 +1064,7 @@ public operator fun Long.div(column: DataColumn): DataColumn = colum * @set [NUMBER_DIV_COLUMN_EXAMPLE] // In a DataFrame of prices of a product per gram, * // compute the amount of product that can be bought with a budget of 3,451.76 euros * val productAmount = BigDecimal("3451.76") / df.pricePerGram - * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [times][DataColumn.times], [plus][DataColumn.plus], [minus][DataColumn.minus] + * @set [NUMBER_DIV_COLUMN_SEE_ALSO] [`times`][DataColumn.times], [`plus`][DataColumn.plus], [`minus`][DataColumn.minus] */ public operator fun BigDecimal.div(column: DataColumn): DataColumn = column.map { this / it } @@ -1074,7 +1074,7 @@ public operator fun BigDecimal.div(column: DataColumn): DataColumn): DataColumn = column.map { this / it } @@ -1118,7 +1118,7 @@ private interface CompareDocs { * @set [COMPARE_EXAMPLE] // Given a DataFrame of orders with statuses represented as strings, * // create a column that indicates whether each order is canceled * val isCanceled = df.status eq "canceled" - * @set [COMPARE_SEE_ALSO] [neq][DataColumn.neq], [gt][DataColumn.gt], [lt][DataColumn.lt] + * @set [COMPARE_SEE_ALSO] [`neq`][DataColumn.neq], [`gt`][DataColumn.gt], [`lt`][DataColumn.lt] * @set [COMPARE_OPERATION] equal to */ public infix fun DataColumn.eq(value: T): DataColumn = map { it == value } @@ -1129,7 +1129,7 @@ public infix fun DataColumn.eq(value: T): DataColumn = map { it * @set [COMPARE_EXAMPLE] // Given a DataFrame of orders with statuses represented as strings, * // create a column that indicates which orders are not completed * val isNotCompleted = df.status neq "completed" - * @set [COMPARE_SEE_ALSO] [eq][DataColumn.eq], [gt][DataColumn.gt], [lt][DataColumn.lt] + * @set [COMPARE_SEE_ALSO] [`eq`][DataColumn.eq], [`gt`][DataColumn.gt], [`lt`][DataColumn.lt] * @set [COMPARE_OPERATION] not equal to */ public infix fun DataColumn.neq(value: T): DataColumn = map { it != value } @@ -1140,7 +1140,7 @@ public infix fun DataColumn.neq(value: T): DataColumn = map { it * @set [COMPARE_EXAMPLE] // Given a DataFrame of orders, * // create a column that indicates which orders cost more than 1,000 euros * val isExpensive = df.orderCost gt 1000 - * @set [COMPARE_SEE_ALSO] [eq][DataColumn.eq], [neq][DataColumn.neq], [lt][DataColumn.lt] + * @set [COMPARE_SEE_ALSO] [`eq`][DataColumn.eq], [`neq`][DataColumn.neq], [`lt`][DataColumn.lt] * @set [COMPARE_OPERATION] greater than */ public infix fun > DataColumn.gt(value: T): DataColumn = map { it > value } @@ -1151,7 +1151,7 @@ public infix fun > DataColumn.gt(value: T): DataColumn> DataColumn.lt(value: T): DataColumn = map { it < value } diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/NameValueProperty.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/NameValueProperty.kt index 53724a35df..eaddd4dd64 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/NameValueProperty.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/NameValueProperty.kt @@ -55,8 +55,8 @@ public val DataRow?>.key: String? get() = this["key"] as String? /** - * Accesses the 'key' column of this [KeyValueProperty][KeyValueProperty] - * [ColumnsContainer][org.jetbrains.kotlinx.dataframe.ColumnsContainer]. + * Accesses the 'key' column of this [`KeyValueProperty`][KeyValueProperty] + * [`ColumnsContainer`][org.jetbrains.kotlinx.dataframe.ColumnsContainer]. * * This is a temporary, future-proof, extension property in preparation of the migration from [KeyValueProperty] * to [NameValueProperty]. @@ -66,8 +66,8 @@ public val ColumnsScope>.name: DataColumn get() = key /** - * Accesses the 'key' column of this [KeyValueProperty][KeyValueProperty] - * [ColumnsContainer][org.jetbrains.kotlinx.dataframe.ColumnsContainer]. + * Accesses the 'key' column of this [`KeyValueProperty`][KeyValueProperty] + * [`ColumnsContainer`][org.jetbrains.kotlinx.dataframe.ColumnsContainer]. * * This is a temporary, future-proof, extension property in preparation of the migration from [KeyValueProperty] * to [NameValueProperty]. @@ -77,8 +77,8 @@ public val ColumnsScope?>.name: DataColumn get() = key /** - * Accesses the 'key' value of this [KeyValueProperty][KeyValueProperty] - * [DataRow][DataRow]. + * Accesses the 'key' value of this [`KeyValueProperty`][KeyValueProperty] + * [`DataRow`][DataRow]. * * This is a temporary, future-proof, extension property in preparation of the migration from [KeyValueProperty] * to [NameValueProperty]. @@ -88,8 +88,8 @@ public val DataRow>.name: String get() = key /** - * Accesses the 'key' value of this [KeyValueProperty][KeyValueProperty] - * [DataRow][DataRow]. + * Accesses the 'key' value of this [`KeyValueProperty`][KeyValueProperty] + * [`DataRow`][DataRow]. * * This is a temporary, future-proof, extension property in preparation of the migration from [KeyValueProperty] * to [NameValueProperty]. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt index 6bf6aa7d59..d2ebf5a514 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/Nulls.kt @@ -51,7 +51,7 @@ internal interface FillNulls { typealias FillNullsSelectingOptions = Nothing } -/** {@set [SelectingColumns.OPERATION] [fillNulls][fillNulls]} */ +/** {@set [SelectingColumns.OPERATION] [`fillNulls`][fillNulls]} */ private typealias SetFillNullsOperationArg = Nothing /** @@ -171,7 +171,7 @@ internal inline val Float?.isNA: Boolean get() = this == null || this.isNaN() */ internal interface FillNaNs { - /** @include [Update.Grammar] {@set [Update.UPDATE_OPERATION] [fillNaNs][fillNaNs]} */ + /** @include [Update.Grammar] {@set [Update.UPDATE_OPERATION] [`fillNaNs`][fillNaNs]} */ typealias Grammar = Nothing /** @@ -181,7 +181,7 @@ internal interface FillNaNs { typealias FillNaNsSelectingOptions = Nothing } -/** {@set [SelectingColumns.OPERATION] [fillNaNs][fillNaNs]} */ +/** {@set [SelectingColumns.OPERATION] [`fillNaNs`][fillNaNs]} */ @ExcludeFromSources internal typealias SetFillNaNsOperationArg = Nothing @@ -246,7 +246,7 @@ public fun DataFrame.fillNaNs(vararg columns: ColumnReference): Upd */ internal interface FillNA { - /** @include [Update.Grammar] {@set [Update.UPDATE_OPERATION] [fillNA][fillNA]} */ + /** @include [Update.Grammar] {@set [Update.UPDATE_OPERATION] [`fillNA`][fillNA]} */ typealias Grammar = Nothing /** @@ -256,7 +256,7 @@ internal interface FillNA { typealias FillNASelectingOptions = Nothing } -/** {@set [SelectingColumns.OPERATION] [fillNA][fillNA]} */ +/** {@set [SelectingColumns.OPERATION] [`fillNA`][fillNA]} */ @ExcludeFromSources internal typealias SetFillNAOperationArg = Nothing @@ -327,7 +327,7 @@ private typealias DropColumnAccessorsParam = Nothing /** * ## The Drop Nulls Operation * - * Removes rows with `null` values. Specific case of [drop][DataFrame.drop]. + * Removes rows with `null` values. Specific case of [`drop`][DataFrame.drop]. * * Optionally, you can select which columns to operate on (see [Selecting Columns][DropNullsSelectingOptions]). * @@ -353,7 +353,7 @@ internal interface DropNulls { typealias DropNullsSelectingOptions = Nothing } -/** {@set [SelectingColumns.OPERATION] [dropNulls][dropNulls]} */ +/** {@set [SelectingColumns.OPERATION] [`dropNulls`][dropNulls]} */ @ExcludeFromSources private typealias SetDropNullsOperationArg = Nothing @@ -367,7 +367,7 @@ private typealias CommonDropNullsFunctionDoc = Nothing /** * @include [CommonDropNullsFunctionDoc] * @include [SelectingColumns.ColumnsSelectionDsl.ColumnsSelectionDslWithExample] {@include [SetDropNullsOperationArg]} - * `df.`[dropNulls][dropNulls]`(whereAllNull = true) { `[colsOf][colsOf]`<`[Double][Double]`>() }` + * `df.`[`dropNulls`][dropNulls]`(whereAllNull = true) { `[`colsOf`][colsOf]`<`[`Double`][Double]`>() }` * @include [DropNulls.WhereAllNullParam] * @include [DropDslParam] */ @@ -403,7 +403,7 @@ public fun DataFrame.dropNulls(whereAllNull: Boolean = false): DataFrame< /** * @include [CommonDropNullsFunctionDoc] * - * `df.`[dropNulls][dropNulls]`(Person::length, whereAllNull = true)` + * `df.`[`dropNulls`][dropNulls]`(Person::length, whereAllNull = true)` * @include [DropNulls.WhereAllNullParam] * @include [DropKPropertiesParam] */ @@ -415,7 +415,7 @@ public fun DataFrame.dropNulls(vararg columns: KProperty<*>, whereAllNull /** * @include [CommonDropNullsFunctionDoc] * - * `df.`[dropNulls][dropNulls]`("length", whereAllNull = true)` + * `df.`[`dropNulls`][dropNulls]`("length", whereAllNull = true)` * @include [DropNulls.WhereAllNullParam] * @include [DropColumnNamesParam] */ @@ -425,7 +425,7 @@ public fun DataFrame.dropNulls(vararg columns: String, whereAllNull: Bool /** * @include [CommonDropNullsFunctionDoc] * - * `df.`[dropNulls][dropNulls]`(length, whereAllNull = true)` + * `df.`[`dropNulls`][dropNulls]`(length, whereAllNull = true)` * @include [DropNulls.WhereAllNullParam] * @include [DropColumnAccessorsParam] */ @@ -449,7 +449,7 @@ public fun DataColumn.dropNulls(): DataColumn = /** * ## The Drop `NA` Operation * - * Removes rows with [`NA`][NA] values. Specific case of [drop][DataFrame.drop]. + * Removes rows with [`NA`][NA] values. Specific case of [`drop`][DataFrame.drop]. * * Optionally, you can select which columns to operate on (see [Selecting Columns][DropNASelectingOptions]). * Also, you can supply `whereAllNA = true` to only drop rows where all selected cells are [`NA`][NA]. By default, @@ -474,7 +474,7 @@ internal interface DropNA { typealias DropNASelectingOptions = Nothing } -/** {@set [SelectingColumns.OPERATION] [dropNA][dropNA]} */ +/** {@set [SelectingColumns.OPERATION] [`dropNA`][dropNA]} */ @ExcludeFromSources private typealias SetDropNAOperationArg = Nothing @@ -488,7 +488,7 @@ private typealias CommonDropNAFunctionDoc = Nothing /** * @include [CommonDropNAFunctionDoc] * @include [SelectingColumns.ColumnsSelectionDsl.ColumnsSelectionDslWithExample] {@include [SetDropNAOperationArg]} - * `df.`[dropNA][dropNA]`(whereAllNA = true) { `[colsOf][colsOf]`<`[Double][Double]`>() }` + * `df.`[`dropNA`][dropNA]`(whereAllNA = true) { `[`colsOf`][colsOf]`<`[`Double`][Double]`>() }` * @include [DropNA.WhereAllNAParam] * @include [DropDslParam] */ @@ -506,7 +506,7 @@ public fun DataFrame.dropNA(whereAllNA: Boolean = false, columns: Columns /** * @include [CommonDropNAFunctionDoc] * - * `df.`[dropNA][dropNA]`(Person::length, whereAllNA = true)` + * `df.`[`dropNA`][dropNA]`(Person::length, whereAllNA = true)` * @include [DropNA.WhereAllNAParam] * @include [DropKPropertiesParam] */ @@ -518,7 +518,7 @@ public fun DataFrame.dropNA(vararg columns: KProperty<*>, whereAllNA: Boo /** * @include [CommonDropNAFunctionDoc] * @include [SelectingColumns.ColumnNamesApi.ColumnNamesApiWithExample] {@include [SetDropNAOperationArg]} - * `df.`[dropNA][dropNA]`("length", whereAllNA = true)` + * `df.`[`dropNA`][dropNA]`("length", whereAllNA = true)` * @include [DropNA.WhereAllNAParam] * @include [DropColumnNamesParam] */ @@ -528,7 +528,7 @@ public fun DataFrame.dropNA(vararg columns: String, whereAllNA: Boolean = /** * @include [CommonDropNAFunctionDoc] * - * `df.`[dropNA][dropNA]`(length, whereAllNA = true)` + * `df.`[`dropNA`][dropNA]`(length, whereAllNA = true)` * @include [DropNA.WhereAllNAParam] * @include [DropColumnAccessorsParam] */ @@ -564,7 +564,7 @@ public fun DataColumn.dropNA(): DataColumn = /** * ## The Drop `NaN` Operation * - * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [drop][DataFrame.drop]. + * Removes rows with [`NaN`][Double.isNaN] values. Specific case of [`drop`][DataFrame.drop]. * * Optionally, you can select which columns to operate on (see [Selecting Columns][DropNaNsSelectingOptions]). * Also, you can supply `whereAllNaN = true` to only drop rows where all selected cells are [`NaN`][Double.isNaN]. By default, @@ -589,7 +589,7 @@ internal interface DropNaNs { typealias DropNaNsSelectingOptions = Nothing } -/** {@set [SelectingColumns.OPERATION] [dropNaNs][dropNaNs]} */ +/** {@set [SelectingColumns.OPERATION] [`dropNaNs`][dropNaNs]} */ @ExcludeFromSources private typealias SetDropNaNsOperationArg = Nothing @@ -603,7 +603,7 @@ private typealias CommonDropNaNsFunctionDoc = Nothing /** * @include [CommonDropNaNsFunctionDoc] * @include [SelectingColumns.ColumnsSelectionDsl.ColumnsSelectionDslWithExample] {@include [SetDropNaNsOperationArg]} - * `df.`[dropNaNs][dropNaNs]`(whereAllNaN = true) { `[colsOf][colsOf]`<`[Double][Double]`>() }` + * `df.`[`dropNaNs`][dropNaNs]`(whereAllNaN = true) { `[`colsOf`][colsOf]`<`[`Double`][Double]`>() }` * @include [DropNaNs.WhereAllNaNParam] * @include [DropDslParam] */ @@ -619,7 +619,7 @@ public fun DataFrame.dropNaNs(whereAllNaN: Boolean = false, columns: Colu /** * @include [CommonDropNaNsFunctionDoc] * - * `df.`[dropNaNs][dropNaNs]`(Person::length, whereAllNaN = true)` + * `df.`[`dropNaNs`][dropNaNs]`(Person::length, whereAllNaN = true)` * @include [DropNaNs.WhereAllNaNParam] * @include [DropKPropertiesParam] */ @@ -631,7 +631,7 @@ public fun DataFrame.dropNaNs(vararg columns: KProperty<*>, whereAllNaN: /** * @include [CommonDropNaNsFunctionDoc] * - * `df.`[dropNaNs][dropNaNs]`("length", whereAllNaN = true)` + * `df.`[`dropNaNs`][dropNaNs]`("length", whereAllNaN = true)` * @include [DropNaNs.WhereAllNaNParam] * @include [DropColumnNamesParam] */ @@ -641,7 +641,7 @@ public fun DataFrame.dropNaNs(vararg columns: String, whereAllNaN: Boolea /** * @include [CommonDropNaNsFunctionDoc] * - * `df.`[dropNaNs][dropNaNs]`(length, whereAllNaN = true)` + * `df.`[`dropNaNs`][dropNaNs]`(length, whereAllNaN = true)` * @include [DropNaNs.WhereAllNaNParam] * @include [DropColumnAccessorsParam] */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ParserOptions.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ParserOptions.kt index d3992dfa67..b9a1a6dcef 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ParserOptions.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ParserOptions.kt @@ -32,12 +32,12 @@ import java.time.LocalTime as JavaLocalTime /** * Global counterpart of [ParserOptions]. * - * These options are used to configure how [DataColumns][DataColumn] of type [String] or [String?][String] + * These options are used to configure how [DataColumns][DataColumn] of type [String] or [`String?`][String] * should be parsed. * * Settings changed here will affect the defaults for all parsing operations. * You can always pass a [ParserOptions] object to functions that perform parsing, like [tryParse], [parse], [convert], - * or even [DataFrame.readCsv][DataFrame.Companion.readCsv\] to override these options. + * or even [`DataFrame.readCsv`][DataFrame.Companion.readCsv\] to override these options. * * The default values are set by [Parsers.resetToDefault]. * @@ -257,8 +257,8 @@ public interface GlobalParserOptions { * This is marked "stable" from Kotlin 2.4.0+, so, by default this is `true`. * * NOTE: If you are using an older Kotlin version, - * interacting with a [Uuid][Uuid] in your code might require - * `@`[OptIn][OptIn]`(`[ExperimentalUuidApi][ExperimentalUuidApi]`::class)`. + * interacting with a [`Uuid`][Uuid] in your code might require + * `@`[`OptIn`][OptIn]`(`[`ExperimentalUuidApi`][ExperimentalUuidApi]`::class)`. * In notebooks, add `-opt-in=kotlin.uuid.ExperimentalUuidApi` to the compiler arguments. */ public var parseExperimentalUuid: Boolean @@ -270,8 +270,8 @@ public interface GlobalParserOptions { * If false, instants are recognized as the deprecated [kotlinx.datetime.Instant] type (#1350). * * NOTE: If you are using an older Kotlin version, - * interacting with an [Instant][kotlin.time.Instant] in your code might require - * `@`[OptIn][OptIn]`(`[ExperimentalTime][kotlin.time.ExperimentalTime]`::class)`. + * interacting with an [`Instant`][kotlin.time.Instant] in your code might require + * `@`[`OptIn`][OptIn]`(`[`ExperimentalTime`][kotlin.time.ExperimentalTime]`::class)`. * In notebooks, add `-opt-in=kotlin.time.ExperimentalTime` to the compiler arguments. */ public var parseExperimentalInstant: Boolean @@ -368,10 +368,10 @@ internal typealias DateTimeComponentsFallbackLink = Nothing /** * ### Options for parsing [String]`?` columns * - * These options are used to configure how [DataColumn]s of type [String] or [String?][String] should be parsed. + * These options are used to configure how [DataColumn]s of type [String] or [`String?`][String] should be parsed. * They can be passed to [tryParse] and [parse] functions. * - * You can also use the [DataFrame.parser][DataFrame.Companion.parser] property to access and modify + * You can also use the [`DataFrame.parser`][DataFrame.Companion.parser] property to access and modify * the global parser configuration. * * If any of the arguments in [ParserOptions] are `null` (or [ParserOptions] itself is `null`), @@ -393,15 +393,15 @@ internal typealias DateTimeComponentsFallbackLink = Nothing * @param parseExperimentalUuid whether to allow parsing UUIDs to the [Uuid] type. * This is marked "stable" from Kotlin 2.4.0+, so, by default this is `true`. * NOTE: If you are using an older Kotlin version, - * interacting with a [Uuid][Uuid] in your code might require - * `@`[OptIn][OptIn]`(`[ExperimentalUuidApi][ExperimentalUuidApi]`::class)`. + * interacting with a [`Uuid`][Uuid] in your code might require + * `@`[`OptIn`][OptIn]`(`[`ExperimentalUuidApi`][ExperimentalUuidApi]`::class)`. * In notebooks, add `-opt-in=kotlin.uuid.ExperimentalUuidApi` to the compiler arguments. * @param parseExperimentalInstant whether to allow parsing to the [kotlin.time.Instant] type. * This is marked "stable" from Kotlin 2.3.0+, so, by default this is `true`. * If false, instants are recognized as the deprecated [kotlinx.datetime.Instant] type (#1350). * NOTE: If you are using an older Kotlin version, - * interacting with an [Instant][kotlin.time.Instant] in your code might require - * `@`[OptIn][OptIn]`(`[ExperimentalTime][kotlin.time.ExperimentalTime]`::class)`. + * interacting with an [`Instant`][kotlin.time.Instant] in your code might require + * `@`[`OptIn`][OptIn]`(`[`ExperimentalTime`][kotlin.time.ExperimentalTime]`::class)`. * In notebooks, add `-opt-in=kotlin.time.ExperimentalTime` to the compiler arguments. */ public class ParserOptions( @@ -584,7 +584,7 @@ public sealed class DateTimeParserOptions(public open val dateTimeFormats: Se * * If supplied to [ParserOptions.dateTime], * parsing will run in Kotlin time mode (similar to setting - * [DataFrame.parser.dateTimeLibrary][GlobalParserOptions.dateTimeLibrary] to [ParseDateTimeLibrary.KOTLIN]). + * [`DataFrame.parser.dateTimeLibrary`][GlobalParserOptions.dateTimeLibrary] to [ParseDateTimeLibrary.KOTLIN]). * * Additionally, if [dateTimeFormats] is not `null`, a.k.a. any format or pattern is provided, * parsing will use the provided formats __ONLY__. Default formats and those in the @@ -667,7 +667,7 @@ public sealed class DateTimeParserOptions(public open val dateTimeFormats: Se * * If supplied to [ParserOptions.dateTime], * parsing will run in Java time mode (similar to setting - * [DataFrame.parser.dateTimeLibrary][GlobalParserOptions.dateTimeLibrary] to [ParseDateTimeLibrary.JAVA]). + * [`DataFrame.parser.dateTimeLibrary`][GlobalParserOptions.dateTimeLibrary] to [ParseDateTimeLibrary.JAVA]). * * Additionally, if [dateTimeFormats] is not `null`, a.k.a. any formatter or pattern is provided, * parsing will use the provided formatters __ONLY__. Default formatters and those in the diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt index 6549f06f5c..d1ad1f326b 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt @@ -170,7 +170,7 @@ public typealias AddExpression = Selector, R> * This can be based on values from the same row in the original [DataFrame]. * * You can also use functions like [prev] and [next] to access other rows, and combine them with - * [newValue][AddDataRow.newValue] to reference values already computed in the new column. + * [`newValue`][AddDataRow.newValue] to reference values already computed in the new column. * For example, use `prev().newValue()` to access the new column value from the previous row. */ @ExcludeFromSources @@ -205,7 +205,7 @@ internal typealias AddExpressionDocs = Nothing * @param name name for a new column. * If it is empty, a unique column name will be generated. * Otherwise, it should be unique for original [DataFrame]. - * @param infer a value of [Infer] that specifies how to compute column [type][BaseColumn.type] for a new column. + * @param infer a value of [Infer] that specifies how to compute column [`type`][BaseColumn.type] for a new column. * Defaults to [Infer.Nulls]. * @param expression [AddExpression] that computes column value for every [DataRow] of a new column. * @return new [DataFrame] with added column. @@ -257,7 +257,7 @@ public inline fun DataFrame.add( * @param path Target [ColumnPath] for the new column. * If it points to a nested location, * intermediate columns will be created if necessary. - * @param infer A value of [Infer] that specifies how to compute the column [type][BaseColumn.type] for the new column. + * @param infer A value of [Infer] that specifies how to compute the column [`type`][BaseColumn.type] for the new column. * Defaults to [Infer.Nulls]. * @param expression An [AddExpression] that computes the column value for every [DataRow] of the new column. * @return A new [DataFrame] with the added column. @@ -450,7 +450,7 @@ public fun DataFrame.add(body: AddDsl.() -> Unit): DataFrame { * @param name name for a new column. * If it is empty, a unique column name will be generated. * Otherwise, it should be unique for original group [DataFrame]s. - * @param infer a value of [Infer] that specifies how to compute column [type][BaseColumn.type] for a new column. + * @param infer a value of [Infer] that specifies how to compute column [`type`][BaseColumn.type] for a new column. * Defaults to [Infer.Nulls]. * @param expression [AddExpression] that computes column value for every [DataRow] of a new column. * @return new [GroupBy] with added column. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt index ef30330125..d35b566453 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/all.kt @@ -169,11 +169,11 @@ public interface AllColumnsSelectionDsl { * * #### For example: * - * `df.`[select][DataFrame.select]` { `[{@get [FUNCTION]}][ColumnsSelectionDsl.{@get [FUNCTION]}]`("someColumn") }` + * `df.`[`select`][DataFrame.select]` { `[{@get [FUNCTION]}][ColumnsSelectionDsl.{@get [FUNCTION]}]`("someColumn") }` * - * `df.`[select][DataFrame.select]` { `[colGroup][ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[{@get [FUNCTION_COLS]}][SingleColumn.{@get [FUNCTION_COLS]}]`(someColumn) }` + * `df.`[`select`][DataFrame.select]` { `[`colGroup`][ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[{@get [FUNCTION_COLS]}][SingleColumn.{@get [FUNCTION_COLS]}]`(someColumn) }` * - * `df.`[select][DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().`[{@get [FUNCTION]}][ColumnSet.{@get [FUNCTION]}]`(Type::someColumn) }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>().`[{@get [FUNCTION]}][ColumnSet.{@get [FUNCTION]}]`(Type::someColumn) }` * * #### Examples for this overload: * @@ -224,9 +224,9 @@ public interface AllColumnsSelectionDsl { * ## All (Cols) * * Creates a new [ColumnSet] that contains all columns from [this\], - * the opposite of [none][ColumnsSelectionDsl.none]. + * the opposite of [`none`][ColumnsSelectionDsl.none]. * - * This makes the function equivalent to [cols()][ColumnsSelectionDsl.cols] without filter. + * This makes the function equivalent to [`cols()`][ColumnsSelectionDsl.cols] without filter. * * This function operates solely on columns at the top-level. * @@ -235,9 +235,9 @@ public interface AllColumnsSelectionDsl { * ### Check out: [Grammar] * * #### For example: - * `df.`[move][DataFrame.move]` { `[all][ColumnsSelectionDsl.all]`() }.`[under][MoveClause.under]`("info")` + * `df.`[`move`][DataFrame.move]` { `[`all`][ColumnsSelectionDsl.all]`() }.`[`under`][MoveClause.under]`("info")` * - * `df.`[select][DataFrame.select]` { myGroup.`[allCols][SingleColumn.allCols]`() }` + * `df.`[`select`][DataFrame.select]` { myGroup.`[`allCols`][SingleColumn.allCols]`() }` * * #### Examples for this overload: * @@ -264,7 +264,7 @@ public interface AllColumnsSelectionDsl { * @include [CommonAllDocs] * @set [CommonAllDocs.Examples] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { "a" in `[name][ColumnWithPath.name]` }.`[all][ColumnSet.all]`() }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { "a" in `[`name`][ColumnWithPath.name]` }.`[`all`][ColumnSet.all]`() }` * {@include [LineBreak]} * NOTE: This is an identity call and can be omitted in most cases. */ @@ -276,7 +276,7 @@ public interface AllColumnsSelectionDsl { * @include [CommonAllDocs] * @set [CommonAllDocs.Examples] * - * `df.`[select][DataFrame.select]` { `[all][ColumnsSelectionDsl.all]`() }` + * `df.`[`select`][DataFrame.select]` { `[`all`][ColumnsSelectionDsl.all]`() }` */ @Interpretable("All1") public fun ColumnsSelectionDsl<*>.all(): ColumnSet<*> = asSingleColumn().allColumnsInternal() @@ -285,7 +285,7 @@ public interface AllColumnsSelectionDsl { * @include [CommonAllDocs] * @set [CommonAllDocs.Examples] * - * `df.`[select][DataFrame.select]` { myGroup.`[allCols][SingleColumn.allCols]`() }` + * `df.`[`select`][DataFrame.select]` { myGroup.`[`allCols`][SingleColumn.allCols]`() }` */ @Interpretable("All2") public fun SingleColumn>.allCols(): ColumnSet<*> = ensureIsColumnGroup().allColumnsInternal() @@ -294,7 +294,7 @@ public interface AllColumnsSelectionDsl { * @include [CommonAllDocs] * @set [CommonAllDocs.Examples] * - * `df.`[select][DataFrame.select]` { "myGroupCol".`[allCols][String.allCols]`() }` + * `df.`[`select`][DataFrame.select]` { "myGroupCol".`[`allCols`][String.allCols]`() }` */ public fun String.allCols(): ColumnSet<*> = columnGroup(this).allCols() @@ -302,7 +302,7 @@ public interface AllColumnsSelectionDsl { * @include [CommonAllDocs] * @set [CommonAllDocs.Examples] * - * `df.`[select][DataFrame.select]` { DataSchemaType::columnGroup.`[allCols][KProperty.allCols]`() }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::columnGroup.`[`allCols`][KProperty.allCols]`() }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -312,7 +312,7 @@ public interface AllColumnsSelectionDsl { * @include [CommonAllDocs] * @set [CommonAllDocs.Examples] * - * `df.`[select][DataFrame.select]` { "pathTo"["myGroup"].`[allCols][ColumnPath.allCols]`() }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myGroup"].`[`allCols`][ColumnPath.allCols]`() }` */ public fun ColumnPath.allCols(): ColumnSet<*> = columnGroup(this).allCols() @@ -326,7 +326,7 @@ public interface AllColumnsSelectionDsl { * @set [CommonAllSubsetDocs.FUNCTION] allAfter * @set [CommonAllSubsetDocs.FUNCTION_COLS] allColsAfter * @set [CommonAllSubsetDocs.BEHAVIOR] after [column\], excluding [column\] itself - * @set [CommonAllSubsetDocs.COLUMN_DOES_NOT_EXIST] the function will return an empty [ColumnSet][ColumnSet] + * @set [CommonAllSubsetDocs.COLUMN_DOES_NOT_EXIST] the function will return an empty [`ColumnSet`][ColumnSet] * @param [column\] The specified column after which all columns should be taken. This column can be referenced * to both relatively to the current [ColumnsResolver] and absolutely. */ @@ -336,7 +336,7 @@ public interface AllColumnsSelectionDsl { * @include [AllAfterDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[allAfter][ColumnSet.allAfter]`{@get [ColumnSetAllAfterDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`allAfter`][ColumnSet.allAfter]`{@get [ColumnSetAllAfterDocs.Arg]} }` */ @ExcludeFromSources private interface ColumnSetAllAfterDocs { @@ -345,7 +345,7 @@ public interface AllColumnsSelectionDsl { typealias Arg = Nothing } - /** @include [ColumnSetAllAfterDocs] {@set [ColumnSetAllAfterDocs.Arg] \ \{ myColumn `[in][String.contains]` it.`[name][ColumnWithPath.name]` \}} */ + /** @include [ColumnSetAllAfterDocs] {@set [ColumnSetAllAfterDocs.Arg] \ \{ myColumn `[`in`][String.contains]` it.`[`name`][ColumnWithPath.name]` \}} */ @Suppress("UNCHECKED_CAST") public fun ColumnSet.allAfter(column: (ColumnWithPath) -> Boolean): ColumnSet = allAfterInternal(column as ColumnFilter<*>) as ColumnSet @@ -372,7 +372,7 @@ public interface AllColumnsSelectionDsl { * @include [AllAfterDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[allAfter][ColumnsSelectionDsl.allAfter]`{@get [ColumnsSelectionDslAllAfterDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { `[`allAfter`][ColumnsSelectionDsl.allAfter]`{@get [ColumnsSelectionDslAllAfterDocs.Arg]} }` */ @ExcludeFromSources private interface ColumnsSelectionDslAllAfterDocs { @@ -406,7 +406,7 @@ public interface AllColumnsSelectionDsl { * @include [AllAfterDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { someColumnGroup.`[allColsAfter][SingleColumn.allColsAfter]`{@get [SingleColumnAllAfterDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { someColumnGroup.`[`allColsAfter`][SingleColumn.allColsAfter]`{@get [SingleColumnAllAfterDocs.Arg]} }` */ @ExcludeFromSources private interface SingleColumnAllAfterDocs { @@ -453,7 +453,7 @@ public interface AllColumnsSelectionDsl { * @include [AllAfterDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "someColGroup".`[allColsAfter][String.allColsAfter]`{@get [StringAllAfterDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { "someColGroup".`[`allColsAfter`][String.allColsAfter]`{@get [StringAllAfterDocs.Arg]} }` */ @ExcludeFromSources private interface StringAllAfterDocs { @@ -483,7 +483,7 @@ public interface AllColumnsSelectionDsl { * @include [AllAfterDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColGroup.`[allColsAfter][KProperty.allColsAfter]`{@get [KPropertyAllAfterDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColGroup.`[`allColsAfter`][KProperty.allColsAfter]`{@get [KPropertyAllAfterDocs.Arg]} }` */ @ExcludeFromSources private interface KPropertyAllAfterDocs { @@ -525,7 +525,7 @@ public interface AllColumnsSelectionDsl { * @include [AllAfterDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["someColGroup"].`[allColsAfter][ColumnPath.allColsAfter]`{@get [ColumnPathAllAfterDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["someColGroup"].`[`allColsAfter`][ColumnPath.allColsAfter]`{@get [ColumnPathAllAfterDocs.Arg]} }` */ @ExcludeFromSources private interface ColumnPathAllAfterDocs { @@ -563,7 +563,7 @@ public interface AllColumnsSelectionDsl { * @set [CommonAllSubsetDocs.FUNCTION] allFrom * @set [CommonAllSubsetDocs.FUNCTION_COLS] allColsFrom * @set [CommonAllSubsetDocs.BEHAVIOR] from [column\], including [column\] itself - * @set [CommonAllSubsetDocs.COLUMN_DOES_NOT_EXIST] the function will return an empty [ColumnSet][ColumnSet] + * @set [CommonAllSubsetDocs.COLUMN_DOES_NOT_EXIST] the function will return an empty [`ColumnSet`][ColumnSet] * @param [column\] The specified column from which all columns should be taken. This column can be referenced * to both relatively to the current [ColumnsResolver] and absolutely. */ @@ -573,7 +573,7 @@ public interface AllColumnsSelectionDsl { * @include [AllFromDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[allFrom][ColumnSet.allFrom]`{@get [ColumnSetAllFromDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`allFrom`][ColumnSet.allFrom]`{@get [ColumnSetAllFromDocs.Arg]} }` */ @ExcludeFromSources private interface ColumnSetAllFromDocs { @@ -582,7 +582,7 @@ public interface AllColumnsSelectionDsl { typealias Arg = Nothing } - /** @include [ColumnSetAllFromDocs] {@set [ColumnSetAllFromDocs.Arg] \ \{ myColumn `[in][String.contains]` it.`[name][ColumnWithPath.name]` \}} */ + /** @include [ColumnSetAllFromDocs] {@set [ColumnSetAllFromDocs.Arg] \ \{ myColumn `[`in`][String.contains]` it.`[`name`][ColumnWithPath.name]` \}} */ @Suppress("UNCHECKED_CAST") public fun ColumnSet.allFrom(column: (ColumnWithPath) -> Boolean): ColumnSet = allFromInternal(column as ColumnFilter<*>) as ColumnSet @@ -608,7 +608,7 @@ public interface AllColumnsSelectionDsl { * @include [AllFromDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[allFrom][ColumnsSelectionDsl.allFrom]`{@get [ColumnsSelectionDslAllFromDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { `[`allFrom`][ColumnsSelectionDsl.allFrom]`{@get [ColumnsSelectionDslAllFromDocs.Arg]} }` */ @ExcludeFromSources private interface ColumnsSelectionDslAllFromDocs { @@ -642,7 +642,7 @@ public interface AllColumnsSelectionDsl { * @include [AllFromDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { someColumnGroup.`[allColsFrom][SingleColumn.allColsFrom]`{@get [SingleColumnAllFromDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { someColumnGroup.`[`allColsFrom`][SingleColumn.allColsFrom]`{@get [SingleColumnAllFromDocs.Arg]} }` */ @ExcludeFromSources private interface SingleColumnAllFromDocs { @@ -689,7 +689,7 @@ public interface AllColumnsSelectionDsl { * @include [AllFromDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "someColGroup".`[allColsFrom][String.allColsFrom]`{@get [StringAllFromDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { "someColGroup".`[`allColsFrom`][String.allColsFrom]`{@get [StringAllFromDocs.Arg]} }` */ @ExcludeFromSources private interface StringAllFromDocs { @@ -719,7 +719,7 @@ public interface AllColumnsSelectionDsl { * @include [AllFromDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { DataSchemaType::someColGroup.`[allColsFrom][KProperty.allColsFrom]`{@get [KPropertyAllFromDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::someColGroup.`[`allColsFrom`][KProperty.allColsFrom]`{@get [KPropertyAllFromDocs.Arg]} }` */ @ExcludeFromSources private interface KPropertyAllFromDocs { @@ -761,7 +761,7 @@ public interface AllColumnsSelectionDsl { * @include [AllFromDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["someColGroup"].`[allFrom][ColumnPath.allColsFrom]`{@get [ColumnPathAllFromDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["someColGroup"].`[`allFrom`][ColumnPath.allColsFrom]`{@get [ColumnPathAllFromDocs.Arg]} }` */ @ExcludeFromSources private interface ColumnPathAllFromDocs { @@ -798,7 +798,7 @@ public interface AllColumnsSelectionDsl { * @set [CommonAllSubsetDocs.FUNCTION] allBefore * @set [CommonAllSubsetDocs.FUNCTION_COLS] allColsBefore * @set [CommonAllSubsetDocs.BEHAVIOR] before [column\], excluding [column\] itself - * @set [CommonAllSubsetDocs.COLUMN_DOES_NOT_EXIST] the function will return a [ColumnSet][ColumnSet] containing all columns + * @set [CommonAllSubsetDocs.COLUMN_DOES_NOT_EXIST] the function will return a [`ColumnSet`][ColumnSet] containing all columns * @param [column\] The specified column before which all columns should be taken. This column can be referenced * to both relatively to the current [ColumnsResolver] and absolutely. */ @@ -808,7 +808,7 @@ public interface AllColumnsSelectionDsl { * @include [AllBeforeDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[allBefore][ColumnSet.allBefore]`{@get [ColumnSetAllBeforeDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`allBefore`][ColumnSet.allBefore]`{@get [ColumnSetAllBeforeDocs.Arg]} }` */ @ExcludeFromSources private interface ColumnSetAllBeforeDocs { @@ -817,7 +817,7 @@ public interface AllColumnsSelectionDsl { typealias Arg = Nothing } - /** @include [ColumnSetAllBeforeDocs] {@set [ColumnSetAllBeforeDocs.Arg] \ \{ myColumn `[in][String.contains]` it.`[name][ColumnWithPath.name]` \}} */ + /** @include [ColumnSetAllBeforeDocs] {@set [ColumnSetAllBeforeDocs.Arg] \ \{ myColumn `[`in`][String.contains]` it.`[`name`][ColumnWithPath.name]` \}} */ @Suppress("UNCHECKED_CAST") public fun ColumnSet.allBefore(column: (ColumnWithPath) -> Boolean): ColumnSet = allBeforeInternal(column as ColumnFilter<*>) as ColumnSet @@ -844,7 +844,7 @@ public interface AllColumnsSelectionDsl { * @include [AllBeforeDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[allBefore][ColumnsSelectionDsl.allBefore]`{@get [ColumnsSelectionDslAllBeforeDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { `[`allBefore`][ColumnsSelectionDsl.allBefore]`{@get [ColumnsSelectionDslAllBeforeDocs.Arg]} }` */ @ExcludeFromSources private interface ColumnsSelectionDslAllBeforeDocs { @@ -879,7 +879,7 @@ public interface AllColumnsSelectionDsl { * @include [AllBeforeDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { someColumnGroup.`[allColsBefore][SingleColumn.allColsBefore]`{@get [SingleColumnAllBeforeDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { someColumnGroup.`[`allColsBefore`][SingleColumn.allColsBefore]`{@get [SingleColumnAllBeforeDocs.Arg]} }` */ @ExcludeFromSources private interface SingleColumnAllBeforeDocs { @@ -923,7 +923,7 @@ public interface AllColumnsSelectionDsl { * @include [AllBeforeDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "someColGroup".`[allColsBefore][String.allColsBefore]`{@get [StringAllBeforeDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { "someColGroup".`[`allColsBefore`][String.allColsBefore]`{@get [StringAllBeforeDocs.Arg]} }` */ @ExcludeFromSources private interface StringAllBeforeDocs { @@ -954,7 +954,7 @@ public interface AllColumnsSelectionDsl { * @include [AllBeforeDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { DataSchemaType::someColGroup.`[allColsBefore][KProperty.allColsBefore]`{@get [KPropertyAllBeforeDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::someColGroup.`[`allColsBefore`][KProperty.allColsBefore]`{@get [KPropertyAllBeforeDocs.Arg]} }` */ @ExcludeFromSources private interface KPropertyAllBeforeDocs { @@ -996,7 +996,7 @@ public interface AllColumnsSelectionDsl { * @include [AllBeforeDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["someColGroup"].`[allColsBefore][ColumnPath.allColsBefore]`{@get [ColumnPathAllBeforeDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["someColGroup"].`[`allColsBefore`][ColumnPath.allColsBefore]`{@get [ColumnPathAllBeforeDocs.Arg]} }` */ @ExcludeFromSources private interface ColumnPathAllBeforeDocs { @@ -1034,7 +1034,7 @@ public interface AllColumnsSelectionDsl { * @set [CommonAllSubsetDocs.FUNCTION] allUpTo * @set [CommonAllSubsetDocs.FUNCTION_COLS] allColsUpTo * @set [CommonAllSubsetDocs.BEHAVIOR] up to [column\], including [column\] itself - * @set [CommonAllSubsetDocs.COLUMN_DOES_NOT_EXIST] the function will return a [ColumnSet][ColumnSet] containing all columns + * @set [CommonAllSubsetDocs.COLUMN_DOES_NOT_EXIST] the function will return a [`ColumnSet`][ColumnSet] containing all columns * @param [column\] The specified column up to which all columns should be taken. This column can be referenced * to both relatively to the current [ColumnsResolver] and absolutely. */ @@ -1044,7 +1044,7 @@ public interface AllColumnsSelectionDsl { * @include [AllUpToDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[allUpTo][ColumnSet.allUpTo]`{@get [ColumnSetAllUpToDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`allUpTo`][ColumnSet.allUpTo]`{@get [ColumnSetAllUpToDocs.Arg]} }` */ @ExcludeFromSources private interface ColumnSetAllUpToDocs { @@ -1053,7 +1053,7 @@ public interface AllColumnsSelectionDsl { typealias Arg = Nothing } - /** @include [ColumnSetAllUpToDocs] {@set [ColumnSetAllUpToDocs.Arg] \ \{ myColumn `[in][String.contains]` it.`[name][ColumnWithPath.name]` \}} */ + /** @include [ColumnSetAllUpToDocs] {@set [ColumnSetAllUpToDocs.Arg] \ \{ myColumn `[`in`][String.contains]` it.`[`name`][ColumnWithPath.name]` \}} */ @Suppress("UNCHECKED_CAST") public fun ColumnSet.allUpTo(column: (ColumnWithPath) -> Boolean): ColumnSet = allUpToInternal(column as ColumnFilter<*>) as ColumnSet @@ -1079,7 +1079,7 @@ public interface AllColumnsSelectionDsl { * @include [AllUpToDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[allUpTo][ColumnsSelectionDsl.allColsUpTo]`{@get [ColumnsSelectionDslAllUpToDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { `[`allUpTo`][ColumnsSelectionDsl.allColsUpTo]`{@get [ColumnsSelectionDslAllUpToDocs.Arg]} }` */ @ExcludeFromSources private interface ColumnsSelectionDslAllUpToDocs { @@ -1113,7 +1113,7 @@ public interface AllColumnsSelectionDsl { * @include [AllUpToDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { someColumnGroup.`[allColsUpTo][SingleColumn.allColsUpTo]`{@get [SingleColumnAllUpToDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { someColumnGroup.`[`allColsUpTo`][SingleColumn.allColsUpTo]`{@get [SingleColumnAllUpToDocs.Arg]} }` */ @ExcludeFromSources private interface SingleColumnAllUpToDocs { @@ -1160,7 +1160,7 @@ public interface AllColumnsSelectionDsl { * @include [AllUpToDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "someColGroup".`[allColsUpTo][String.allColsUpTo]`{@get [StringAllUpToDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { "someColGroup".`[`allColsUpTo`][String.allColsUpTo]`{@get [StringAllUpToDocs.Arg]} }` */ @ExcludeFromSources private interface StringAllUpToDocs { @@ -1190,7 +1190,7 @@ public interface AllColumnsSelectionDsl { * @include [AllUpToDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { DataSchemaType::someColGroup.`[allColsUpTo][KProperty.allColsUpTo]`{@get [KPropertyAllUpToDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::someColGroup.`[`allColsUpTo`][KProperty.allColsUpTo]`{@get [KPropertyAllUpToDocs.Arg]} }` */ @ExcludeFromSources private interface KPropertyAllUpToDocs { @@ -1232,7 +1232,7 @@ public interface AllColumnsSelectionDsl { * @include [AllUpToDocs] * @set [CommonAllSubsetDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["someColGroup"].`[allColsUpTo][ColumnPath.allColsUpTo]`{@get [ColumnPathAllUpToDocs.Arg]} }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["someColGroup"].`[`allColsUpTo`][ColumnPath.allColsUpTo]`{@get [ColumnPathAllUpToDocs.Arg]} }` */ @ExcludeFromSources private interface ColumnPathAllUpToDocs { @@ -1264,7 +1264,7 @@ public interface AllColumnsSelectionDsl { /** * If [this] is a [SingleColumn] containing a single [ColumnGroup] - * (like [SingleColumn][SingleColumn]`<`[AnyRow][AnyRow]`>` or [ColumnsSelectionDsl][ColumnsSelectionDsl]), it + * (like [`SingleColumn`][SingleColumn]`<`[`AnyRow`][AnyRow]`>` or [`ColumnsSelectionDsl`][ColumnsSelectionDsl]), it * returns a [(transformable) ColumnSet][TransformableColumnSet] containing the children of this [ColumnGroup], * else it simply returns a [(transformable) ColumnSet][TransformableColumnSet] from [this] * (like when [this] is a [ColumnSet]). diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt index 7a7f1c9248..8bb69b28ad 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/allExcept.kt @@ -1,6 +1,7 @@ package org.jetbrains.kotlinx.dataframe.api import org.jetbrains.kotlinx.dataframe.ColumnsSelector +import org.jetbrains.kotlinx.dataframe.DataColumn import org.jetbrains.kotlinx.dataframe.DataFrame import org.jetbrains.kotlinx.dataframe.DataRow import org.jetbrains.kotlinx.dataframe.annotations.AccessApiOverload @@ -113,16 +114,16 @@ public interface AllExceptColumnsSelectionDsl { * * We can do: * - * `df.`[select][DataFrame.select]` { `[colsOf][colsOf]`<`[Int][Int]`>() `[except][ColumnSet.except]` (age `[and][ColumnsSelectionDsl.and]` height) }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][colsOf]`<`[`Int`][Int]`>() `[`except`][ColumnSet.except]` (age `[`and`][ColumnsSelectionDsl.and]` height) }` * - * which will 'subtract' the [ColumnSet] created by `age `[and][ColumnsSelectionDsl.and]` height` from the [ColumnSet] created by [colsOf][colsOf]`<`[Int][Int]`>()`. + * which will 'subtract' the [ColumnSet] created by `age `[`and`][ColumnsSelectionDsl.and]` height` from the [ColumnSet] created by [`colsOf`][colsOf]`<`[`Int`][Int]`>()`. * * {@include [LineBreak]} * This operation can also be used to exclude columns from [Column Groups][ColumnGroup]. * * For instance: * - * `df.`[select][DataFrame.select]` { `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]` { "a" `[in][String.contains]` it.`[name][DataColumn.name]`() } `[except][ColumnSet.except]` userData.age }` + * `df.`[`select`][DataFrame.select]` { `[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]` { "a" `[`in`][String.contains]` it.`[`name`][DataColumn.name]`() } `[`except`][ColumnSet.except]` userData.age }` * {@include [LineBreak]} * * Note that the selection of columns to exclude from [column sets][ColumnSet] is always done relative to the outer @@ -132,17 +133,17 @@ public interface AllExceptColumnsSelectionDsl { * each time it is encountered (including inside [ColumnGroups][ColumnGroup]). You could say the receiver [ColumnSet] * is [simplified][ColumnsSelectionDsl.simplify] before the operation is performed: * - * [cols][ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[except][ColumnSet.except]`(a.b)` + * [`cols`][ColumnsSelectionDsl.cols]`(a, a, a.b, a.b).`[`except`][ColumnSet.except]`(a.b)` * - * `== `[cols][ColumnsSelectionDsl.cols]`(a).`[except][ColumnSet.except]`(a.b)` + * `== `[`cols`][ColumnsSelectionDsl.cols]`(a).`[`except`][ColumnSet.except]`(a.b)` * - * ### In the [ColumnsSelectionDsl][ColumnsSelectionDsl] - * Instead of having to write [all][ColumnsSelectionDsl.all]`() `[except][ColumnsSelectionDsl.except]` { ... }` in the DSL, - * you can use [allExcept][ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result. + * ### In the [`ColumnsSelectionDsl`][ColumnsSelectionDsl] + * Instead of having to write [`all`][ColumnsSelectionDsl.all]`() `[`except`][ColumnsSelectionDsl.except]` { ... }` in the DSL, + * you can use [`allExcept`][ColumnsSelectionDsl.allExcept]` { ... }` to achieve the same result. * * For example: * - * `df.`[select][DataFrame.select]` { `[allExcept][ColumnsSelectionDsl.allExcept]` { userData.age `[and][ColumnsSelectionDsl.and]` height } }` + * `df.`[`select`][DataFrame.select]` { `[`allExcept`][ColumnsSelectionDsl.allExcept]` { userData.age `[`and`][ColumnsSelectionDsl.and]` height } }` * * ### On [ColumnGroups][ColumnGroup]: All Cols Except * The variant of this function on [ColumnGroups][ColumnGroup] is a bit different as it changes the scope relative to @@ -150,31 +151,31 @@ public interface AllExceptColumnsSelectionDsl { * {@include [LineBreak]} * In other words: * - * `df.`[select][DataFrame.select]` { myColGroup.`[allColsExcept][SingleColumn.allColsExcept]` { colA `[and][ColumnsSelectionDsl.and]` colB } }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`allColsExcept`][SingleColumn.allColsExcept]` { colA `[`and`][ColumnsSelectionDsl.and]` colB } }` * * is shorthand for * - * `df.`[select][DataFrame.select]` { myColGroup.`[select][ColumnsSelectionDsl.select]` { `[all][ColumnsSelectionDsl.all]`() `[except][ColumnSet.except]` { colA `[and][ColumnsSelectionDsl.and]` colB } } }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`select`][ColumnsSelectionDsl.select]` { `[`all`][ColumnsSelectionDsl.all]`() `[`except`][ColumnSet.except]` { colA `[`and`][ColumnsSelectionDsl.and]` colB } } }` * * or * - * `df.`[select][DataFrame.select]` { myColGroup.`[allCols][ColumnsSelectionDsl.allCols]`() `[except][ColumnSet.except]` { myColGroup.colA `[and][ColumnsSelectionDsl.and]` myColGroup.colB } }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`allCols`][ColumnsSelectionDsl.allCols]`() `[`except`][ColumnSet.except]` { myColGroup.colA `[`and`][ColumnsSelectionDsl.and]` myColGroup.colB } }` * {@include [LineBreak]} - * Also note the name change, similar to [allCols][ColumnsSelectionDsl.allCols], this makes it clearer that you're selecting + * Also note the name change, similar to [`allCols`][ColumnsSelectionDsl.allCols], this makes it clearer that you're selecting * columns inside the group, 'lifting' them out. * * ### On [ColumnGroups][ColumnGroup]: Except * This variant can be used to exclude some nested columns from a [ColumnGroup] in the selection. - * In contrast to [allColsExcept][ColumnsSelectionDsl.allColsExcept], + * In contrast to [`allColsExcept`][ColumnsSelectionDsl.allColsExcept], * this function does not 'lift' the columns out of the group, preserving the structure. * * So: * - * `df.`[select][DataFrame.select]` { colGroup.`[except][SingleColumn.except]` { col } }` + * `df.`[`select`][DataFrame.select]` { colGroup.`[`except`][SingleColumn.except]` { col } }` * * is shorthand for: * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]`(colGroup) `[except][ColumnSet.except]` colGroup.col }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]`(colGroup) `[`except`][ColumnSet.except]` colGroup.col }` * * ### Examples for this overload * {@get [EXAMPLE]} @@ -203,9 +204,9 @@ public interface AllExceptColumnsSelectionDsl { /** * @include [CommonExceptDocs] * {@set [CommonExceptDocs.EXAMPLE] - * `df.`[select][ColumnsSelectionDsl.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Number][Number]`>() `[except][ColumnSet.except]` {@get [ARGUMENT_1]} \}` + * `df.`[`select`][ColumnsSelectionDsl.select]` { `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Number`][Number]`>() `[`except`][ColumnSet.except]` {@get [ARGUMENT_1]} \}` * - * `df.`[select][ColumnsSelectionDsl.select]` { `[cols][ColumnsSelectionDsl.cols]`(name, age) `[except][ColumnSet.except]` {@get [ARGUMENT_2]} \}` + * `df.`[`select`][ColumnsSelectionDsl.select]` { `[`cols`][ColumnsSelectionDsl.cols]`(name, age) `[`except`][ColumnSet.except]` {@get [ARGUMENT_2]} \}` * } */ @ExcludeFromSources @@ -221,9 +222,9 @@ public interface AllExceptColumnsSelectionDsl { /** * @include [CommonExceptDocs] * {@set [CommonExceptDocs.EXAMPLE] - * `df.`[select][ColumnsSelectionDsl.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Number][Number]`>().`[except][ColumnSet.except]`{@get [ARGUMENT_1]} \}` + * `df.`[`select`][ColumnsSelectionDsl.select]` { `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Number`][Number]`>().`[`except`][ColumnSet.except]`{@get [ARGUMENT_1]} \}` * - * `df.`[select][ColumnsSelectionDsl.select]` { `[cols][ColumnsSelectionDsl.cols]`(name, age).`[except][ColumnSet.except]`{@get [ARGUMENT_2]} \}` + * `df.`[`select`][ColumnsSelectionDsl.select]` { `[`cols`][ColumnsSelectionDsl.cols]`(name, age).`[`except`][ColumnSet.except]`{@get [ARGUMENT_2]} \}` * } */ @ExcludeFromSources @@ -240,7 +241,7 @@ public interface AllExceptColumnsSelectionDsl { * @include [ColumnSetInfixDocs] * @set [CommonExceptDocs.PARAM] @param [selector\] A lambda in which you specify the columns that need to be * excluded from the [ColumnSet]. The scope of the selector is the same as the outer scope. - * @set [ColumnSetInfixDocs.ARGUMENT_1] { "age" `[and][ColumnsSelectionDsl.and]` height } + * @set [ColumnSetInfixDocs.ARGUMENT_1] { "age" `[`and`][ColumnsSelectionDsl.and]` height } * @set [ColumnSetInfixDocs.ARGUMENT_2] { name.firstName } */ @Interpretable("ColumnSetExceptSelector") @@ -250,7 +251,7 @@ public interface AllExceptColumnsSelectionDsl { * @include [ColumnSetInfixDocs] * @set [CommonExceptDocs.PARAM] @param [other\] A [ColumnsResolver] containing the columns that need to be * excluded from the [ColumnSet]. - * @set [ColumnSetInfixDocs.ARGUMENT_1] "age" `[and][ColumnsSelectionDsl.and]` height + * @set [ColumnSetInfixDocs.ARGUMENT_1] "age" `[`and`][ColumnsSelectionDsl.and]` height * @set [ColumnSetInfixDocs.ARGUMENT_2] name.firstName */ @Interpretable("ColumnSetExceptColumnsResolver") @@ -335,9 +336,9 @@ public interface AllExceptColumnsSelectionDsl { /** * @include [CommonExceptDocs] * @set [CommonExceptDocs.EXAMPLE] - * `df.`[select][ColumnsSelectionDsl.select]` { `[allExcept][ColumnsSelectionDsl.allExcept]{@get [ARGUMENT_1]}` \}` + * `df.`[`select`][ColumnsSelectionDsl.select]` { `[`allExcept`][ColumnsSelectionDsl.allExcept]{@get [ARGUMENT_1]}` \}` * - * `df.`[select][ColumnsSelectionDsl.select]` { `[allExcept][ColumnsSelectionDsl.allExcept]{@get [ARGUMENT_2]}` \}` + * `df.`[`select`][ColumnsSelectionDsl.select]` { `[`allExcept`][ColumnsSelectionDsl.allExcept]{@get [ARGUMENT_2]}` \}` */ @ExcludeFromSources private interface ColumnsSelectionDslDocs { @@ -353,7 +354,7 @@ public interface AllExceptColumnsSelectionDsl { * @include [ColumnsSelectionDslDocs] * @set [CommonExceptDocs.PARAM] @param [selector\] A lambda in which you specify the columns that need to be * excluded from the current selection. The scope of the selector is the same as the outer scope. - * @set [ColumnsSelectionDslDocs.ARGUMENT_1] ` { "age" `[and][ColumnsSelectionDsl.and]` height }` + * @set [ColumnsSelectionDslDocs.ARGUMENT_1] ` { "age" `[`and`][ColumnsSelectionDsl.and]` height }` * @set [ColumnsSelectionDslDocs.ARGUMENT_2] ` { name.firstName }` */ @Interpretable("CSDslAllExceptSelector") @@ -414,9 +415,9 @@ public interface AllExceptColumnsSelectionDsl { /** * @include [CommonExceptDocs] * @set [CommonExceptDocs.EXAMPLE] {@comment blocks are there to prevent double ``} - * `df.`[select][ColumnsSelectionDsl.select]` { `{@get [RECEIVER_1]}[allColsExcept][{@get [RECEIVER_TYPE]}.allColsExcept]{@get [ARGUMENT_1]}` \}` + * `df.`[`select`][ColumnsSelectionDsl.select]` { `{@get [RECEIVER_1]}[`allColsExcept`][{@get [RECEIVER_TYPE]}.allColsExcept]{@get [ARGUMENT_1]}` \}` * - * `df.`[select][ColumnsSelectionDsl.select]` { city `[and][ColumnsSelectionDsl.and]` `{@get [RECEIVER_2]}[allColsExcept][{@get [RECEIVER_TYPE]}.allColsExcept]{@get [ARGUMENT_2]}` \}` + * `df.`[`select`][ColumnsSelectionDsl.select]` { city `[`and`][ColumnsSelectionDsl.and]` `{@get [RECEIVER_2]}[`allColsExcept`][{@get [RECEIVER_TYPE]}.allColsExcept]{@get [ARGUMENT_2]}` \}` */ @Suppress("ClassName") @ExcludeFromSources @@ -469,7 +470,7 @@ public interface AllExceptColumnsSelectionDsl { * @set [CommonExceptDocs.PARAM] @param [selector\] A lambda in which you specify the columns that need to be * excluded from the current selection in [this\] column group. The other columns will be included in the selection * by default. The scope of the selector is relative to the column group. - * @set [ColumnGroupDocs.ARGUMENT_1] ` { "age" `[and][ColumnsSelectionDsl.and]` height }` + * @set [ColumnGroupDocs.ARGUMENT_1] ` { "age" `[`and`][ColumnsSelectionDsl.and]` height }` * @set [ColumnGroupDocs.ARGUMENT_2] ` { firstName }` */ typealias SelectorArgs = Nothing @@ -562,9 +563,9 @@ public interface AllExceptColumnsSelectionDsl { /** * @include [CommonExceptDocs] * @set [CommonExceptDocs.EXAMPLE] {@comment blocks are there to prevent double ``} - * `df.`[select][ColumnsSelectionDsl.select]` { `{@get [RECEIVER_1]}[except][{@get [RECEIVER_TYPE]}.except]{@get [ARGUMENT_1]}` \}` + * `df.`[`select`][ColumnsSelectionDsl.select]` { `{@get [RECEIVER_1]}[`except`][{@get [RECEIVER_TYPE]}.except]{@get [ARGUMENT_1]}` \}` * - * `df.`[select][ColumnsSelectionDsl.select]` { city `[and][ColumnsSelectionDsl.and]` `{@get [RECEIVER_2]}[except][{@get [RECEIVER_TYPE]}.except]{@get [ARGUMENT_2]}` \}` + * `df.`[`select`][ColumnsSelectionDsl.select]` { city `[`and`][ColumnsSelectionDsl.and]` `{@get [RECEIVER_2]}[`except`][{@get [RECEIVER_TYPE]}.except]{@get [ARGUMENT_2]}` \}` */ @ExcludeFromSources private interface ColumnGroupExceptDocs : ColumnGroupDocs diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/and.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/and.kt index b5b9da6a0c..980e2f09f4 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/and.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/and.kt @@ -106,7 +106,7 @@ public interface AndColumnsSelectionDsl { * @include [CommonAndDocs] * @set [CommonAndDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { ... } `[`and`][ColumnsResolver.and]` `{@get [ColumnsResolverAndDocs.Argument]}` }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { ... } `[`and`][ColumnsResolver.and]` `{@get [ColumnsResolverAndDocs.Argument]}` }` */ private interface ColumnsResolverAndDocs { @@ -136,7 +136,7 @@ public interface AndColumnsSelectionDsl { * @include [CommonAndDocs] * @set [CommonAndDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "colA" `[`and`][String.and]` `{@get [StringAndDocs.Argument]}` }` + * `df.`[`select`][DataFrame.select]` { "colA" `[`and`][String.and]` `{@get [StringAndDocs.Argument]}` }` */ private interface StringAndDocs { @@ -165,7 +165,7 @@ public interface AndColumnsSelectionDsl { * @include [CommonAndDocs] * @set [CommonAndDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { Type::colA `[`and`][KProperty.and]` `{@get [KPropertyAndDocs.Argument]}` }` + * `df.`[`select`][DataFrame.select]` { Type::colA `[`and`][KProperty.and]` `{@get [KPropertyAndDocs.Argument]}` }` */ private interface KPropertyAndDocs { @@ -177,7 +177,7 @@ public interface AndColumnsSelectionDsl { @AccessApiOverload public infix fun KProperty.and(other: ColumnsResolver): ColumnSet = toColumnAccessor() and other - /** @include [KPropertyAndDocs] {@set [KPropertyAndDocs.Argument] `{ colA `[/][DataColumn.div]` 2.0 `[`named`][ColumnReference.named]` "half colA" \}`} */ + /** @include [KPropertyAndDocs] {@set [KPropertyAndDocs.Argument] `{ colA `[`/`][DataColumn.div]` 2.0 `[`named`][ColumnReference.named]` "half colA" \}`} */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload public infix fun KProperty.and(other: () -> ColumnsResolver): ColumnSet = diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt index 4e40785651..420eeca49a 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/col.kt @@ -92,20 +92,20 @@ public interface ColColumnsSelectionDsl { * * #### For example: * - * `df.`[select][DataFrame.select]` { `[col][col]`<`[String][String]`>("colA") }` + * `df.`[`select`][DataFrame.select]` { `[`col`][col]`<`[`String`][String]`>("colA") }` * - * `df.`[select][DataFrame.select]` { `[col][col]`(SomeType::colB) }` + * `df.`[`select`][DataFrame.select]` { `[`col`][col]`(SomeType::colB) }` * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[col][col]`(1) }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`col`][col]`(1) }` * * #### Examples for this overload: * * $[CommonColDocs.EXAMPLE] * * To create a [ColumnAccessor] for a specific kind of column with runtime checks, take a look at the functions - * [valueCol][ColumnsSelectionDsl.valueCol], - * [colGroup][ColumnsSelectionDsl.colGroup], - * and [frameCol][ColumnsSelectionDsl.frameCol]. + * [`valueCol`][ColumnsSelectionDsl.valueCol], + * [`colGroup`][ColumnsSelectionDsl.colGroup], + * and [`frameCol`][ColumnsSelectionDsl.frameCol]. * * @return A [ColumnAccessor] for the column with the given argument if possible, else a [SingleColumn]. * @throws [IllegalStateException\] if the column with the given argument does not exist. @@ -122,14 +122,14 @@ public interface ColColumnsSelectionDsl { typealias EXAMPLE = Nothing /** - * `df.`[select][DataFrame.select]` { $[CommonColDocs.RECEIVER]`[col][col]`($[CommonColDocs.ARG]) \}` + * `df.`[`select`][DataFrame.select]` { $[CommonColDocs.RECEIVER]`[`col`][col]`($[CommonColDocs.ARG]) \}` */ typealias SingleExample = Nothing /** - * `df.`[select][DataFrame.select]` { $[CommonColDocs.RECEIVER]`[col][col]`($[CommonColDocs.ARG]) \}` + * `df.`[`select`][DataFrame.select]` { $[CommonColDocs.RECEIVER]`[`col`][col]`($[CommonColDocs.ARG]) \}` * - * `df.`[select][DataFrame.select]` { $[CommonColDocs.RECEIVER]`[col][col]`<`[String][String]`>($[CommonColDocs.ARG]) \}` + * `df.`[`select`][DataFrame.select]` { $[CommonColDocs.RECEIVER]`[`col`][col]`<`[`String`][String]`>($[CommonColDocs.ARG]) \}` */ typealias DoubleExample = Nothing @@ -497,24 +497,24 @@ public interface ColColumnsSelectionDsl { private typealias ColIndexDocs = Nothing /** - * @include [ColIndexDocs] {@set [CommonColDocs.RECEIVER] `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().} + * @include [ColIndexDocs] {@set [CommonColDocs.RECEIVER] `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>().} * @include [CommonColDocs.ColumnTypeParam] * {@set [CommonColDocs.EXAMPLE] * {@include [CommonColDocs.SingleExample]} * - * `df.`[select][DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][col]`1`[`]`][col]` \}` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][col]`1`[`]`][col]` \}` * } * {@set [CommonColDocs.NOTE] NOTE: You can use the get-[] operator on [ColumnSets][ColumnSet] as well!} */ public fun ColumnSet.col(index: Int): SingleColumn = getAt(index) /** - * @include [ColIndexDocs] {@set [CommonColDocs.RECEIVER] `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().} + * @include [ColIndexDocs] {@set [CommonColDocs.RECEIVER] `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>().} * @include [CommonColDocs.ColumnTypeParam] * {@set [CommonColDocs.EXAMPLE] * {@include [CommonColDocs.SingleExample]} * - * `df.`[select][DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[String][String]`>()`[`[`][col]`1`[`]`][col]` \}` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`String`][String]`>()`[`[`][col]`1`[`]`][col]` \}` * } */ public operator fun ColumnSet.get(index: Int): SingleColumn = col(index) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt index 0445ce45b2..92d03252c5 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroup.kt @@ -92,20 +92,20 @@ public interface ColGroupColumnsSelectionDsl { * * #### For example: * - * `df.`[select][DataFrame.select]` { `[colGroup][colGroup]`<`[String][String]`>("colGroupA") }` + * `df.`[`select`][DataFrame.select]` { `[`colGroup`][colGroup]`<`[`String`][String]`>("colGroupA") }` * - * `df.`[select][DataFrame.select]` { `[colGroup][colGroup]`(SomeType::colGroupB) }` + * `df.`[`select`][DataFrame.select]` { `[`colGroup`][colGroup]`(SomeType::colGroupB) }` * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[colGroup][colGroup]`(1) }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`colGroup`][colGroup]`(1) }` * * #### Examples for this overload: * * $[CommonColGroupDocs.EXAMPLE] * * To create a [ColumnAccessor] for another kind of column, take a look at the functions - * [col][ColumnsSelectionDsl.col], - * [valueCol][ColumnsSelectionDsl.valueCol], - * and [frameCol][ColumnsSelectionDsl.frameCol]. + * [`col`][ColumnsSelectionDsl.col], + * [`valueCol`][ColumnsSelectionDsl.valueCol], + * and [`frameCol`][ColumnsSelectionDsl.frameCol]. * * @return A [ColumnAccessor] for the column group with the given argument if possible, else a [SingleColumn]. * @throws [IllegalStateException\] if the column with the given argument does not exist. @@ -123,14 +123,14 @@ public interface ColGroupColumnsSelectionDsl { typealias EXAMPLE = Nothing /** - * `df.`[select][DataFrame.select]` { $[CommonColGroupDocs.RECEIVER]`[colGroup][colGroup]`($[CommonColGroupDocs.ARG]) \}` + * `df.`[`select`][DataFrame.select]` { $[CommonColGroupDocs.RECEIVER]`[`colGroup`][colGroup]`($[CommonColGroupDocs.ARG]) \}` */ typealias SingleExample = Nothing /** - * `df.`[select][DataFrame.select]` { $[CommonColGroupDocs.RECEIVER]`[colGroup][colGroup]`($[CommonColGroupDocs.ARG]) \}` + * `df.`[`select`][DataFrame.select]` { $[CommonColGroupDocs.RECEIVER]`[`colGroup`][colGroup]`($[CommonColGroupDocs.ARG]) \}` * - * `df.`[select][DataFrame.select]` { $[CommonColGroupDocs.RECEIVER]`[colGroup][colGroup]`<`[String][String]`>($[CommonColGroupDocs.ARG]) \}` + * `df.`[`select`][DataFrame.select]` { $[CommonColGroupDocs.RECEIVER]`[`colGroup`][colGroup]`<`[`String`][String]`>($[CommonColGroupDocs.ARG]) \}` */ typealias DoubleExample = Nothing @@ -557,7 +557,7 @@ public interface ColGroupColumnsSelectionDsl { private typealias ColGroupIndexDocs = Nothing /** - * @include [ColGroupIndexDocs] {@set [CommonColGroupDocs.RECEIVER] `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().} + * @include [ColGroupIndexDocs] {@set [CommonColGroupDocs.RECEIVER] `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>().} * @include [CommonColGroupDocs.ColumnGroupTypeParam] * {@set [CommonColGroupDocs.EXAMPLE] {@include [CommonColGroupDocs.SingleExample]}} */ @@ -567,7 +567,7 @@ public interface ColGroupColumnsSelectionDsl { getAt(index).ensureIsColumnGroup() /** - * @include [ColGroupIndexDocs] {@set [CommonColGroupDocs.RECEIVER] `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().} + * @include [ColGroupIndexDocs] {@set [CommonColGroupDocs.RECEIVER] `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>().} * @include [CommonColGroupDocs.ColumnGroupTypeParam] * {@set [CommonColGroupDocs.EXAMPLE] {@include [CommonColGroupDocs.SingleExample]}} */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroups.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroups.kt index c8f62e5a8f..54eb381a98 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroups.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colGroups.kt @@ -74,11 +74,11 @@ public interface ColGroupsColumnsSelectionDsl { * * #### For example: * - * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`colGroups`][ColumnsSelectionDsl.colGroups]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` * - * `df.`[select][DataFrame.select]` { `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().`[colGroups][ColumnsSelectionDsl.colGroups]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]`().`[`colGroups`][ColumnsSelectionDsl.colGroups]`() }` * - * `df.`[select][DataFrame.select]` { "myColGroup".`[colGroups][String.colGroups]`() }` + * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`colGroups`][String.colGroups]`() }` * * #### Examples for this overload: * @@ -101,11 +101,11 @@ public interface ColGroupsColumnsSelectionDsl { * @include [CommonColGroupsDocs] * @set [CommonColGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") }.`[colGroups][ColumnSet.colGroups]`() }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") }.`[`colGroups`][ColumnSet.colGroups]`() }` * * `// NOTE: This can be shortened to just:` * - * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`colGroups`][ColumnsSelectionDsl.colGroups]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ @Interpretable("ColGroups0") public fun ColumnSet<*>.colGroups(filter: Predicate> = { true }): ColumnSet> = @@ -115,9 +115,9 @@ public interface ColGroupsColumnsSelectionDsl { * @include [CommonColGroupsDocs] * @set [CommonColGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colGroups`][ColumnsSelectionDsl.colGroups]`() }` * - * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`colGroups`][ColumnsSelectionDsl.colGroups]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ @Interpretable("ColGroups1") public fun ColumnsSelectionDsl<*>.colGroups(filter: Predicate> = { true }): ColumnSet> = @@ -127,9 +127,9 @@ public interface ColGroupsColumnsSelectionDsl { * @include [CommonColGroupsDocs] * @set [CommonColGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColGroup.`[colGroups][SingleColumn.colGroups]`() }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`colGroups`][SingleColumn.colGroups]`() }` * - * `df.`[select][DataFrame.select]` { myColGroup.`[colGroups][SingleColumn.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`colGroups`][SingleColumn.colGroups]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ @Interpretable("ColGroups2") public fun SingleColumn>.colGroups(filter: Predicate> = { true }): ColumnSet> = @@ -139,9 +139,9 @@ public interface ColGroupsColumnsSelectionDsl { * @include [CommonColGroupsDocs] * @set [CommonColGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColGroup".`[colGroups][String.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`colGroups`][String.colGroups]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` * - * `df.`[select][DataFrame.select]` { "myColGroup".`[colGroups][String.colGroups]`() }` + * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`colGroups`][String.colGroups]`() }` */ public fun String.colGroups(filter: Predicate> = { true }): ColumnSet> = columnGroup(this).colGroups(filter) @@ -150,9 +150,9 @@ public interface ColGroupsColumnsSelectionDsl { * @include [CommonColGroupsDocs] * @set [CommonColGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colGroup][ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[colGroups][SingleColumn.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`colGroup`][ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[`colGroups`][SingleColumn.colGroups]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColGroup.`[colGroups][KProperty.colGroups]`() }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColGroup.`[`colGroups`][KProperty.colGroups]`() }` */ public fun KProperty<*>.colGroups(filter: Predicate> = { true }): ColumnSet> = columnGroup(this).colGroups(filter) @@ -161,7 +161,7 @@ public interface ColGroupsColumnsSelectionDsl { * @include [CommonColGroupsDocs] * @set [CommonColGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myGroupCol"].`[colGroups][ColumnPath.colGroups]`() }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myGroupCol"].`[`colGroups`][ColumnPath.colGroups]`() }` */ public fun ColumnPath.colGroups(filter: Predicate> = { true }): ColumnSet> = columnGroup(this).colGroups(filter) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt index b2256b3059..aa9afb9457 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsAtAnyDepth.kt @@ -70,24 +70,24 @@ public interface ColsAtAnyDepthColumnsSelectionDsl { * Returns all columns in [this\] at any depth (so also inside [Column Groups][ColumnGroup]) * * This function can also be followed by another [ColumnSet] filter function like - * [colsOf][ColumnsSelectionDsl.colsOf], [single][ColumnsSelectionDsl.single], or [valueCols][ColumnsSelectionDsl.valueCols]. + * [`colsOf`][ColumnsSelectionDsl.colsOf], [`single`][ColumnsSelectionDsl.single], or [`valueCols`][ColumnsSelectionDsl.valueCols]. * ### Check out: [Grammar] * #### For example: * `// Depth-first search to a column containing the value "Alice"` * - * `df.`[select][DataFrame.select]` { `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().`[filter][FilterColumnsSelectionDsl.filter]` { "Alice" `[in][Iterable.contains]` it.`[values][DataColumn.values]`() }.`[first][ColumnsSelectionDsl.firstCol]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]`().`[`filter`][FilterColumnsSelectionDsl.filter]` { "Alice" `[`in`][Iterable.contains]` it.`[`values`][DataColumn.values]`() }.`[`first`][ColumnsSelectionDsl.firstCol]`() }` * {@include [LineBreak]} * `// The columns at any depth excluding the top-level` * - * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]`().`[colsAtAnyDepth][ColumnSet.colsAtAnyDepth]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colGroups`][ColumnsSelectionDsl.colGroups]`().`[`colsAtAnyDepth`][ColumnSet.colsAtAnyDepth]`() }` * {@include [LineBreak]} * `// All value- and frame columns at any depth` * - * `df.`[select][DataFrame.select]` { `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().`[filter][FilterColumnsSelectionDsl.filter]` { !it.`[isColumnGroup][DataColumn.isColumnGroup]` } }` + * `df.`[`select`][DataFrame.select]` { `[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]`().`[`filter`][FilterColumnsSelectionDsl.filter]` { !it.`[`isColumnGroup`][DataColumn.isColumnGroup]` } }` * {@include [LineBreak]} * `// All value columns at any depth nested under a column group named "myColGroup"` * - * `df.`[select][DataFrame.select]` { myColGroup.`[colsAtAnyDepth][SingleColumn.colsAtAnyDepth]`().`[valueCols][ColumnsSelectionDsl.valueCols]`() }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`colsAtAnyDepth`][SingleColumn.colsAtAnyDepth]`().`[`valueCols`][ColumnsSelectionDsl.valueCols]`() }` * * #### Examples for this overload: * @@ -95,17 +95,17 @@ public interface ColsAtAnyDepthColumnsSelectionDsl { * * #### Converting from deprecated syntax: * - * `dfs { condition } -> `[colsAtAnyDepth][colsAtAnyDepth]`().`[filter][FilterColumnsSelectionDsl.filter]` { condition }` + * `dfs { condition } -> `[`colsAtAnyDepth`][colsAtAnyDepth]`().`[`filter`][FilterColumnsSelectionDsl.filter]` { condition }` * - * `allDfs(includeGroups = false) -> `[colsAtAnyDepth][colsAtAnyDepth]`().`[filter][FilterColumnsSelectionDsl.filter]` { includeGroups || !it.`[isColumnGroup][DataColumn.isColumnGroup]`() }` + * `allDfs(includeGroups = false) -> `[`colsAtAnyDepth`][colsAtAnyDepth]`().`[`filter`][FilterColumnsSelectionDsl.filter]` { includeGroups || !it.`[`isColumnGroup`][DataColumn.isColumnGroup]`() }` * - * `dfsOf { condition } -> `[colsAtAnyDepth][colsAtAnyDepth]`().`[colsOf][ColumnsSelectionDsl.colsOf]` { condition }` + * `dfsOf { condition } -> `[`colsAtAnyDepth`][colsAtAnyDepth]`().`[`colsOf`][ColumnsSelectionDsl.colsOf]` { condition }` * - * [cols][ColumnsSelectionDsl.cols]` { condition }.recursively() -> `[colsAtAnyDepth][colsAtAnyDepth]`().`[filter][FilterColumnsSelectionDsl.filter]` { condition }` + * [`cols`][ColumnsSelectionDsl.cols]` { condition }.recursively() -> `[`colsAtAnyDepth`][colsAtAnyDepth]`().`[`filter`][FilterColumnsSelectionDsl.filter]` { condition }` * - * [first][ColumnsSelectionDsl.first]` { condition }.rec() -> `[colsAtAnyDepth][colsAtAnyDepth]` { condition }.`[first][ColumnsSelectionDsl.first]`()` + * [`first`][ColumnsSelectionDsl.first]` { condition }.rec() -> `[`colsAtAnyDepth`][colsAtAnyDepth]` { condition }.`[`first`][ColumnsSelectionDsl.first]`()` * - * [all][ColumnsSelectionDsl.all]`().recursively() -> `[colsAtAnyDepth][colsAtAnyDepth]`()` + * [`all`][ColumnsSelectionDsl.all]`().recursively() -> `[`colsAtAnyDepth`][colsAtAnyDepth]`()` * * @see [DataFrame.flatten\] * @see [ColumnsSelectionDsl.simplify\] @@ -120,7 +120,7 @@ public interface ColsAtAnyDepthColumnsSelectionDsl { * @include [CommonAtAnyDepthDocs] * @set [CommonAtAnyDepthDocs.Examples] * - * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]`().`[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]` { "Alice" `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }` + * `df.`[`select`][DataFrame.select]` { `[`colGroups`][ColumnsSelectionDsl.colGroups]`().`[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]` { "Alice" `[`in`][Iterable.contains]` it.`[`values`][DataColumn.values]`() } }` */ @Interpretable("ColsAtAnyDepth0") @Deprecated( @@ -135,7 +135,7 @@ public interface ColsAtAnyDepthColumnsSelectionDsl { * @include [CommonAtAnyDepthDocs] * @set [CommonAtAnyDepthDocs.Examples] * - * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]`().`[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().filter { "Alice" `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }` + * `df.`[`select`][DataFrame.select]` { `[`colGroups`][ColumnsSelectionDsl.colGroups]`().`[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]`().filter { "Alice" `[`in`][Iterable.contains]` it.`[`values`][DataColumn.values]`() } }` */ @Interpretable("ColsAtAnyDepth0") public fun ColumnSet<*>.colsAtAnyDepth(): ColumnSet<*> = colsAtAnyDepthInternal { true } @@ -144,9 +144,9 @@ public interface ColsAtAnyDepthColumnsSelectionDsl { * @include [CommonAtAnyDepthDocs] * @set [CommonAtAnyDepthDocs.Examples] * - * `df.`[select][DataFrame.select]` { `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]` { "Alice" `[in][Iterable.contains]` it.`[values][DataColumn.values]`() }.`[first][ColumnsSelectionDsl.first]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]` { "Alice" `[`in`][Iterable.contains]` it.`[`values`][DataColumn.values]`() }.`[`first`][ColumnsSelectionDsl.first]`() }` * - * `df.`[select][DataFrame.select]` { `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]` { !it.`[isColumnGroup][DataColumn.isColumnGroup]` } }` + * `df.`[`select`][DataFrame.select]` { `[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]` { !it.`[`isColumnGroup`][DataColumn.isColumnGroup]` } }` */ @Interpretable("ColsAtAnyDepth1") @Deprecated( @@ -162,9 +162,9 @@ public interface ColsAtAnyDepthColumnsSelectionDsl { * @include [CommonAtAnyDepthDocs] * @set [CommonAtAnyDepthDocs.Examples] * - * `df.`[select][DataFrame.select]` { `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().filter { "Alice" `[in][Iterable.contains]` it.`[values][DataColumn.values]`() }.`[first][ColumnsSelectionDsl.first]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]`().filter { "Alice" `[`in`][Iterable.contains]` it.`[`values`][DataColumn.values]`() }.`[`first`][ColumnsSelectionDsl.first]`() }` * - * `df.`[select][DataFrame.select]` { `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().filter { !it.`[isColumnGroup][DataColumn.isColumnGroup]` } }` + * `df.`[`select`][DataFrame.select]` { `[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]`().filter { !it.`[`isColumnGroup`][DataColumn.isColumnGroup]` } }` */ @Interpretable("ColsAtAnyDepth1") public fun ColumnsSelectionDsl<*>.colsAtAnyDepth(): ColumnSet<*> = asSingleColumn().colsAtAnyDepthInternal { true } @@ -173,7 +173,7 @@ public interface ColsAtAnyDepthColumnsSelectionDsl { * @include [CommonAtAnyDepthDocs] * @set [CommonAtAnyDepthDocs.Examples] * - * `df.`[select][DataFrame.select]` { myColGroup.`[colsAtAnyDepth][SingleColumn.colsAtAnyDepth]` { "Alice" `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`colsAtAnyDepth`][SingleColumn.colsAtAnyDepth]` { "Alice" `[`in`][Iterable.contains]` it.`[`values`][DataColumn.values]`() } }` */ @Interpretable("ColsAtAnyDepth2") @Deprecated( @@ -189,7 +189,7 @@ public interface ColsAtAnyDepthColumnsSelectionDsl { * @include [CommonAtAnyDepthDocs] * @set [CommonAtAnyDepthDocs.Examples] * - * `df.`[select][DataFrame.select]` { myColGroup.`[colsAtAnyDepth][SingleColumn.colsAtAnyDepth]`().filter { "Alice" `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`colsAtAnyDepth`][SingleColumn.colsAtAnyDepth]`().filter { "Alice" `[`in`][Iterable.contains]` it.`[`values`][DataColumn.values]`() } }` */ @Interpretable("ColsAtAnyDepth2") public fun SingleColumn>.colsAtAnyDepth(): ColumnSet<*> = @@ -199,7 +199,7 @@ public interface ColsAtAnyDepthColumnsSelectionDsl { * @include [CommonAtAnyDepthDocs] * @set [CommonAtAnyDepthDocs.Examples] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsAtAnyDepth][String.colsAtAnyDepth]` { "Alice" `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`colsAtAnyDepth`][String.colsAtAnyDepth]` { "Alice" `[`in`][Iterable.contains]` it.`[`values`][DataColumn.values]`() } }` */ @Deprecated( message = COLS_AT_ANY_DEPTH, @@ -213,7 +213,7 @@ public interface ColsAtAnyDepthColumnsSelectionDsl { * @include [CommonAtAnyDepthDocs] * @set [CommonAtAnyDepthDocs.Examples] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsAtAnyDepth][String.colsAtAnyDepth]`().filter { "Alice" `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`colsAtAnyDepth`][String.colsAtAnyDepth]`().filter { "Alice" `[`in`][Iterable.contains]` it.`[`values`][DataColumn.values]`() } }` */ public fun String.colsAtAnyDepth(): ColumnSet<*> = columnGroup(this).colsAtAnyDepth { true } @@ -221,7 +221,7 @@ public interface ColsAtAnyDepthColumnsSelectionDsl { * @include [CommonAtAnyDepthDocs] * @set [CommonAtAnyDepthDocs.Examples] * - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsAtAnyDepth][KProperty.colsAtAnyDepth]` { "Alice" `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`colsAtAnyDepth`][KProperty.colsAtAnyDepth]` { "Alice" `[`in`][Iterable.contains]` it.`[`values`][DataColumn.values]`() } }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -232,7 +232,7 @@ public interface ColsAtAnyDepthColumnsSelectionDsl { * @include [CommonAtAnyDepthDocs] * @set [CommonAtAnyDepthDocs.Examples] * - * `df.`[select][DataFrame.select]` { "pathTo"["myGroupCol"].`[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]` { "Alice" `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myGroupCol"].`[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]` { "Alice" `[`in`][Iterable.contains]` it.`[`values`][DataColumn.values]`() } }` */ @Deprecated("", replaceWith = ReplaceWith("colsAtAnyDepth().filter(predicate)")) public fun ColumnPath.colsAtAnyDepth(predicate: (ColumnWithPath<*>) -> Boolean = { true }): ColumnSet<*> = @@ -242,7 +242,7 @@ public interface ColsAtAnyDepthColumnsSelectionDsl { * @include [CommonAtAnyDepthDocs] * @set [CommonAtAnyDepthDocs.Examples] * - * `df.`[select][DataFrame.select]` { "pathTo"["myGroupCol"].`[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().filter { "Alice" `[in][Iterable.contains]` it.`[values][DataColumn.values]`() } }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myGroupCol"].`[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]`().filter { "Alice" `[`in`][Iterable.contains]` it.`[`values`][DataColumn.values]`() } }` */ public fun ColumnPath.colsAtAnyDepth(): ColumnSet<*> = columnGroup(this).colsAtAnyDepth { true } diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsInGroups.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsInGroups.kt index 0a40f9f943..164208fa1e 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsInGroups.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsInGroups.kt @@ -65,12 +65,12 @@ public interface ColsInGroupsColumnsSelectionDsl { /** * ## Cols in Groups * - * [colsInGroups][colsInGroups] is a function that returns all columns at the top-levels of + * [`colsInGroups`][colsInGroups] is a function that returns all columns at the top-levels of * all [column groups][ColumnGroup] in [this\]. This is useful if you want to select all columns that are * "one level deeper". * - * NOTE: This function should not be confused with [cols][ColumnsSelectionDsl.cols], which operates on all - * columns directly in [this\], or with [colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth], which operates on all + * NOTE: This function should not be confused with [`cols`][ColumnsSelectionDsl.cols], which operates on all + * columns directly in [this\], or with [`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth], which operates on all * columns in [this\] at any depth. * * ### Check out: [Grammar] @@ -79,19 +79,19 @@ public interface ColsInGroupsColumnsSelectionDsl { * * To get only the columns inside all column groups in a [DataFrame], instead of having to write: * - * `df.`[select][DataFrame.select]` { colGroupA.`[cols][ColumnsSelectionDsl.cols]`() `[and][ColumnsSelectionDsl.and]` colGroupB.`[cols][ColumnsSelectionDsl.cols]`() ... }` + * `df.`[`select`][DataFrame.select]` { colGroupA.`[`cols`][ColumnsSelectionDsl.cols]`() `[`and`][ColumnsSelectionDsl.and]` colGroupB.`[`cols`][ColumnsSelectionDsl.cols]`() ... }` * * you can use: * - * `df.`[select][DataFrame.select]` { `[colsInGroups][ColumnsSelectionDsl.colsInGroups]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsInGroups`][ColumnsSelectionDsl.colsInGroups]`() }` * * and * - * `df.`[select][DataFrame.select]` { `[colsInGroups][ColumnsSelectionDsl.colsInGroups]`().`[nameContains][ColumnsSelectionDsl.nameContains]`("user") }` + * `df.`[`select`][DataFrame.select]` { `[`colsInGroups`][ColumnsSelectionDsl.colsInGroups]`().`[`nameContains`][ColumnsSelectionDsl.nameContains]`("user") }` * {@include [LineBreak]} * Similarly, you can take the columns inside all [column groups][ColumnGroup] in a [ColumnSet]: * {@include [LineBreak]} - * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]`().`[nameContains][ColumnsSelectionDsl.nameContains]`("my").`[colsInGroups][ColumnSet.colsInGroups]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colGroups`][ColumnsSelectionDsl.colGroups]`().`[`nameContains`][ColumnsSelectionDsl.nameContains]`("my").`[`colsInGroups`][ColumnSet.colsInGroups]`() }` * {@include [LineBreak]} * * #### Examples of this overload: @@ -112,9 +112,9 @@ public interface ColsInGroupsColumnsSelectionDsl { * @include [ColsInGroupsDocs] * @set [ColsInGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsInGroups][ColumnSet.colsInGroups]` { "my" `[in][String.contains]` it.`[name][DataColumn.name]` } }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`colsInGroups`][ColumnSet.colsInGroups]` { "my" `[`in`][String.contains]` it.`[`name`][DataColumn.name]` } }` * - * `df.`[select][DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[DataRow][DataRow]`>().`[colsInGroups][ColumnSet.colsInGroups]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`DataRow`][DataRow]`>().`[`colsInGroups`][ColumnSet.colsInGroups]`() }` */ @Deprecated( message = COLS_IN_GROUPS, @@ -128,7 +128,7 @@ public interface ColsInGroupsColumnsSelectionDsl { * @include [ColsInGroupsDocs] * @set [ColsInGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[DataRow][DataRow]`>().`[colsInGroups][ColumnSet.colsInGroups]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`DataRow`][DataRow]`>().`[`colsInGroups`][ColumnSet.colsInGroups]`() }` */ public fun ColumnSet<*>.colsInGroups(): ColumnSet<*> = transform { it.flatMap { it.cols() } } @@ -136,9 +136,9 @@ public interface ColsInGroupsColumnsSelectionDsl { * @include [ColsInGroupsDocs] * @set [ColsInGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsInGroups][ColumnSet.colsInGroups]` { "my" `[in][String.contains]` it.`[name][DataColumn.name]` } }` + * `df.`[`select`][DataFrame.select]` { `[`colsInGroups`][ColumnSet.colsInGroups]` { "my" `[`in`][String.contains]` it.`[`name`][DataColumn.name]` } }` * - * `df.`[select][DataFrame.select]` { `[colsInGroups][ColumnSet.colsInGroups]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsInGroups`][ColumnSet.colsInGroups]`() }` */ @Deprecated( message = COLS_IN_GROUPS, @@ -152,7 +152,7 @@ public interface ColsInGroupsColumnsSelectionDsl { * @include [ColsInGroupsDocs] * @set [ColsInGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsInGroups][ColumnSet.colsInGroups]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsInGroups`][ColumnSet.colsInGroups]`() }` */ public fun ColumnsSelectionDsl<*>.colsInGroups(): ColumnSet<*> = asSingleColumn().colsInGroups() @@ -160,9 +160,9 @@ public interface ColsInGroupsColumnsSelectionDsl { * @include [ColsInGroupsDocs] * @set [ColsInGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsInGroups][SingleColumn.colsInGroups]`() }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`colsInGroups`][SingleColumn.colsInGroups]`() }` * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsInGroups][SingleColumn.colsInGroups]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`colsInGroups`][SingleColumn.colsInGroups]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` */ @Deprecated( message = COLS_IN_GROUPS, @@ -177,7 +177,7 @@ public interface ColsInGroupsColumnsSelectionDsl { * @include [ColsInGroupsDocs] * @set [ColsInGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsInGroups][SingleColumn.colsInGroups]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`colsInGroups`][SingleColumn.colsInGroups]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` */ public fun SingleColumn>.colsInGroups(): ColumnSet<*> = ensureIsColumnGroup().allColumnsInternal().colsInGroups() @@ -186,7 +186,7 @@ public interface ColsInGroupsColumnsSelectionDsl { * @include [ColsInGroupsDocs] * @set [ColsInGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsInGroups][String.colsInGroups]`() }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`colsInGroups`][String.colsInGroups]`() }` */ @Deprecated( message = COLS_IN_GROUPS, @@ -200,7 +200,7 @@ public interface ColsInGroupsColumnsSelectionDsl { * @include [ColsInGroupsDocs] * @set [ColsInGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsInGroups][String.colsInGroups]`() }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`colsInGroups`][String.colsInGroups]`() }` */ public fun String.colsInGroups(): ColumnSet<*> = columnGroup(this).colsInGroups() @@ -208,9 +208,9 @@ public interface ColsInGroupsColumnsSelectionDsl { * @include [ColsInGroupsDocs] * @set [ColsInGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsInGroups][KProperty.colsInGroups]`() }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`colsInGroups`][KProperty.colsInGroups]`() }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[colsInGroups][KProperty.colsInGroups]`() }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`colsInGroups`][KProperty.colsInGroups]`() }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -221,7 +221,7 @@ public interface ColsInGroupsColumnsSelectionDsl { * @include [ColsInGroupsDocs] * @set [ColsInGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[colsInGroups][ColumnPath.colsInGroups]`() }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`colsInGroups`][ColumnPath.colsInGroups]`() }` */ @Deprecated( message = COLS_IN_GROUPS, @@ -235,7 +235,7 @@ public interface ColsInGroupsColumnsSelectionDsl { * @include [ColsInGroupsDocs] * @set [ColsInGroupsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[colsInGroups][ColumnPath.colsInGroups]`() }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`colsInGroups`][ColumnPath.colsInGroups]`() }` */ public fun ColumnPath.colsInGroups(): ColumnSet<*> = columnGroup(this).colsInGroups() } diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOf.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOf.kt index 460bee3c90..4ecbfb263b 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOf.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOf.kt @@ -96,34 +96,34 @@ public interface ColsOfColumnsSelectionDsl { * * This function operates solely on columns at the top-level. * - * __NOTE:__ Null-filled columns of type [Nothing?][Nothing] will be included when selecting [`colsOf`][colsOf]`()`. - * This is because [Nothing][Nothing] is considered a subtype of all other types in Kotlin. - * To exclude these columns, call `.`[filter][ColumnsSelectionDsl.filter]` { !it.`[allNulls][DataColumn.allNulls]`() }` + * __NOTE:__ Null-filled columns of type [`Nothing?`][Nothing] will be included when selecting [`colsOf`][colsOf]`()`. + * This is because [`Nothing`][Nothing] is considered a subtype of all other types in Kotlin. + * To exclude these columns, call `.`[`filter`][ColumnsSelectionDsl.filter]` { !it.`[`allNulls`][DataColumn.allNulls]`() }` * after it. * * ### Check out: [Grammar] * * #### For example: * - * `df.`[select][DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>() }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>() }` * - * `df.`[select][DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`> { it.`[`size`][DataColumn.size]` > 10 } }` * {@include [LineBreak]} * Alternatively, [colsOf] can also be called on existing columns: * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>() }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>() }` * - * `df.`[select][DataFrame.select]` { "myColumnGroup"().`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup"().`[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`> { it.`[`size`][DataColumn.size]` > 10 } }` * - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsOf][ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Double`][Double]`>() }` * {@include [LineBreak]} * Finally, [colsOf] can also take a [KType] argument instead of a reified type. * This is useful when the type is not known at compile time or when the API function cannot be inlined. * {@comment TODO: [Issue: #325, context receiver support](https://github.com/Kotlin/dataframe/issues/325) } * - * `df.`[select][DataFrame.select]` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>(`[`typeOf`][typeOf]`<`[`Int`][Int]`>()) }` * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>(`[`typeOf`][typeOf]`<`[`Int`][Int]`>()) { it: `[`DataColumn`][DataColumn]`<`[`Int`][Int]`> -> it.`[`size`][DataColumn.size]` > 10 } }` * * #### Examples for this overload: */ @@ -139,9 +139,9 @@ public interface ColsOfColumnsSelectionDsl { /** * @include [CommonColsOfDocs] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsOf][String.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`colsOf`][String.colsOf]`(`[`typeOf`][typeOf]`<`[`Int`][Int]`>()) }` * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsOf][String.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`colsOf`][String.colsOf]`(`[`typeOf`][typeOf]`<`[`Int`][Int]`>()) { it: `[`DataColumn`][DataColumn]`<`[`Int`][Int]`> -> it.`[`size`][DataColumn.size]` > 10 } }` * * @include [CommonColsOfDocs.FilterParam] * @include [CommonColsOfDocs.Return] @@ -152,9 +152,9 @@ public interface ColsOfColumnsSelectionDsl { /** * @include [CommonColsOfDocs] * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[colsOf][KProperty.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`colsOf`][KProperty.colsOf]`(`[`typeOf`][typeOf]`<`[`Int`][Int]`>()) }` * - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsOf][KProperty.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`colsOf`][KProperty.colsOf]`(`[`typeOf`][typeOf]`<`[`Int`][Int]`>()) { it: `[`DataColumn`][DataColumn]`<`[`Int`][Int]`> -> it.`[`size`][DataColumn.size]` > 10 } }` * * @include [CommonColsOfDocs.FilterParam] * @include [CommonColsOfDocs.Return] @@ -167,9 +167,9 @@ public interface ColsOfColumnsSelectionDsl { /** * @include [CommonColsOfDocs] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[colsOf][ColumnPath.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`colsOf`][ColumnPath.colsOf]`(`[`typeOf`][typeOf]`<`[`Int`][Int]`>()) }` * - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[colsOf][ColumnPath.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`colsOf`][ColumnPath.colsOf]`(`[`typeOf`][typeOf]`<`[`Int`][Int]`>()) { it: `[`DataColumn`][DataColumn]`<`[`Int`][Int]`> -> it.`[`size`][DataColumn.size]` > 10 } }` * * @include [CommonColsOfDocs.FilterParam] * @include [CommonColsOfDocs.Return] @@ -181,9 +181,9 @@ public interface ColsOfColumnsSelectionDsl { /** * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`colsOf`][ColumnSet.colsOf]`(`[`typeOf`][typeOf]`<`[`Int`][Int]`>()) }` * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`colsOf`][ColumnSet.colsOf]`(`[`typeOf`][typeOf]`<`[`Int`][Int]`>()) { it: `[`DataColumn`][DataColumn]`<`[`Int`][Int]`> -> it.`[`size`][DataColumn.size]` > 10 } }` * * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam] * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return] @@ -194,9 +194,9 @@ public fun ColumnSet<*>.colsOf(type: KType, filter: (ColumnWithPath) -> B /** * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`<`[Int][Int]`>() }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`colsOf`][ColumnSet.colsOf]`<`[`Int`][Int]`>() }` * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`colsOf`][ColumnSet.colsOf]`<`[`Int`][Int]`> { it.`[`size`][DataColumn.size]` > 10 } }` * * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam] * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return] @@ -209,7 +209,7 @@ public inline fun ColumnSet<*>.colsOf( /** * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs] * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`(`[`typeOf`][typeOf]`<`[`Int`][Int]`>()) }` * * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam] * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return] @@ -222,7 +222,7 @@ public fun ColumnsSelectionDsl<*>.colsOf( /** * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs] * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>() }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>() }` * * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam] * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return] @@ -235,9 +235,9 @@ public inline fun ColumnsSelectionDsl<*>.colsOf( /** * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>(`[`typeOf`][typeOf]`<`[`Int`][Int]`>()) { it: `[`DataColumn`][DataColumn]`<`[`Int`][Int]`> -> it.`[`size`][DataColumn.size]` > 10 } }` * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>(`[`typeOf`][typeOf]`<`[`Int`][Int]`>()) }` * * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam] * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return] @@ -250,9 +250,9 @@ public fun SingleColumn>.colsOf( /** * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`> { it.`[`size`][DataColumn.size]` > 10 } }` * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>() }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>() }` * * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam] * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return] diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt index cdce693fc5..a0729e6c21 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/colsOfKind.kt @@ -80,11 +80,11 @@ public interface ColsOfKindColumnsSelectionDsl { * * #### For example: * - * `df.`[select][DataFrame.select]` { `[colsOfKind][ColumnsSelectionDsl.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`colsOfKind`][ColumnsSelectionDsl.colsOfKind]`(`[`Value`][ColumnKind.Value]`, `[`Frame`][ColumnKind.Frame]`) { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` * - * `df.`[select][DataFrame.select]` { `[colsOfKind][ColumnsSelectionDsl.colsOfKind]`(`[Group][ColumnKind.Group]`) }` + * `df.`[`select`][DataFrame.select]` { `[`colsOfKind`][ColumnsSelectionDsl.colsOfKind]`(`[`Group`][ColumnKind.Group]`) }` * - * `df.`[select][DataFrame.select]` { "myColGroup".`[colsOfKind][String.colsOfKind]`(`[Frame][ColumnKind.Frame]`) }` + * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`colsOfKind`][String.colsOfKind]`(`[`Frame`][ColumnKind.Frame]`) }` * * #### Examples for this overload: * @@ -109,11 +109,11 @@ public interface ColsOfKindColumnsSelectionDsl { * @include [CommonColsOfKindDocs] * @set [CommonColsOfKindDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") }.`[colsOfKind][ColumnSet.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") }.`[`colsOfKind`][ColumnSet.colsOfKind]`(`[`Value`][ColumnKind.Value]`, `[`Frame`][ColumnKind.Frame]`) }` * * `// NOTE: This can be shortened to just:` * - * `df.`[select][DataFrame.select]` { `[colsOfKind][ColumnsSelectionDsl.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`colsOfKind`][ColumnsSelectionDsl.colsOfKind]`(`[`Value`][ColumnKind.Value]`, `[`Frame`][ColumnKind.Frame]`) { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun ColumnSet<*>.colsOfKind( kind: ColumnKind, @@ -129,7 +129,7 @@ public interface ColsOfKindColumnsSelectionDsl { * @include [CommonColsOfKindDocs] * @set [CommonColsOfKindDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsOfKind][ColumnsSelectionDsl.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`colsOfKind`][ColumnsSelectionDsl.colsOfKind]`(`[`Value`][ColumnKind.Value]`, `[`Frame`][ColumnKind.Frame]`) { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun ColumnsSelectionDsl<*>.colsOfKind( kind: ColumnKind, @@ -145,7 +145,7 @@ public interface ColsOfKindColumnsSelectionDsl { * @include [CommonColsOfKindDocs] * @set [CommonColsOfKindDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOfKind][SingleColumn.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`colsOfKind`][SingleColumn.colsOfKind]`(`[`Value`][ColumnKind.Value]`, `[`Frame`][ColumnKind.Frame]`) }` */ public fun SingleColumn>.colsOfKind( kind: ColumnKind, @@ -161,7 +161,7 @@ public interface ColsOfKindColumnsSelectionDsl { * @include [CommonColsOfKindDocs] * @set [CommonColsOfKindDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsOfKind][SingleColumn.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`colsOfKind`][SingleColumn.colsOfKind]`(`[`Value`][ColumnKind.Value]`, `[`Frame`][ColumnKind.Frame]`) }` */ public fun String.colsOfKind( kind: ColumnKind, @@ -173,7 +173,7 @@ public interface ColsOfKindColumnsSelectionDsl { * @include [CommonColsOfKindDocs] * @set [CommonColsOfKindDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsOfKind][KProperty.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`colsOfKind`][KProperty.colsOfKind]`(`[`Value`][ColumnKind.Value]`, `[`Frame`][ColumnKind.Frame]`) }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -187,7 +187,7 @@ public interface ColsOfKindColumnsSelectionDsl { * @include [CommonColsOfKindDocs] * @set [CommonColsOfKindDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[colsOfKind][ColumnPath.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`colsOfKind`][ColumnPath.colsOfKind]`(`[`Value`][ColumnKind.Value]`, `[`Frame`][ColumnKind.Frame]`) }` */ public fun ColumnPath.colsOfKind( kind: ColumnKind, diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnNameFilters.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnNameFilters.kt index b8abd90279..7db02d100b 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnNameFilters.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnNameFilters.kt @@ -91,17 +91,17 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * * NOTE: For [column groups][ColumnGroup], `nameContains` is named `colsNameContains` to avoid confusion. * - * This function is a shorthand for [cols][ColumnsSelectionDsl.cols]` { `{@get [ARGUMENT]}{@get [ARGUMENT]}` `[in][String.contains]` it.`[name][DataColumn.name]` }`. + * This function is a shorthand for [`cols`][ColumnsSelectionDsl.cols]` { `{@get [ARGUMENT]}{@get [ARGUMENT]}` `[`in`][String.contains]` it.`[`name`][DataColumn.name]` }`. * * ### Check out: [Grammar] * * #### For example: * - * `df.`[select][DataFrame.select]` { `[nameContains][SingleColumn.colsNameContains]`("my") }` + * `df.`[`select`][DataFrame.select]` { `[`nameContains`][SingleColumn.colsNameContains]`("my") }` * - * `df.`[select][DataFrame.select]` { "someGroupCol".`[nameContains][String.colsNameContains]`(`[Regex][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }` + * `df.`[`select`][DataFrame.select]` { "someGroupCol".`[`nameContains`][String.colsNameContains]`(`[`Regex`][Regex]`("my[a-zA-Z][a-zA-Z0-9]*")) }` * - * `df.`[select][DataFrame.select]` { Type::someGroupCol.`[nameContains][SingleColumn.colsNameContains]`("my", ignoreCase = true) }` + * `df.`[`select`][DataFrame.select]` { Type::someGroupCol.`[`nameContains`][SingleColumn.colsNameContains]`("my", ignoreCase = true) }` * * #### Examples for this overload: * @@ -143,9 +143,9 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [NameContainsTextDocs] * @set [CommonNameContainsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[nameContains][ColumnSet.nameContains]`("my") }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`nameContains`][ColumnSet.nameContains]`("my") }` * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[nameContains][ColumnSet.nameContains]`("my", ignoreCase = true) }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`nameContains`][ColumnSet.nameContains]`("my", ignoreCase = true) }` */ @Suppress("UNCHECKED_CAST") @Interpretable("NameContains0") @@ -156,7 +156,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [NameContainsTextDocs] * @set [CommonNameContainsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[nameContains][ColumnsSelectionDsl.colsNameContains]`("my") }` + * `df.`[`select`][DataFrame.select]` { `[`nameContains`][ColumnsSelectionDsl.colsNameContains]`("my") }` */ @Interpretable("NameContains1") public fun ColumnsSelectionDsl<*>.nameContains(text: CharSequence, ignoreCase: Boolean = false): ColumnSet<*> = @@ -166,7 +166,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [NameContainsTextDocs] * @set [CommonNameContainsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { someGroupCol.`[colsNameContains][SingleColumn.colsNameContains]`("my") }` + * `df.`[`select`][DataFrame.select]` { someGroupCol.`[`colsNameContains`][SingleColumn.colsNameContains]`("my") }` */ @Interpretable("NameContains2") public fun SingleColumn>.colsNameContains( @@ -178,7 +178,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [NameContainsTextDocs] * @set [CommonNameContainsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "someGroupCol".`[colsNameContains][String.colsNameContains]`("my") }` + * `df.`[`select`][DataFrame.select]` { "someGroupCol".`[`colsNameContains`][String.colsNameContains]`("my") }` */ public fun String.colsNameContains(text: CharSequence, ignoreCase: Boolean = false): ColumnSet<*> = columnGroup(this).colsNameContains(text, ignoreCase) @@ -187,7 +187,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [NameContainsTextDocs] * @set [CommonNameContainsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { DataSchemaType::someGroupCol.`[colsNameContains][KProperty.colsNameContains]`("my") }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::someGroupCol.`[`colsNameContains`][KProperty.colsNameContains]`("my") }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -198,7 +198,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [NameContainsTextDocs] * @set [CommonNameContainsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["someGroupCol"].`[colsNameContains][ColumnPath.colsNameContains]`("my") }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["someGroupCol"].`[`colsNameContains`][ColumnPath.colsNameContains]`("my") }` */ public fun ColumnPath.colsNameContains(text: CharSequence, ignoreCase: Boolean = false): ColumnSet<*> = columnGroup(this).colsNameContains(text, ignoreCase) @@ -212,9 +212,9 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [NameContainsRegexDocs] * @set [CommonNameContainsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[nameContains][ColumnSet.nameContains]`(`[Regex][Regex]`("order-[0-9]+")) }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`nameContains`][ColumnSet.nameContains]`(`[`Regex`][Regex]`("order-[0-9]+")) }` * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[nameContains][ColumnSet.nameContains]`(`[Regex][Regex]`("order-[0-9]+")) }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`nameContains`][ColumnSet.nameContains]`(`[`Regex`][Regex]`("order-[0-9]+")) }` */ @Suppress("UNCHECKED_CAST") public fun ColumnSet.nameContains(regex: Regex): ColumnSet = @@ -224,7 +224,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [NameContainsRegexDocs] * @set [CommonNameContainsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[nameContains][ColumnsSelectionDsl.nameContains]`(`[Regex][Regex]`("order-[0-9]+")) }` + * `df.`[`select`][DataFrame.select]` { `[`nameContains`][ColumnsSelectionDsl.nameContains]`(`[`Regex`][Regex]`("order-[0-9]+")) }` */ public fun ColumnsSelectionDsl<*>.nameContains(regex: Regex): ColumnSet<*> = asSingleColumn().colsNameContains(regex) @@ -233,7 +233,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [NameContainsRegexDocs] * @set [CommonNameContainsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { someGroupCol.`[colsNameContains][SingleColumn.colsNameContains]`(`[Regex][Regex]`("order-[0-9]+")) }` + * `df.`[`select`][DataFrame.select]` { someGroupCol.`[`colsNameContains`][SingleColumn.colsNameContains]`(`[`Regex`][Regex]`("order-[0-9]+")) }` */ public fun SingleColumn>.colsNameContains(regex: Regex): ColumnSet<*> = this.ensureIsColumnGroup().colsInternal { it.name.contains(regex) } @@ -242,7 +242,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [NameContainsRegexDocs] * @set [CommonNameContainsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "someGroupCol".`[colsNameContains][String.colsNameContains]`(`[Regex][Regex]`("order-[0-9]+")) }` + * `df.`[`select`][DataFrame.select]` { "someGroupCol".`[`colsNameContains`][String.colsNameContains]`(`[`Regex`][Regex]`("order-[0-9]+")) }` */ public fun String.colsNameContains(regex: Regex): ColumnSet<*> = columnGroup(this).colsNameContains(regex) @@ -250,7 +250,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [NameContainsRegexDocs] * @set [CommonNameContainsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { DataSchemaType::someGroupCol.`[colsNameContains][KProperty.colsNameContains]`(`[Regex][Regex]`("order-[0-9]+")) }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::someGroupCol.`[`colsNameContains`][KProperty.colsNameContains]`(`[`Regex`][Regex]`("order-[0-9]+")) }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -260,7 +260,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [NameContainsRegexDocs] * @set [CommonNameContainsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["someGroupCol"].`[colsNameContains][ColumnPath.colsNameContains]`(`[Regex][Regex]`("order-[0-9]+")) }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["someGroupCol"].`[`colsNameContains`][ColumnPath.colsNameContains]`(`[`Regex`][Regex]`("order-[0-9]+")) }` */ public fun ColumnPath.colsNameContains(regex: Regex): ColumnSet<*> = columnGroup(this).colsNameContains(regex) @@ -275,17 +275,17 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * * NOTE: For [column groups][ColumnGroup], the function is named `{@get [CommonNameStartsEndsDocs.COLS_NAME_OPERATION_NAME]}` to avoid confusion. * - * This function is a shorthand for [cols][ColumnsSelectionDsl.cols]` { it.`[name][DataColumn.name]`.`[{@get [OPERATION_NAME]}][String.{@get [OPERATION_NAME]}]`(`{@get [ARGUMENT]}{@get [ARGUMENT]}`) }`. + * This function is a shorthand for [`cols`][ColumnsSelectionDsl.cols]` { it.`[`name`][DataColumn.name]`.`[{@get [OPERATION_NAME]}][String.{@get [OPERATION_NAME]}]`(`{@get [ARGUMENT]}{@get [ARGUMENT]}`) }`. * * ### Check out: [Grammar] * * #### For example: * - * `df.`[select][DataFrame.select]` { `[{@get [NAME_OPERATION_NAME]}][ColumnsSelectionDsl.{@get [NAME_OPERATION_NAME]}]`("order") }` + * `df.`[`select`][DataFrame.select]` { `[{@get [NAME_OPERATION_NAME]}][ColumnsSelectionDsl.{@get [NAME_OPERATION_NAME]}]`("order") }` * - * `df.`[select][DataFrame.select]` { "someGroupCol".`[{@get [COLS_NAME_OPERATION_NAME]}][String.{@get [COLS_NAME_OPERATION_NAME]}]`("b") }` + * `df.`[`select`][DataFrame.select]` { "someGroupCol".`[{@get [COLS_NAME_OPERATION_NAME]}][String.{@get [COLS_NAME_OPERATION_NAME]}]`("b") }` * - * `df.`[select][DataFrame.select]` { Type::someGroupCol.`[{@get [COLS_NAME_OPERATION_NAME]}][SingleColumn.{@get [COLS_NAME_OPERATION_NAME]}]`("a", ignoreCase = true) }` + * `df.`[`select`][DataFrame.select]` { Type::someGroupCol.`[{@get [COLS_NAME_OPERATION_NAME]}][SingleColumn.{@get [COLS_NAME_OPERATION_NAME]}]`("a", ignoreCase = true) }` * * #### Examples for this overload: * @@ -342,7 +342,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [CommonNameStartsWithDocs] * @set [CommonNameStartsEndsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[nameStartsWith][ColumnSet.nameStartsWith]`("order-") }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`nameStartsWith`][ColumnSet.nameStartsWith]`("order-") }` */ @Suppress("UNCHECKED_CAST") @Interpretable("NameStartsWith0") @@ -353,7 +353,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [CommonNameStartsWithDocs] * @set [CommonNameStartsEndsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[nameStartsWith][ColumnsSelectionDsl.nameStartsWith]`("order-") }` + * `df.`[`select`][DataFrame.select]` { `[`nameStartsWith`][ColumnsSelectionDsl.nameStartsWith]`("order-") }` */ @Interpretable("NameStartsWith1") public fun ColumnsSelectionDsl<*>.nameStartsWith(prefix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*> = @@ -363,7 +363,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [CommonNameStartsWithDocs] * @set [CommonNameStartsEndsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { someGroupCol.`[colsNameStartsWith][SingleColumn.colsNameStartsWith]`("order-") }` + * `df.`[`select`][DataFrame.select]` { someGroupCol.`[`colsNameStartsWith`][SingleColumn.colsNameStartsWith]`("order-") }` */ @Interpretable("NameStartsWith2") public fun SingleColumn>.colsNameStartsWith( @@ -375,7 +375,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [CommonNameStartsWithDocs] * @set [CommonNameStartsEndsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "someGroupCol".`[colsNameStartsWith][String.colsNameStartsWith]`("order-") }` + * `df.`[`select`][DataFrame.select]` { "someGroupCol".`[`colsNameStartsWith`][String.colsNameStartsWith]`("order-") }` */ public fun String.colsNameStartsWith(prefix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*> = columnGroup(this).colsNameStartsWith(prefix, ignoreCase) @@ -384,7 +384,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [CommonNameStartsWithDocs] * @set [CommonNameStartsEndsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { DataSchemaType::someGroupCol.`[colsNameStartsWith][KProperty.colsNameStartsWith]`("order-") }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::someGroupCol.`[`colsNameStartsWith`][KProperty.colsNameStartsWith]`("order-") }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -395,7 +395,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [CommonNameStartsWithDocs] * @set [CommonNameStartsEndsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["someGroupCol"].`[colsNameStartsWith][ColumnPath.colsNameStartsWith]`("order-") }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["someGroupCol"].`[`colsNameStartsWith`][ColumnPath.colsNameStartsWith]`("order-") }` */ public fun ColumnPath.colsNameStartsWith(prefix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*> = columnGroup(this).colsNameStartsWith(prefix, ignoreCase) @@ -423,7 +423,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [CommonNameEndsWithDocs] * @set [CommonNameStartsEndsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[nameEndsWith][ColumnSet.nameEndsWith]`("-order") }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`nameEndsWith`][ColumnSet.nameEndsWith]`("-order") }` */ @Suppress("UNCHECKED_CAST") @Interpretable("NameEndsWith0") @@ -434,7 +434,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [CommonNameEndsWithDocs] * @set [CommonNameStartsEndsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[nameEndsWith][ColumnsSelectionDsl.nameEndsWith]`("-order") }` + * `df.`[`select`][DataFrame.select]` { `[`nameEndsWith`][ColumnsSelectionDsl.nameEndsWith]`("-order") }` */ @Interpretable("NameEndsWith") public fun ColumnsSelectionDsl<*>.nameEndsWith(suffix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*> = @@ -444,7 +444,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [CommonNameEndsWithDocs] * @set [CommonNameStartsEndsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { someGroupCol.`[colsNameEndsWith][SingleColumn.colsNameEndsWith]`("-order") }` + * `df.`[`select`][DataFrame.select]` { someGroupCol.`[`colsNameEndsWith`][SingleColumn.colsNameEndsWith]`("-order") }` */ @Interpretable("NameEndsWith2") public fun SingleColumn>.colsNameEndsWith( @@ -456,7 +456,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [CommonNameEndsWithDocs] * @set [CommonNameStartsEndsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "someGroupCol".`[colsNameEndsWith][String.colsNameEndsWith]`("-order") }` + * `df.`[`select`][DataFrame.select]` { "someGroupCol".`[`colsNameEndsWith`][String.colsNameEndsWith]`("-order") }` */ public fun String.colsNameEndsWith(suffix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*> = columnGroup(this).colsNameEndsWith(suffix, ignoreCase) @@ -465,7 +465,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [CommonNameEndsWithDocs] * @set [CommonNameStartsEndsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { DataSchemaType::someGroupCol.`[colsNameEndsWith][KProperty.colsNameEndsWith]`("-order") }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::someGroupCol.`[`colsNameEndsWith`][KProperty.colsNameEndsWith]`("-order") }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -476,7 +476,7 @@ public interface ColumnNameFiltersColumnsSelectionDsl { * @include [CommonNameEndsWithDocs] * @set [CommonNameStartsEndsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["someGroupCol"].`[colsNameEndsWith][ColumnPath.colsNameEndsWith]`("-order") }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["someGroupCol"].`[`colsNameEndsWith`][ColumnPath.colsNameEndsWith]`("-order") }` */ public fun ColumnPath.colsNameEndsWith(suffix: CharSequence, ignoreCase: Boolean = false): ColumnSet<*> = columnGroup(this).colsNameEndsWith(suffix, ignoreCase) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnRange.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnRange.kt index 2756c166c5..7ae5c27ba5 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnRange.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/columnRange.kt @@ -54,7 +54,7 @@ public interface ColumnRangeColumnsSelectionDsl { * * #### For example: * - * `df.`[select][DataFrame.select]` { `{@get [CommonRangeOfColumnsDocs.Example]}` }` + * `df.`[`select`][DataFrame.select]` { `{@get [CommonRangeOfColumnsDocs.Example]}` }` * * @param [endInclusive\] The last column in the subset. * @receiver The first column in the subset. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt index 241a957a59..81927d1d60 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt @@ -99,15 +99,15 @@ internal typealias SeeAlsoParse = Nothing * returns a [Convert], * which serves as an intermediate step. * The [Convert] object provides methods to transform selected columns using: - * - [to][Convert.to] - * - [with][Convert.with] - * - [asFrame][Convert.asFrame] - * - [perRowCol][Convert.perRowCol] - * - [notNull][Convert.notNull] - * - [toDataFrames][Convert.toDataFrames] + * - [`to`][Convert.to] + * - [`with`][Convert.with] + * - [`asFrame`][Convert.asFrame] + * - [`perRowCol`][Convert.perRowCol] + * - [`notNull`][Convert.notNull] + * - [`toDataFrames`][Convert.toDataFrames] * * Additionally, it offers a wide range of methods for converting to specific types, - * such as [toStr][Convert.toStr], [toDouble][Convert.toDouble], and many others. + * such as [`toStr`][Convert.toStr], [`toDouble`][Convert.toDouble], and many others. * * For the full list of supported types, see [SupportedTypes]. * @@ -139,11 +139,11 @@ internal interface ConvertDocs { * * [Int], [Long], [Float], [Double]; * * [BigDecimal], [BigInteger]; * * [LocalDateTime], [LocalDate], [LocalTime], - * `Instant` ([kotlinx.datetime][DeprecatedInstant], [kotlin.time][StdlibInstant], and [java.time]), + * `Instant` ([`kotlinx.datetime`][DeprecatedInstant], [`kotlin.time`][StdlibInstant], and [java.time]), * * [URL], [IMG], [IFRAME]. * * __NOTE__: Conversion between [Int] and [Char] is done by UTF-16 [Char.code]. - * To convert [Char]->[Int] the way it is written, use [parse()][parse] instead, or, + * To convert [Char]->[Int] the way it is written, use [`parse()`][parse] instead, or, * in either case, use [String] as intermediary type. */ typealias SupportedTypes = Nothing @@ -252,7 +252,7 @@ internal interface ConvertDocs { typealias Grammar = Nothing } -/** {@set [SelectingColumns.OPERATION] [convert][convert]} */ +/** {@set [SelectingColumns.OPERATION] [`convert`][convert]} */ @ExcludeFromSources private typealias SetConvertOperationArg = Nothing @@ -369,12 +369,12 @@ public inline fun Convert.notNull( * in the [DataFrame], but their values will be transformed. * * Use the following methods to perform the conversion: - * - [to(kType)][to]/[to`()][to] – converts columns to a specific type. - * - [asColumn { columnConverter }][asColumn] - converts columns using column converter expression. - * - [with][Convert.with] – applies a custom row-wise conversion expression. - * - [notNull][Convert.notNull] – like [with], but only for non-null values. - * - [perRowCol][Convert.perRowCol] – applies a conversion that uses both column and row information. - * - [asFrame][Convert.asFrame] – converts [column groups][ColumnGroup] as a [DataFrame] with the given expression. + * - [`to(kType)`][to]/[`to()`][to] – converts columns to a specific type. + * - [`asColumn { columnConverter }`][asColumn] - converts columns using column converter expression. + * - [`with`][Convert.with] – applies a custom row-wise conversion expression. + * - [`notNull`][Convert.notNull] – like [with], but only for non-null values. + * - [`perRowCol`][Convert.perRowCol] – applies a conversion that uses both column and row information. + * - [`asFrame`][Convert.asFrame] – converts [column groups][ColumnGroup] as a [DataFrame] with the given expression. * - [toStr], [toInt], [toLong], [toDouble], [toFloat], [toBigDecimal], * [toBigInteger], [toBoolean] – convert to standard types. * - [toLocalDateTime], [toLocalDate], [toLocalTime] – convert to kotlinx.datetime types. @@ -390,7 +390,7 @@ public class Convert( @PublishedApi internal val columns: ColumnsSelector, ) { /** - * Casts the type parameter of the columns previously selected with [convert][convert] to a new type [R], + * Casts the type parameter of the columns previously selected with [`convert`][convert] to a new type [R], * without performing any actual data transformation. * * This operation updates the static type of the selected columns for further type-safe conversions. @@ -512,7 +512,7 @@ private typealias SeeAlsoConvertAsColumn = Nothing * df.convert { colsOf() }.with { baseValue -> (baseValue * coeff).seconds } * ``` * - * @param infer [Infer] strategy that defines how the [type][DataColumn.type] of the resulting column should be determined. + * @param infer [Infer] strategy that defines how the [`type`][DataColumn.type] of the resulting column should be determined. * Defaults to [Infer.Nulls]. * @param [rowConverter] The [RowValueExpression] to provide a new value for every selected cell giving its row and previous value. * @return A new [DataFrame] with the converted values. @@ -607,7 +607,7 @@ private typealias SeeAlsoConvertWith = Nothing * } * ``` * - * @param infer [Infer] strategy that defines how the [type][DataColumn.type] of the resulting column should be determined. + * @param infer [Infer] strategy that defines how the [`type`][DataColumn.type] of the resulting column should be determined. * Defaults to [Infer.Nulls]. * @param [expression] The [RowColumnExpression] to provide a new value for every selected cell giving its row and column. */ @@ -807,10 +807,10 @@ public fun DataColumn.convertToDouble(): DataColumn = con /** * Converts values in this [String] column to [Double] considering locale (number format). * - * If any of the parameters is `null`, the global default (in [DataFrame.parser][DataFrame.Companion.parser]) is used. + * If any of the parameters is `null`, the global default (in [`DataFrame.parser`][DataFrame.Companion.parser]) is used. * * @param locale If defined, its number format is used for parsing. - * The default in [DataFrame.parser][DataFrame.Companion.parser] is the system locale. + * The default in [`DataFrame.parser`][DataFrame.Companion.parser] is the system locale. * If the column cannot be parsed, the POSIX format is used. * * @return A new [DataColumn] with the [Double] values. @@ -826,9 +826,9 @@ public fun DataColumn.convertToDouble(locale: Locale? = null): DataColum /** * @include [DataColumnStringConvertToDoubleDoc] * @param nullStrings a set of strings that should be treated as `null` values. - * The default in [DataFrame.parser][DataFrame.Companion.parser] is ["null", "NULL", "NA", "N/A"]. + * The default in [`DataFrame.parser`][DataFrame.Companion.parser] is ["null", "NULL", "NA", "N/A"]. * @param useFastDoubleParser whether to use [FastDoubleParser]. - * The default in [DataFrame.parser][DataFrame.Companion.parser] is `true`. + * The default in [`DataFrame.parser`][DataFrame.Companion.parser] is `true`. */ @JvmName("convertToDoubleFromString") public fun DataColumn.convertToDouble( @@ -846,9 +846,9 @@ public fun DataColumn.convertToDouble(locale: Locale? = null): DataColu /** * @include [DataColumnStringConvertToDoubleDoc] * @param nullStrings a set of strings that should be treated as `null` values. - * The default in [DataFrame.parser][DataFrame.Companion.parser] is ["null", "NULL", "NA", "N/A"]. + * The default in [`DataFrame.parser`][DataFrame.Companion.parser] is ["null", "NULL", "NA", "N/A"]. * @param useFastDoubleParser whether to use [FastDoubleParser]. - * The default in [DataFrame.parser][DataFrame.Companion.parser] is `true`. + * The default in [`DataFrame.parser`][DataFrame.Companion.parser] is `true`. */ @JvmName("convertToDoubleFromStringNullable") public fun DataColumn.convertToDouble( diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt index e26b9bf7fa..2ca48b827a 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convertTo.kt @@ -131,7 +131,7 @@ public class ConvertType( /** * Converts values in [DataFrame] to match given column schema [T]. * - * Original columns are mapped to destination columns by column [path][DataColumn.path]. + * Original columns are mapped to destination columns by column [`path`][DataColumn.path]. * * Type converters for every column are selected automatically. See [convert] operation for details. * @@ -166,7 +166,7 @@ public inline fun DataFrame<*>.convertTo( /** * Converts values in [DataFrame] to match given column schema [T]. * - * Original columns are mapped to destination columns by column [path][DataColumn.path]. + * Original columns are mapped to destination columns by column [`path`][DataColumn.path]. * * Type converters for every column are selected automatically. See [convert] operation for details. * @@ -203,7 +203,7 @@ public inline fun DataFrame<*>.convertTo( /** * Converts values in [DataFrame] to match given column schema [schemaType]. * - * Original columns are mapped to destination columns by column [path][DataColumn.path]. + * Original columns are mapped to destination columns by column [`path`][DataColumn.path]. * * Type converters for every column are selected automatically. See [convert] operation for details. * diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt index f8f7f80df8..ddc6aaccd8 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/corr.kt @@ -36,14 +36,14 @@ import kotlin.reflect.typeOf * it will be unpacked into suitable nested columns. * * The [Corr] object provides two methods to perform correlation calculations: - * - [with][Corr.with] — computes correlations between the initially selected columns and a second set of columns. - * - [withItself][Corr.withItself] — computes pairwise correlations within the initially selected columns. + * - [`with`][Corr.with] — computes correlations between the initially selected columns and a second set of columns. + * - [`withItself`][Corr.withItself] — computes pairwise correlations within the initially selected columns. * * Each method returns a square or rectangular correlation matrix represented by a [DataFrame], * where rows and columns correspond to the selected column sets, * and each cell contains the Pearson correlation coefficient between the corresponding pair of columns. * - * To compute correlations between all suitable columns in the [DataFrame], use [DataFrame.corr()][DataFrame.corr]. + * To compute correlations between all suitable columns in the [DataFrame], use [`DataFrame.corr()`][DataFrame.corr]. * * Check out [Grammar]. * @@ -78,7 +78,7 @@ internal interface CorrDocs { typealias Grammar = Nothing } -/** {@set [SelectingColumns.OPERATION] [corr][corr]} */ +/** {@set [SelectingColumns.OPERATION] [`corr`][corr]} */ @ExcludeFromSources private typealias SetCorrOperationArg = Nothing diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/count.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/count.kt index 0e4d0f19df..3176cae4fd 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/count.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/count.kt @@ -72,8 +72,8 @@ public fun DataFrame.count(): Int = rowsCount() * {@include [SelectingRows.RowFilterSnippet]} * * See also: - * - [filter][DataFrame.filter] — filters rows using a [RowFilter] condition. - * - [countDistinct][DataFrame.countDistinct] — counts distinct rows or values. + * - [`filter`][DataFrame.filter] — filters rows using a [RowFilter] condition. + * - [`countDistinct`][DataFrame.countDistinct] — counts distinct rows or values. * * For more information: {@include [DocumentationUrls.Count]} * @@ -106,7 +106,7 @@ public inline fun DataFrame.count(predicate: RowFilter): Int = rows(). * * This is equivalent to applying `.aggregate { count() }`, but more efficient. * - * See also [DataFrame.groupBy] and common [aggregate][Grouped.aggregate]. + * See also [DataFrame.groupBy] and common [`aggregate`][Grouped.aggregate]. * * For more information: {@include [DocumentationUrls.Count]} * @@ -139,7 +139,7 @@ public fun Grouped.count(resultName: String = "count"): DataFrame = * * This is equivalent to calling `.aggregate { count(predicate) }`, but more efficient. * - * See also [DataFrame.groupBy] and common [aggregate][Grouped.aggregate]. + * See also [DataFrame.groupBy] and common [`aggregate`][Grouped.aggregate]. * * For more information: {@include [DocumentationUrls.Count]} * @@ -175,7 +175,7 @@ public inline fun Grouped.count( * * The original [Pivot] column structure is preserved. * If the [Pivot] was created using multiple or nested keys - * (e.g., via [and][PivotDsl.and] or [then][PivotDsl.then]), + * (e.g., via [`and`][PivotDsl.and] or [`then`][PivotDsl.then]), * the structure remains unchanged — only the contents of each group * are replaced with the number of rows in that group. * @@ -183,8 +183,8 @@ public inline fun Grouped.count( * * See also: * - [pivot]. - * - common [aggregate][Pivot.aggregate]. - * - [pivotCounts][DataFrame.pivotCounts] shortcut. + * - common [`aggregate`][Pivot.aggregate]. + * - [`pivotCounts`][DataFrame.pivotCounts] shortcut. * * For more information: {@include [DocumentationUrls.Count]} * @@ -213,7 +213,7 @@ public fun Pivot.count(): DataRow = delegate { count() } * * The original [Pivot] column structure is preserved. * If the [Pivot] was created using multiple or nested keys - * (e.g., via [and][PivotDsl.and] or [then][PivotDsl.then]), + * (e.g., via [`and`][PivotDsl.and] or [`then`][PivotDsl.then]), * the structure remains unchanged — only the contents of each group * are replaced with the number of rows (matching the [predicate]) in that group. * @@ -221,8 +221,8 @@ public fun Pivot.count(): DataRow = delegate { count() } * * See also: * - [pivot]. - * - common [aggregate][Pivot.aggregate]. - * - [pivotCounts][DataFrame.pivotCounts] shortcut. + * - common [`aggregate`][Pivot.aggregate]. + * - [`pivotCounts`][DataFrame.pivotCounts] shortcut. * * For more information: {@include [DocumentationUrls.Count]} * @@ -252,7 +252,7 @@ public inline fun Pivot.count(crossinline predicate: RowFilter): DataR * * The original [Pivot] column structure is preserved. * If the [Pivot] was created using multiple or nested keys - * (e.g., via [and][PivotDsl.and] or [then][PivotDsl.then]), + * (e.g., via [`and`][PivotDsl.and] or [`then`][PivotDsl.then]), * the result will contain nested column groups reflecting that key structure, * with each group containing columns for the values of the corresponding key. * @@ -260,7 +260,7 @@ public inline fun Pivot.count(crossinline predicate: RowFilter): DataR * * See also: * - [pivot], [DataFrame.groupBy], [Pivot.groupBy] and [GroupBy.pivot]. - * - common [aggregate][PivotGroupBy.aggregate]; + * - common [`aggregate`][PivotGroupBy.aggregate]; * - [GroupBy.pivotCounts] shortcut. * * For more information: {@include [DocumentationUrls.Count]} @@ -288,7 +288,7 @@ public fun PivotGroupBy.count(): DataFrame = aggregate { count() defau * * The original [Pivot] column structure is preserved. * If the [Pivot] was created using multiple or nested keys - * (e.g., via [and][PivotDsl.and] or [then][PivotDsl.then]), + * (e.g., via [`and`][PivotDsl.and] or [`then`][PivotDsl.then]), * the result will contain nested column groups reflecting that key structure, * with each group containing columns for the values * (matching the [predicate]) of the corresponding key. @@ -297,7 +297,7 @@ public fun PivotGroupBy.count(): DataFrame = aggregate { count() defau * * See also: * - [pivot], [DataFrame.groupBy], [Pivot.groupBy] and [GroupBy.pivot]. - * - common [aggregate][PivotGroupBy.aggregate]; + * - common [`aggregate`][PivotGroupBy.aggregate]; * - [GroupBy.pivotCounts] shortcut. * * For more information: {@include [DocumentationUrls.Count]} diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt index 99dcdd7f90..917f045f4f 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt @@ -29,8 +29,8 @@ import kotlin.reflect.KProperty * the number of unique row combinations. * * See also: - * - [distinct][DataFrame.distinct], which removes duplicate rows and returns a new [DataFrame]. - * - [count][DataFrame.count], which counts the number of rows satisfying a given predicate. + * - [`distinct`][DataFrame.distinct], which removes duplicate rows and returns a new [DataFrame]. + * - [`count`][DataFrame.count], which counts the number of rows satisfying a given predicate. * * For more information: {@include [DocumentationUrls.CountDistinct]} * @@ -45,8 +45,8 @@ public fun DataFrame<*>.countDistinct(): Int = countDistinct { all() } * the number of unique values combinations. * * See also: - * - [distinct][DataFrame.distinct], which removes duplicate rows and returns a new [DataFrame]. - * - [count][DataFrame.count], which counts the number of rows satisfying a given predicate. + * - [`distinct`][DataFrame.distinct], which removes duplicate rows and returns a new [DataFrame]. + * - [`count`][DataFrame.count], which counts the number of rows satisfying a given predicate. * * For more information: {@include [DocumentationUrls.CountDistinct]} * @@ -115,10 +115,10 @@ public fun DataFrame.countDistinct(vararg columns: AnyColumnReference): I * that contains the number of distinct {@get [COMPARISON_OBJECT] rows} in each group. * * See also: - * - [aggregate][Grouped.aggregate], which aggregates a [GroupBy] using the provided statistics. - * - [count][Grouped.count], which counts the number of rows in each group. - * - [distinct][DataFrame.distinct], which removes duplicate rows and returns a new [DataFrame]. - * - [groupBy][DataFrame.groupBy], which groups the rows of a [DataFrame] + * - [`aggregate`][Grouped.aggregate], which aggregates a [GroupBy] using the provided statistics. + * - [`count`][Grouped.count], which counts the number of rows in each group. + * - [`distinct`][DataFrame.distinct], which removes duplicate rows and returns a new [DataFrame]. + * - [`groupBy`][DataFrame.groupBy], which groups the rows of a [DataFrame] * based on the values in one or more specified cols. * * For more information: {@include [DocumentationUrls.CountDistinct]} diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt index be26a77bfd..caef58cfc1 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt @@ -30,7 +30,7 @@ import kotlin.reflect.KProperty * * `cumSum` only works on columns that contain solely primitive numbers. * - * Similar to [sum][sum], [Byte][Byte]- and [Short][Short]-columns are converted to [Int][Int]. + * Similar to [`sum`][sum], [`Byte`][Byte]- and [`Short`][Short]-columns are converted to [`Int`][Int]. * * {@get [CumSumDocs.CUMSUM_PARAM] @param [columns\] The selection of the columns to apply the `cumSum` operation to. * If not provided, `cumSum` will be applied to all primitive columns [at any depth][ColumnsSelectionDsl.colsAtAnyDepth]. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt index 3d73991a98..1513cc4b1f 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt @@ -88,7 +88,7 @@ internal typealias Describe = Nothing @ExcludeFromSources internal typealias DescribeWithSelection = Nothing -/** {@set [SelectingColumns.OPERATION] [describe][describe]} */ +/** {@set [SelectingColumns.OPERATION] [`describe`][describe]} */ @ExcludeFromSources private typealias SetDescribeOperationArg = Nothing // endregion diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt index 4ad440456e..979cd1fe05 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/distinct.kt @@ -182,7 +182,7 @@ public interface DistinctColumnsSelectionDsl { * This doesn't solve [DuplicateColumnNamesException] if you've selected two columns with the same name. * For this, you'll need to [rename][ColumnsSelectionDsl.named] one of the columns. * - * See also [Grammar], [named][ColumnsSelectionDsl.named], [simplify][ColumnsSelectionDsl.simplify]. + * See also [Grammar], [`named`][ColumnsSelectionDsl.named], [`simplify`][ColumnsSelectionDsl.simplify]. * * ### Examples * ```kotlin diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt index 4bf23e4a08..6c637415f6 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/drop.kt @@ -122,9 +122,9 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropFirstDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[drop][ColumnSet.drop]`(2) }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>().`[`drop`][ColumnSet.drop]`(2) }` * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[drop][ColumnSet.drop]`(2) }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`drop`][ColumnSet.drop]`(2) }` */ @Interpretable("Drop0") public fun ColumnSet.drop(n: Int): ColumnSet = transform { it.drop(n) } @@ -133,7 +133,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropFirstDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[drop][ColumnsSelectionDsl.drop]`(5) }` + * `df.`[`select`][DataFrame.select]` { `[`drop`][ColumnsSelectionDsl.drop]`(5) }` */ @Interpretable("Drop1") public fun ColumnsSelectionDsl<*>.drop(n: Int): ColumnSet<*> = asSingleColumn().dropCols(n) @@ -142,7 +142,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropFirstDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[dropCols][SingleColumn.dropCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`dropCols`][SingleColumn.dropCols]`(1) }` */ @Interpretable("Drop2") public fun SingleColumn>.dropCols(n: Int): ColumnSet<*> = @@ -152,7 +152,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropFirstDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[dropCols][String.dropCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`dropCols`][String.dropCols]`(1) }` */ public fun String.dropCols(n: Int): ColumnSet<*> = columnGroup(this).dropCols(n) @@ -160,7 +160,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropFirstDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[dropCols][KProperty.dropCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`dropCols`][KProperty.dropCols]`(1) }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -170,7 +170,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropFirstDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[dropCols][ColumnPath.dropCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`dropCols`][ColumnPath.dropCols]`(1) }` */ public fun ColumnPath.dropCols(n: Int): ColumnSet<*> = columnGroup(this).dropCols(n) @@ -191,9 +191,9 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropLastDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[dropLast][ColumnSet.dropLast]`(2) }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>().`[`dropLast`][ColumnSet.dropLast]`(2) }` * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[dropLast][ColumnSet.dropLast]`() }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`dropLast`][ColumnSet.dropLast]`() }` */ @Interpretable("DropLast0") public fun ColumnSet.dropLast(n: Int = 1): ColumnSet = transform { it.dropLast(n) } @@ -202,7 +202,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropLastDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[dropLast][ColumnsSelectionDsl.dropLast]`(5) }` + * `df.`[`select`][DataFrame.select]` { `[`dropLast`][ColumnsSelectionDsl.dropLast]`(5) }` */ @Interpretable("DropLast1") public fun ColumnsSelectionDsl<*>.dropLast(n: Int = 1): ColumnSet<*> = this.asSingleColumn().dropLastCols(n) @@ -211,7 +211,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropLastDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[dropLastCols][SingleColumn.dropLastCols]`() }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`dropLastCols`][SingleColumn.dropLastCols]`() }` */ @Interpretable("DropLast2") public fun SingleColumn>.dropLastCols(n: Int): ColumnSet<*> = @@ -221,7 +221,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropLastDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[dropLastCols][String.dropLastCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`dropLastCols`][String.dropLastCols]`(1) }` */ public fun String.dropLastCols(n: Int): ColumnSet<*> = columnGroup(this).dropLastCols(n) @@ -229,7 +229,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropLastDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[dropLastCols][KProperty.dropLastCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`dropLastCols`][KProperty.dropLastCols]`(1) }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -239,7 +239,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropLastDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[dropLastCols][ColumnPath.dropLastCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`dropLastCols`][ColumnPath.dropLastCols]`(1) }` */ public fun ColumnPath.dropLastCols(n: Int): ColumnSet<*> = columnGroup(this).dropLastCols(n) @@ -260,9 +260,9 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[dropWhile][ColumnSet.dropWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>().`[`dropWhile`][ColumnSet.dropWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[dropWhile][ColumnSet.dropWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`dropWhile`][ColumnSet.dropWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun ColumnSet.dropWhile(predicate: (ColumnWithPath) -> Boolean): ColumnSet = transform { it.dropWhile(predicate) } @@ -271,7 +271,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[dropWhile][ColumnsSelectionDsl.dropWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { `[`dropWhile`][ColumnsSelectionDsl.dropWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` */ public fun ColumnsSelectionDsl<*>.dropWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = this.asSingleColumn().dropColsWhile(predicate) @@ -280,7 +280,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[dropColsWhile][SingleColumn.dropColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`dropColsWhile`][SingleColumn.dropColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun SingleColumn>.dropColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = this.ensureIsColumnGroup().transformSingle { it.cols().dropWhile(predicate) } @@ -289,7 +289,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[dropColsWhile][String.dropColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`dropColsWhile`][String.dropColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun String.dropColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = columnGroup(this).dropColsWhile(predicate) @@ -298,7 +298,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[dropColsWhile][KProperty.dropColsWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`dropColsWhile`][KProperty.dropColsWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -309,7 +309,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[dropColsWhile][ColumnPath.dropColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`dropColsWhile`][ColumnPath.dropColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun ColumnPath.dropColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = columnGroup(this).dropColsWhile(predicate) @@ -331,9 +331,9 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropLastWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[dropLastWhile][ColumnSet.dropLastWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>().`[`dropLastWhile`][ColumnSet.dropLastWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[dropLastWhile][ColumnSet.dropLastWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`dropLastWhile`][ColumnSet.dropLastWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun ColumnSet.dropLastWhile(predicate: (ColumnWithPath) -> Boolean): ColumnSet = transform { it.dropLastWhile(predicate) } @@ -342,7 +342,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropLastWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[dropLastWhile][ColumnsSelectionDsl.dropLastWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { `[`dropLastWhile`][ColumnsSelectionDsl.dropLastWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` */ public fun ColumnsSelectionDsl<*>.dropLastWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = this.asSingleColumn().dropLastColsWhile(predicate) @@ -351,7 +351,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropLastWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[dropLastColsWhile][SingleColumn.dropLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`dropLastColsWhile`][SingleColumn.dropLastColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun SingleColumn>.dropLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = this.ensureIsColumnGroup().transformSingle { it.cols().dropLastWhile(predicate) } @@ -360,7 +360,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropLastWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[dropLastColsWhile][String.dropLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`dropLastColsWhile`][String.dropLastColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun String.dropLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = columnGroup(this).dropLastColsWhile(predicate) @@ -369,9 +369,9 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropLastWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[dropLastColsWhile][SingleColumn.dropLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`dropLastColsWhile`][SingleColumn.dropLastColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[dropLastColsWhile][KProperty.dropLastColsWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`dropLastColsWhile`][KProperty.dropLastColsWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -382,7 +382,7 @@ public interface DropColumnsSelectionDsl { * @include [CommonDropLastWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[dropLastColsWhile][ColumnPath.dropLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`dropLastColsWhile`][ColumnPath.dropLastColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun ColumnPath.dropLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = columnGroup(this).dropLastColsWhile(predicate) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/expr.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/expr.kt index 38e9cd3a88..97548e9a01 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/expr.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/expr.kt @@ -49,12 +49,12 @@ public interface ExprColumnsSelectionDsl { * * #### For example: * - * `df.`[groupBy][DataFrame.groupBy]` { `[`expr`][ColumnsSelectionDsl.expr]` { firstName.`[`length`][String.length]` + lastName.`[`length`][String.length]` } `[`named`][named]` "nameLength" }` + * `df.`[`groupBy`][DataFrame.groupBy]` { `[`expr`][ColumnsSelectionDsl.expr]` { firstName.`[`length`][String.length]` + lastName.`[`length`][String.length]` } `[`named`][named]` "nameLength" }` * - * `df.`[sortBy][DataFrame.sortBy]` { `[`expr`][ColumnsSelectionDsl.expr]` { name.`[`length`][String.length]` }.`[`desc`][SortDsl.desc]`() }` + * `df.`[`sortBy`][DataFrame.sortBy]` { `[`expr`][ColumnsSelectionDsl.expr]` { name.`[`length`][String.length]` }.`[`desc`][SortDsl.desc]`() }` * * @param [name] The name the temporary column. Is empty by default ("untitled" in the DataFrame). - * @include [Infer.ParamDoc] By default: [Nulls][Infer.Nulls]. + * @include [Infer.ParamDoc] By default: [`Nulls`][Infer.Nulls]. * @param [expression] An [AddExpression] to define what each new row of the temporary column should contain. */ @Interpretable("Expr0") diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt index 90b09dfac8..653a8ba0b7 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/filter.kt @@ -55,8 +55,8 @@ public inline fun DataColumn.filter(predicate: Predicate): DataColumn< * For more information, see: {@include [DocumentationUrls.Filter]} * * See also: - * - [drop][DataFrame.drop], which drops rows based on values within the row. - * - [distinct][DataFrame.distinct], which filters out rows with duplicated values. + * - [`drop`][DataFrame.drop], which drops rows based on values within the row. + * - [`distinct`][DataFrame.distinct], which filters out rows with duplicated values. * * ### Example * ```kotlin @@ -137,8 +137,8 @@ public interface FilterColumnsSelectionDsl { * Creates a subset of columns ([ColumnSet]) from the current [ColumnSet] that * adhere to the given [predicate]. * - * Aside from calling [filter][ColumnSet.filter] directly, you can also use the [get][ColumnsSelectionDsl.get] operator - * in most cases. This function belongs to [cols][ColumnsSelectionDsl.cols] but operates identically. + * Aside from calling [`filter`][ColumnSet.filter] directly, you can also use the [`get`][ColumnsSelectionDsl.get] operator + * in most cases. This function belongs to [`cols`][ColumnsSelectionDsl.cols] but operates identically. * * ### Check out: [Grammar] * diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt index 352ace0bb7..2cab54aadc 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/first.kt @@ -107,11 +107,11 @@ public fun DataColumn.firstOrNull(predicate: (T) -> Boolean): T? = values /** * Returns the first [row][DataRow] in this [DataFrame]. * - * See also [firstOrNull][DataFrame.firstOrNull], - * [last][DataFrame.last], - * [take][DataFrame.take], - * [takeWhile][DataFrame.takeWhile], - * [takeLast][DataFrame.takeLast]. + * See also [`firstOrNull`][DataFrame.firstOrNull], + * [`last`][DataFrame.last], + * [`take`][DataFrame.take], + * [`takeWhile`][DataFrame.takeWhile], + * [`takeLast`][DataFrame.takeLast]. * * @return A [DataRow] containing the first row in this [DataFrame]. * @@ -127,11 +127,11 @@ public fun DataFrame.first(): DataRow { /** * Returns the first [row][DataRow] in this [DataFrame]. If the [DataFrame] does not contain any rows, returns `null`. * - * See also [first][DataFrame.first], - * [last][DataFrame.last], - * [take][DataFrame.take], - * [takeWhile][DataFrame.takeWhile], - * [takeLast][DataFrame.takeLast]. + * See also [`first`][DataFrame.first], + * [`last`][DataFrame.last], + * [`take`][DataFrame.take], + * [`takeWhile`][DataFrame.takeWhile], + * [`takeLast`][DataFrame.takeLast]. * * @return A [DataRow] containing the first row in this [DataFrame], or `null` if the [DataFrame] is empty. */ @@ -151,11 +151,11 @@ public fun DataFrame.firstOrNull(): DataRow? = if (nrow > 0) first() e * df.first { amount > 100 } * ``` * - * See also [firstOrNull][DataFrame.firstOrNull], - * [last][DataFrame.last], - * [take][DataFrame.take], - * [takeWhile][DataFrame.takeWhile], - * [takeLast][DataFrame.takeLast]. + * See also [`firstOrNull`][DataFrame.firstOrNull], + * [`last`][DataFrame.last], + * [`take`][DataFrame.take], + * [`takeWhile`][DataFrame.takeWhile], + * [`takeLast`][DataFrame.takeLast]. * * @param [predicate] A [row filter][RowFilter] used to get the first value * that satisfies a condition specified in this filter. @@ -186,11 +186,11 @@ public inline fun DataFrame.first(predicate: RowFilter): DataRow = * df.firstOrNull { amount > 100 } * ``` * - * See also [first][DataFrame.first], - * [last][DataFrame.last], - * [take][DataFrame.take], - * [takeWhile][DataFrame.takeWhile], - * [takeLast][DataFrame.takeLast]. + * See also [`first`][DataFrame.first], + * [`last`][DataFrame.last], + * [`take`][DataFrame.take], + * [`takeWhile`][DataFrame.takeWhile], + * [`takeLast`][DataFrame.takeLast]. * * @param [predicate] A [row filter][RowFilter] used to get the first value * that satisfies a condition specified in this filter. @@ -224,7 +224,7 @@ public inline fun DataFrame.firstOrNull(predicate: RowFilter): DataRow * df.groupBy { customerId }.first().concat() * ``` * - * See also [last][GroupBy.last]. + * See also [`last`][GroupBy.last]. * * @return A [ReducedGroupBy] containing the first [row][DataRow] * (or a [row][DataRow] with `null` values, except the grouping key) from each group. @@ -253,7 +253,7 @@ public fun GroupBy.first(): ReducedGroupBy = reduce { firstOr * df.groupBy { customerId }.first { total > 100 }.concat() * ``` * - * See also [last][GroupBy.last]. + * See also [`last`][GroupBy.last]. * * @param [predicate] A [row filter][RowFilter] used to get the first value * that satisfies a condition specified in this filter. @@ -281,7 +281,7 @@ public fun GroupBy.first(predicate: RowFilter): ReducedGroupBy Pivot.first(): ReducedPivot = reduce { firstOrNull() } * df.pivot { type }.first { !soldOut }.values() * ``` * - * See also [pivot], [reduce][Pivot.reduce], [last][Pivot.last]. + * See also [pivot], [`reduce`][Pivot.reduce], [`last`][Pivot.last]. * * @param [predicate] A [row filter][RowFilter] used to get the first value * that satisfies a condition specified in this filter. @@ -337,10 +337,10 @@ public fun Pivot.first(predicate: RowFilter): ReducedPivot = reduce * df.pivot { type }.groupBy { city }.first().values() * ``` * - * See also [groupBy][Pivot.groupBy], - * [pivot][GroupBy.pivot], - * [reduce][PivotGroupBy.reduce], - * [last][PivotGroupBy.last]. + * See also [`groupBy`][Pivot.groupBy], + * [`pivot`][GroupBy.pivot], + * [`reduce`][PivotGroupBy.reduce], + * [`last`][PivotGroupBy.last]. * * @return A [ReducedPivotGroupBy] containing in each combination of a [groupBy] key and a [pivot] key either * the first [row][DataRow] of the corresponding [DataFrame] formed by this pivot–group pair, @@ -375,10 +375,10 @@ public fun PivotGroupBy.first(): ReducedPivotGroupBy = reduce { firstO * df.pivot { type }.groupBy { city }.first { !soldOut }.values() * ``` * - * See also [groupBy][Pivot.groupBy], - * [pivot][GroupBy.pivot], - * [reduce][PivotGroupBy.reduce], - * [last][PivotGroupBy.last]. + * See also [`groupBy`][Pivot.groupBy], + * [`pivot`][GroupBy.pivot], + * [`reduce`][PivotGroupBy.reduce], + * [`last`][PivotGroupBy.last]. * * @param [predicate] A [row filter][RowFilter] used to get the first value * that satisfies a condition specified in this filter. @@ -451,9 +451,9 @@ public interface FirstColumnsSelectionDsl { * * #### Examples: * - * `df.`[select][DataFrame.select]` { `[first][ColumnsSelectionDsl.first]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }` + * `df.`[`select`][DataFrame.select]` { `[`first`][ColumnsSelectionDsl.first]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("order") } }` * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[firstCol][String.firstCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`firstCol`][String.firstCol]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` * * #### Examples for this overload: * @@ -474,9 +474,9 @@ public interface FirstColumnsSelectionDsl { /** * @include [CommonFirstDocs] * @set [CommonFirstDocs.Examples] - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[first][ColumnSet.first]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>().`[`first`][ColumnSet.first]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[first][ColumnSet.first]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`first`][ColumnSet.first]`() }` */ @Suppress("UNCHECKED_CAST") @Interpretable("First0") @@ -489,7 +489,7 @@ public interface FirstColumnsSelectionDsl { * @include [CommonFirstDocs] * @set [CommonFirstDocs.Examples] * - * `df.`[select][DataFrame.select]` { `[first][ColumnsSelectionDsl.first]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { `[`first`][ColumnsSelectionDsl.first]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` */ @Interpretable("First1") public fun ColumnsSelectionDsl<*>.first(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*> = @@ -499,7 +499,7 @@ public interface FirstColumnsSelectionDsl { * @include [CommonFirstDocs] * @set [CommonFirstDocs.Examples] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[firstCol][SingleColumn.firstCol]`() }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`firstCol`][SingleColumn.firstCol]`() }` */ @Interpretable("First2") public fun SingleColumn>.firstCol( @@ -509,7 +509,7 @@ public interface FirstColumnsSelectionDsl { /** * @include [CommonFirstDocs] * @set [CommonFirstDocs.Examples] - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[firstCol][String.firstCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`firstCol`][String.firstCol]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` */ public fun String.firstCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*> = columnGroup(this).firstCol(condition) @@ -517,9 +517,9 @@ public interface FirstColumnsSelectionDsl { /** * @include [CommonFirstDocs] * @set [CommonFirstDocs.Examples] - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[firstCol][SingleColumn.firstCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`firstCol`][SingleColumn.firstCol]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[firstCol][KProperty.firstCol]`() }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`firstCol`][KProperty.firstCol]`() }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -529,7 +529,7 @@ public interface FirstColumnsSelectionDsl { /** * @include [CommonFirstDocs] * @set [CommonFirstDocs.Examples] - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[firstCol][ColumnPath.firstCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`firstCol`][ColumnPath.firstCol]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` */ public fun ColumnPath.firstCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*> = columnGroup(this).firstCol(condition) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt index a216bdead0..9d91ca6859 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/flatten.kt @@ -46,7 +46,7 @@ private interface FlattenDocs { typealias GROUPS = Nothing /** - * @include [SelectingColumns] {@set [SelectingColumns.OPERATION] [flatten][flatten]} + * @include [SelectingColumns] {@set [SelectingColumns.OPERATION] [`flatten`][flatten]} */ typealias FlattenSelectingOptions = Nothing } diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/format.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/format.kt index 306308ed20..481203d2f4 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/format.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/format.kt @@ -65,11 +65,11 @@ import kotlin.reflect.KProperty * See [Selecting Columns][FormatSelectingColumns]. * * The [FormatClause] allows to further narrow down the selection to individual cells - * by selecting only certain rows, using [where][FormatClause.where], + * by selecting only certain rows, using [`where`][FormatClause.where], * and then finally specify how to format the cells using - * [with][FormatClause.with], [perRowCol][FormatClause.perRowCol], or [linearBg][FormatClause.linearBg]. + * [`with`][FormatClause.with], [`perRowCol`][FormatClause.perRowCol], or [`linearBg`][FormatClause.linearBg]. * - * You can continue formatting the [FormattedFrame] by calling [format][FormattedFrame.format] on it again. + * You can continue formatting the [FormattedFrame] by calling [`format`][FormattedFrame.format] on it again. * * Specifying a [column group][ColumnGroup] makes all of its inner columns be formatted in the same way unless * overridden. @@ -121,7 +121,7 @@ internal interface FormatDocs { * `\[ `__`.`__[**`where`**][FormatClause.where]**` { `**[`filter`][SelectingRows.RowValueCondition]`: `[`RowValueFilter`][RowValueFilter]**` } `**`]` * * {@include [Indent]} - * `\[ `__`.`__[**`at`**][FormatClause.at]**`(`**`rowIndices: `[Collection][Collection]`<`[Int][Int]`> | `[IntRange][IntRange]` | `**`vararg`**` `[Int][Int]**`)`**` ]` + * `\[ `__`.`__[**`at`**][FormatClause.at]**`(`**`rowIndices: `[`Collection`][Collection]`<`[`Int`][Int]`> | `[`IntRange`][IntRange]` | `**`vararg`**` `[`Int`][Int]**`)`**` ]` * * {@include [Indent]} * `\[ `__`.`__[**`notNull`**][FormatClause.notNull]**`()`**` ]` @@ -136,7 +136,7 @@ internal interface FormatDocs { * `| `__`.`__[**`perRowCol`**][FormatClause.perRowCol]**` { `**{@include [RowColFormatterRef]}**` }`** * * {@include [Indent]} - * `| `__`.`__[**`linearBg`**][FormatClause.linearBg]**`(`**`from: `[Pair][Pair]`<`[Number][Number]`, `[RgbColor][RgbColor]`>`**`,`**` to: `[Pair][Pair]`<`[Number][Number]`, `[RgbColor][RgbColor]`>`**`)`** + * `| `__`.`__[**`linearBg`**][FormatClause.linearBg]**`(`**`from: `[`Pair`][Pair]`<`[`Number`][Number]`, `[`RgbColor`][RgbColor]`>`**`,`**` to: `[`Pair`][Pair]`<`[`Number`][Number]`, `[`RgbColor`][RgbColor]`>`**`)`** * * `\[ `__`.`__[**format**][FormattedFrame.format]` ↺ \]` * {@include [LineBreak]} @@ -155,7 +155,7 @@ internal interface FormatDocs { * {@include [RgbColorDef]} * * ### Notation: - * _- Returning [CellAttributes][CellAttributes]_: + * _- Returning [`CellAttributes`][CellAttributes]_: * * {@include [CellAttributesRef]}` `[**`and`**][CellAttributes.and]` `{@include [CellAttributesRef]} * @@ -163,69 +163,69 @@ internal interface FormatDocs { * * `| `[**`background`**][FormattingDsl.background]**`(`**{@include [RgbColorRef]}**`)`** * - * `| `[**`background`**][FormattingDsl.background]**`(`**`r: `[Short][Short]**`,`**` g: `[Short][Short]**`,`**` b: `[Short][Short]**`)`** + * `| `[**`background`**][FormattingDsl.background]**`(`**`r: `[`Short`][Short]**`,`**` g: `[`Short`][Short]**`,`**` b: `[`Short`][Short]**`)`** * - * `| `[**`linearBg`**][FormattingDsl.linearBg]**`(`**`value: `[Number][Number]**`,`**` from: `[Pair][Pair]`<`[Number][Number]`, `[RgbColor][RgbColor]`>`**`,`**` to: `[Pair][Pair]`<`[Number][Number]`, `[RgbColor][RgbColor]`>`**`)`** + * `| `[**`linearBg`**][FormattingDsl.linearBg]**`(`**`value: `[`Number`][Number]**`,`**` from: `[`Pair`][Pair]`<`[`Number`][Number]`, `[`RgbColor`][RgbColor]`>`**`,`**` to: `[`Pair`][Pair]`<`[`Number`][Number]`, `[`RgbColor`][RgbColor]`>`**`)`** * * `| `[**`textColor`**][FormattingDsl.textColor]**`(`**{@include [RgbColorRef]}**`)`** * - * `| `[**`textColor`**][FormattingDsl.textColor]**`(`**`r: `[Short][Short]**`,`**` g: `[Short][Short]**`,`**` b: `[Short][Short]**`)`** + * `| `[**`textColor`**][FormattingDsl.textColor]**`(`**`r: `[`Short`][Short]**`,`**` g: `[`Short`][Short]**`,`**` b: `[`Short`][Short]**`)`** * - * `| `[**`attr`**][attr]**`(`**`name: `[String][String]**`,`**` value: `[String][String]**`)`** + * `| `[**`attr`**][attr]**`(`**`name: `[`String`][String]**`,`**` value: `[`String`][String]**`)`** * - * _- Returning [RgbColor][RgbColor]:_ + * _- Returning [`RgbColor`][RgbColor]:_ * * [**`black`**][FormattingDsl.black]` | `[**`white`**][FormattingDsl.white]` | `[**`green`**][FormattingDsl.green]` | `[**`red`**][FormattingDsl.red]` | `[**`blue`**][FormattingDsl.blue]` | `[**`gray`**][FormattingDsl.gray]` | `[**`darkGray`**][FormattingDsl.darkGray]` | `[**`lightGray`**][FormattingDsl.lightGray] * - * `| `[**`rgb`**][FormattingDsl.rgb]**`(`**`r: `[Short][Short]**`,`**` g: `[Short][Short]**`,`**` b: `[Short][Short]**`)`** + * `| `[**`rgb`**][FormattingDsl.rgb]**`(`**`r: `[`Short`][Short]**`,`**` g: `[`Short`][Short]**`,`**` b: `[`Short`][Short]**`)`** * - * `| `[**`linear`**][FormattingDsl.linear]**`(`**`value: `[Number][Number]**`,`**` from: `[Pair][Pair]`<`[Number][Number]`, `[RgbColor][RgbColor]`>`**`,`**` to: `[Pair][Pair]`<`[Number][Number]`, `[RgbColor][RgbColor]`>`**`)`** + * `| `[**`linear`**][FormattingDsl.linear]**`(`**`value: `[`Number`][Number]**`,`**` from: `[`Pair`][Pair]`<`[`Number`][Number]`, `[`RgbColor`][RgbColor]`>`**`,`**` to: `[`Pair`][Pair]`<`[`Number`][Number]`, `[`RgbColor`][RgbColor]`>`**`)`** */ typealias FormattingDslGrammarDef = Nothing /** - * `cellFormatter: `{@include [FormattingDslGrammarRef]}`.(cell: C) -> `[CellAttributes][CellAttributes]`?` + * `cellFormatter: `{@include [FormattingDslGrammarRef]}`.(cell: C) -> `[`CellAttributes`][CellAttributes]`?` */ typealias CellFormatterDef = Nothing /** - * `rowColFormatter: `{@include [FormattingDslGrammarRef]}`.(row: `[DataRow][DataRow]`, col: `[ColumnWithPath][ColumnWithPath]`) -> `[CellAttributes][CellAttributes]`?` + * `rowColFormatter: `{@include [FormattingDslGrammarRef]}`.(row: `[`DataRow`][DataRow]`, col: `[`ColumnWithPath`][ColumnWithPath]`) -> `[`CellAttributes`][CellAttributes]`?` */ typealias RowColFormatterDef = Nothing /** - * `cellAttributes: `[CellAttributes][CellAttributes] + * `cellAttributes: `[`CellAttributes`][CellAttributes] */ typealias CellAttributesDef = Nothing /** - * `color: `[RgbColor][RgbColor] + * `color: `[`RgbColor`][RgbColor] */ typealias RgbColorDef = Nothing - /** [cellFormatter][CellFormatterDef] */ + /** [`cellFormatter`][CellFormatterDef] */ @ExcludeFromSources typealias CellFormatterRef = Nothing - /** [rowColFormatter][RowColFormatterDef] */ + /** [`rowColFormatter`][RowColFormatterDef] */ @ExcludeFromSources typealias RowColFormatterRef = Nothing - /** [FormattingDsl][FormattingDslGrammarDef] */ + /** [`FormattingDsl`][FormattingDslGrammarDef] */ @ExcludeFromSources typealias FormattingDslGrammarRef = Nothing - /** [cellAttributes][CellAttributesDef] */ + /** [`cellAttributes`][CellAttributesDef] */ @ExcludeFromSources typealias CellAttributesRef = Nothing - /** [color][RgbColorDef] */ + /** [`color`][RgbColorDef] */ @ExcludeFromSources typealias RgbColorRef = Nothing } } -/** {@set [SelectingColumns.OPERATION] [format][format]} */ +/** {@set [SelectingColumns.OPERATION] [`format`][format]} */ @ExcludeFromSources private typealias SetFormatOperationArg = Nothing @@ -380,7 +380,7 @@ public fun FormattedFrame.format(): FormatClause = FormatClause( * * You need to specify [filter]: A lambda function expecting a `true` result for each * cell that should be included in the formatting selection. - * Both the cell value (`it: `[C][C]) and its row (`this: `[DataRow][DataRow]`<`[T][T]`>`) are available. + * Both the cell value (`it: `[`C`][C]) and its row (`this: `[`DataRow`][DataRow]`<`[`T`][T]`>`) are available. * * ### Examples using [where]: * ```kt @@ -446,7 +446,7 @@ public fun FormatClause.at(rowRange: IntRange): FormatClause /** * Filters the format-selection to only include cells where the value is not null. * - * This is shorthand for `.`[where][FormatClause.where]` { it != null }`. + * This is shorthand for `.`[`where`][FormatClause.where]` { it != null }`. * * ### Examples using [notNull]: * ```kt @@ -500,7 +500,7 @@ public fun FormatClause.with(formatter: CellFormatter): Formatte /** * Creates a new [FormattedFrame] that uses the specified [CellFormatter] to format selected non-null cells of the dataframe. * - * This function is shorthand for `.`[notNull()][FormatClause.notNull]`.`[with { }][FormatClause.with]. + * This function is shorthand for `.`[`notNull()`][FormatClause.notNull]`.`[`with { }`][FormatClause.with]. * * You need to specify [formatter]: {@include [CellFormatter]} * @@ -525,9 +525,9 @@ public fun FormatClause.notNull(formatter: CellFormatter): Form * * This function is shorthand for: * - * `.`[with][FormatClause.with]` { `[background][FormattingDsl.background]`(`[linear][FormattingDsl.linear]`(it, `[from][from]`, `[to][to]`)) }` + * `.`[`with`][FormatClause.with]` { `[`background`][FormattingDsl.background]`(`[`linear`][FormattingDsl.linear]`(it, `[`from`][from]`, `[`to`][to]`)) }` * - * See also [with][FormatClause.with], [background][FormattingDsl.background], and [linear][FormattingDsl.linear]. + * See also [`with`][FormatClause.with], [`background`][FormattingDsl.background], and [`linear`][FormattingDsl.linear]. * * ### Examples using [linearBg]: * ```kt @@ -566,8 +566,8 @@ public fun FormatClause.linearBg( * * Any color can be represented in terms of [r] (red), [g] (green), and [b] (blue) values from `0..255`. * - * Inside [FormattingDsl], there are shortcuts for common colors, like [white][FormattingDsl.white], - * [green][FormattingDsl.green], and [gray][FormattingDsl.gray]. + * Inside [FormattingDsl], there are shortcuts for common colors, like [`white`][FormattingDsl.white], + * [`green`][FormattingDsl.green], and [`gray`][FormattingDsl.gray]. */ public data class RgbColor(val r: Short, val g: Short, val b: Short) { @@ -585,7 +585,7 @@ public data class RgbColor(val r: Short, val g: Short, val b: Short) { * * For instance: * - * `df.`[format()][DataFrame.format]`.`[`with {`][FormatClause.with]` `[background][FormattingDsl.background]`(`[white][FormattingDsl.white]`) `[and][CellAttributes.and]` `[textColor][FormattingDsl.textColor]`(`[black][FormattingDsl.black]`) `[`}`][FormatClause.with] + * `df.`[`format()`][DataFrame.format]`.`[`with {`][FormatClause.with]` `[`background`][FormattingDsl.background]`(`[`white`][FormattingDsl.white]`) `[`and`][CellAttributes.and]` `[`textColor`][FormattingDsl.textColor]`(`[`black`][FormattingDsl.black]`) `[`}`][FormatClause.with] * * @see [CellAttributes.and] */ @@ -600,7 +600,7 @@ public interface CellAttributes { * * For instance: * - * `df.`[format()][DataFrame.format]`.`[`with {`][FormatClause.with]` `[background][FormattingDsl.background]`(`[white][FormattingDsl.white]`) `[and][CellAttributes.and]` `[textColor][FormattingDsl.textColor]`(`[black][FormattingDsl.black]`) `[`}`][FormatClause.with] + * `df.`[`format()`][DataFrame.format]`.`[`with {`][FormatClause.with]` `[`background`][FormattingDsl.background]`(`[`white`][FormattingDsl.white]`) `[`and`][CellAttributes.and]` `[`textColor`][FormattingDsl.textColor]`(`[`black`][FormattingDsl.black]`) `[`}`][FormatClause.with] */ public infix fun CellAttributes?.and(other: CellAttributes?): CellAttributes? = when { @@ -616,12 +616,12 @@ public infix fun CellAttributes?.and(other: CellAttributes?): CellAttributes? = * * For instance, to specify black, bold text on a white background, you could write: * - * [background][FormattingDsl.background]`(`[white][FormattingDsl.white]`) `[and][CellAttributes.and]` ` - * [textColor][FormattingDsl.textColor]`(`[black][FormattingDsl.black]`) `[and][CellAttributes.and]` ` - * [bold][FormattingDsl.bold] + * [`background`][FormattingDsl.background]`(`[`white`][FormattingDsl.white]`) `[`and`][CellAttributes.and]` ` + * [`textColor`][FormattingDsl.textColor]`(`[`black`][FormattingDsl.black]`) `[`and`][CellAttributes.and]` ` + * [`bold`][FormattingDsl.bold] * - * It's also possible to define your own colors using [rgb][FormattingDsl.rgb] or interpolate - * colors using [linear][FormattingDsl.linear]. + * It's also possible to define your own colors using [`rgb`][FormattingDsl.rgb] or interpolate + * colors using [`linear`][FormattingDsl.linear]. * * Use [attr] if you want to specify a custom CSS attribute. */ @@ -660,26 +660,26 @@ public object FormattingDsl { /** * A [cell attribute][CellAttributes] that sets the background color of a cell. - * @param color Either one of the predefined colors, like [black], or [green], or a custom color using [rgb()][rgb]. + * @param color Either one of the predefined colors, like [black], or [green], or a custom color using [`rgb()`][rgb]. */ public fun background(color: RgbColor): CellAttributes = attr("background-color", color.toString()) /** * A [cell attribute][CellAttributes] that sets the background color of a cell. - * A shortcut for [background][background]`(`[rgb(...)][rgb]`)`. + * A shortcut for [`background`][background]`(`[`rgb(...)`][rgb]`)`. * @see [rgb] */ public fun background(r: Short, g: Short, b: Short): CellAttributes = background(RgbColor(r, g, b)) /** * A [cell attribute][CellAttributes] that sets the text color of a cell. - * @param color Either one of the predefined colors, like [black], or [green], or a custom color using [rgb()][rgb]. + * @param color Either one of the predefined colors, like [black], or [green], or a custom color using [`rgb()`][rgb]. */ public fun textColor(color: RgbColor): CellAttributes = attr("color", color.toString()) /** * A [cell attribute][CellAttributes] that sets the text color of a cell. - * A shortcut for [textColor][textColor]`(`[rgb(...)][rgb]`)`. + * A shortcut for [`textColor`][textColor]`(`[`rgb(...)`][rgb]`)`. * @see [rgb] */ public fun textColor(r: Short, g: Short, b: Short): CellAttributes = textColor(RgbColor(r, g, b)) @@ -694,7 +694,7 @@ public object FormattingDsl { public val underline: CellAttributes = attr("text-decoration", "underline") /** - * Shorthand for [background][background]`(`[linear][linear]`(...))` + * Shorthand for [`background`][background]`(`[`linear`][linear]`(...))` * * Creates a [cell attribute][CellAttributes] that applies a background color calculated * by interpolating between [from] and [to], given [value]. @@ -759,7 +759,7 @@ public object FormattingDsl { /** * A lambda function expecting a [CellAttributes] or `null` given an instance of - * [DataRow][DataRow]`<`[T][T]`>` and [ColumnWithPath][ColumnWithPath]`<`[C][C]`>`. + * [`DataRow`][DataRow]`<`[`T`][T]`>` and [`ColumnWithPath`][ColumnWithPath]`<`[`C`][C]`>`. * * This is similar to a [RowColumnExpression], except that you also have access * to the [FormattingDsl] in the context. @@ -778,7 +778,7 @@ public typealias RowColFormatter = FormattingDsl.(row: DataRow, col: Co public typealias CellFormatter = FormattingDsl.(cell: C) -> CellAttributes? /** - * A wrapper around a [DataFrame][df] with CSS attributes that can be + * A wrapper around a [`DataFrame`][df] with CSS attributes that can be * converted to a formatted HTML table in the form of [DataFrameHtmlData]. * * Call [toHtml] or [toStandaloneHtml] to get the HTML representation of the [DataFrame]. @@ -786,7 +786,7 @@ public typealias CellFormatter = FormattingDsl.(cell: C) -> CellAttributes? * In Jupyter kernel (Kotlin Notebook) environments, you can often output this class directly. * Use [toHtml] or [toStandaloneHtml] when this produces unexpected results. * - * You can apply further formatting to this [FormattedFrame] by calling [format()][FormattedFrame.format] once again. + * You can apply further formatting to this [FormattedFrame] by calling [`format()`][FormattedFrame.format] once again. */ public class FormattedFrame( internal val df: DataFrame, @@ -802,7 +802,7 @@ public class FormattedFrame( * Use [toStandaloneHtml] if you need the [DataFrameHtmlData] to include CSS- and script definitions. * * By default, cell content is formatted as text - * Use [RenderedContent.media][media] or [IMG], [IFRAME] if you need custom HTML inside a cell. + * Use [`RenderedContent.media`][media] or [IMG], [IFRAME] if you need custom HTML inside a cell. * * @param [configuration] The [DisplayConfiguration] to use as a base for this [FormattedFrame]. * Default: [DisplayConfiguration.DEFAULT]. @@ -828,7 +828,7 @@ public class FormattedFrame( * feature of IntelliJ IDEA will automatically reload the file content when it's updated. * * By default, cell content is formatted as text - * Use [RenderedContent.media][media] or [IMG], [IFRAME] if you need custom HTML inside a cell. + * Use [`RenderedContent.media`][media] or [IMG], [IFRAME] if you need custom HTML inside a cell. * * __NOTE:__ In Kotlin Notebook, output [FormattedFrame] directly, or use [toHtml], * as that environment already has CSS- and script definitions for DataFrame. @@ -865,18 +865,18 @@ public class FormattedFrame( * to produce a new [FormattedFrame]; a [DataFrame] with HTML formatting data. * * Use the following function to filter the rows to format: - * - [where][FormatClause.where] – filters the rows to format using a [RowValueFilter]. - * - [at][FormatClause.at] – Only format in rows with certain indices. - * - [notNull][FormatClause.notNull] – Only format cells that have non-null values. + * - [`where`][FormatClause.where] – filters the rows to format using a [RowValueFilter]. + * - [`at`][FormatClause.at] – Only format in rows with certain indices. + * - [`notNull`][FormatClause.notNull] – Only format cells that have non-null values. * * Use the following functions to finalize this formatting round: - * - [with][FormatClause.with] – Specifies how to format the cells using a [CellFormatter]. - * - [perRowCol][FormatClause.perRowCol] – Specifies how to format each cell individually using a [RowColFormatter]. - * - [linearBg][FormatClause.linearBg] – + * - [`with`][FormatClause.with] – Specifies how to format the cells using a [CellFormatter]. + * - [`perRowCol`][FormatClause.perRowCol] – Specifies how to format each cell individually using a [RowColFormatter]. + * - [`linearBg`][FormatClause.linearBg] – * Interpolates between two colors to set the background color of each numeric cell based on its value. - * Shorthand for `.`[with][FormatClause.with]` { `[background][FormattingDsl.background]`(`[linear][FormattingDsl.linear]`(it, from, to)) }` - * - [notNull][FormatClause.notNull] – Specifies how to format non-null cells using a [CellFormatter]. - * Shorthand for `.`[notNull()][FormatClause.notNull]`.`[with { }][FormatClause.with]. + * Shorthand for `.`[`with`][FormatClause.with]` { `[`background`][FormattingDsl.background]`(`[`linear`][FormattingDsl.linear]`(it, from, to)) }` + * - [`notNull`][FormatClause.notNull] – Specifies how to format non-null cells using a [CellFormatter]. + * Shorthand for `.`[`notNull()`][FormatClause.notNull]`.`[`with { }`][FormatClause.with]. * * See [Grammar][FormatDocs.Grammar] for more details. */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt index bbeaadbfff..f4956fb14b 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCol.kt @@ -93,20 +93,20 @@ public interface FrameColColumnsSelectionDsl { * * #### For example: * - * `df.`[select][DataFrame.select]` { `[frameCol][frameCol]`<`[String][String]`>("frameColA") }` + * `df.`[`select`][DataFrame.select]` { `[`frameCol`][frameCol]`<`[`String`][String]`>("frameColA") }` * - * `df.`[select][DataFrame.select]` { `[frameCol][frameCol]`(SomeType::frameColB) }` + * `df.`[`select`][DataFrame.select]` { `[`frameCol`][frameCol]`(SomeType::frameColB) }` * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[frameCol][frameCol]`(1) }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`frameCol`][frameCol]`(1) }` * * #### Examples for this overload: * * {@get [CommonFrameColDocs.EXAMPLE]} * * To create a [ColumnAccessor] for another kind of column, take a look at the functions - * [col][ColumnsSelectionDsl.col], - * [colGroup][ColumnsSelectionDsl.colGroup], - * and [valueCol][ColumnsSelectionDsl.valueCol]. + * [`col`][ColumnsSelectionDsl.col], + * [`colGroup`][ColumnsSelectionDsl.colGroup], + * and [`valueCol`][ColumnsSelectionDsl.valueCol]. * * @return A [ColumnAccessor] for the frame column with the given argument if possible, else a [SingleColumn]. * @throws [IllegalStateException\] if the column with the given argument does not exist. @@ -123,14 +123,14 @@ public interface FrameColColumnsSelectionDsl { typealias EXAMPLE = Nothing /** - * `df.`[select][DataFrame.select]` { {@get [CommonFrameColDocs.RECEIVER]}`[frameCol][frameCol]`({@get [CommonFrameColDocs.ARG]}) \}` + * `df.`[`select`][DataFrame.select]` { {@get [CommonFrameColDocs.RECEIVER]}`[`frameCol`][frameCol]`({@get [CommonFrameColDocs.ARG]}) \}` */ typealias SingleExample = Nothing /** - * `df.`[select][DataFrame.select]` { {@get [CommonFrameColDocs.RECEIVER]}`[frameCol][frameCol]`({@get [CommonFrameColDocs.ARG]}) \}` + * `df.`[`select`][DataFrame.select]` { {@get [CommonFrameColDocs.RECEIVER]}`[`frameCol`][frameCol]`({@get [CommonFrameColDocs.ARG]}) \}` * - * `df.`[select][DataFrame.select]` { {@get [CommonFrameColDocs.RECEIVER]}`[frameCol][frameCol]`<`[String][String]`>({@get [CommonFrameColDocs.ARG]}) \}` + * `df.`[`select`][DataFrame.select]` { {@get [CommonFrameColDocs.RECEIVER]}`[`frameCol`][frameCol]`<`[`String`][String]`>({@get [CommonFrameColDocs.ARG]}) \}` */ typealias DoubleExample = Nothing @@ -551,7 +551,7 @@ public interface FrameColColumnsSelectionDsl { private typealias FrameColIndexDocs = Nothing /** - * @include [FrameColIndexDocs] {@set [CommonFrameColDocs.RECEIVER] `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().} + * @include [FrameColIndexDocs] {@set [CommonFrameColDocs.RECEIVER] `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>().} * @include [CommonFrameColDocs.FrameColumnTypeParam] * {@set [CommonFrameColDocs.EXAMPLE] {@include [CommonFrameColDocs.SingleExample]}} */ @@ -561,7 +561,7 @@ public interface FrameColColumnsSelectionDsl { getAt(index).ensureIsFrameColumn() /** - * @include [FrameColIndexDocs] {@set [CommonFrameColDocs.RECEIVER] `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().} + * @include [FrameColIndexDocs] {@set [CommonFrameColDocs.RECEIVER] `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>().} * @include [CommonFrameColDocs.FrameColumnTypeParam] * {@set [CommonFrameColDocs.EXAMPLE] {@include [CommonFrameColDocs.SingleExample]}} */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCols.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCols.kt index 0b26ee5e87..b15180dd97 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCols.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/frameCols.kt @@ -78,11 +78,11 @@ public interface FrameColsColumnsSelectionDsl { * * #### For example: * - * `df.`[select][DataFrame.select]` { `[frameCols][SingleColumn.frameCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`frameCols`][SingleColumn.frameCols]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` * - * `df.`[select][DataFrame.select]` { `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().`[frameCols][SingleColumn.frameCols]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]`().`[`frameCols`][SingleColumn.frameCols]`() }` * - * `df.`[select][DataFrame.select]` { "myColGroup".`[frameCols][String.frameCols]`() }` + * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`frameCols`][String.frameCols]`() }` * * #### Examples for this overload: * @@ -105,11 +105,11 @@ public interface FrameColsColumnsSelectionDsl { * @include [CommonFrameColsDocs] * @set [CommonFrameColsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") }.`[frameCols][ColumnSet.frameCols]`() }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") }.`[`frameCols`][ColumnSet.frameCols]`() }` * * `// NOTE: This can be shortened to just:` * - * `df.`[select][DataFrame.select]` { `[frameCols][ColumnsSelectionDsl.frameCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`frameCols`][ColumnsSelectionDsl.frameCols]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ @Interpretable("FrameCols0") public fun ColumnSet<*>.frameCols(filter: Predicate> = { true }): ColumnSet> = @@ -119,9 +119,9 @@ public interface FrameColsColumnsSelectionDsl { * @include [CommonFrameColsDocs] * @set [CommonFrameColsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[frameCols][ColumnsSelectionDsl.frameCols]`() }` + * `df.`[`select`][DataFrame.select]` { `[`frameCols`][ColumnsSelectionDsl.frameCols]`() }` * - * `df.`[select][DataFrame.select]` { `[frameCols][ColumnsSelectionDsl.frameCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`frameCols`][ColumnsSelectionDsl.frameCols]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ @Interpretable("FrameCols1") public fun ColumnsSelectionDsl<*>.frameCols( @@ -132,9 +132,9 @@ public interface FrameColsColumnsSelectionDsl { * @include [CommonFrameColsDocs] * @set [CommonFrameColsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColGroup.`[frameCols][SingleColumn.frameCols]`() }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`frameCols`][SingleColumn.frameCols]`() }` * - * `df.`[select][DataFrame.select]` { myColGroup.`[frameCols][SingleColumn.frameCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`frameCols`][SingleColumn.frameCols]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ @Interpretable("FrameCols2") public fun SingleColumn>.frameCols( @@ -145,9 +145,9 @@ public interface FrameColsColumnsSelectionDsl { * @include [CommonFrameColsDocs] * @set [CommonFrameColsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColGroup".`[frameCols][String.frameCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`frameCols`][String.frameCols]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` * - * `df.`[select][DataFrame.select]` { "myColGroup".`[frameCols][String.frameCols]`() }` + * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`frameCols`][String.frameCols]`() }` */ public fun String.frameCols(filter: Predicate> = { true }): ColumnSet> = columnGroup(this).frameCols(filter) @@ -156,11 +156,11 @@ public interface FrameColsColumnsSelectionDsl { * @include [CommonFrameColsDocs] * @set [CommonFrameColsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colGroup][ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[frameCols][SingleColumn.frameCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`colGroup`][ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[`frameCols`][SingleColumn.frameCols]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` * - * `df.`[select][DataFrame.select]` { Type::myColGroup.`[frameCols][SingleColumn.frameCols]`() }` + * `df.`[`select`][DataFrame.select]` { Type::myColGroup.`[`frameCols`][SingleColumn.frameCols]`() }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColGroup.`[frameCols][KProperty.frameCols]`() }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColGroup.`[`frameCols`][KProperty.frameCols]`() }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -171,7 +171,7 @@ public interface FrameColsColumnsSelectionDsl { * @include [CommonFrameColsDocs] * @set [CommonFrameColsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myGroupCol"].`[frameCols][ColumnPath.frameCols]`() }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myGroupCol"].`[`frameCols`][ColumnPath.frameCols]`() }` */ public fun ColumnPath.frameCols(filter: Predicate> = { true }): ColumnSet> = columnGroup(this).frameCols(filter) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt index cc417f9c4b..2cc5f9614b 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt @@ -38,15 +38,15 @@ import kotlin.reflect.typeOf * This function does not perform the reshaping immediately — it returns * a [Gather] object, which serves as an intermediate step. * Before applying the final transformation, you may: - * - filter values ([where][Gather.where], [notNull][Gather.notNull]); - * - explode list-columns ([explodeLists][Gather.explodeLists]); - * - transform keys ([mapKeys][Gather.mapKeys]) or values ([mapValues][Gather.mapValues]); - * - cast the value type ([cast][Gather.cast]). + * - filter values ([`where`][Gather.where], [`notNull`][Gather.notNull]); + * - explode list-columns ([`explodeLists`][Gather.explodeLists]); + * - transform keys ([`mapKeys`][Gather.mapKeys]) or values ([`mapValues`][Gather.mapValues]); + * - cast the value type ([`cast`][Gather.cast]). * * Finally, reshape the DataFrame using one of the following methods: - * - [into][Gather.into] - * - [keysInto][Gather.keysInto] - * - [valuesInto][Gather.valuesInto] + * - [`into`][Gather.into] + * - [`keysInto`][Gather.keysInto] + * - [`valuesInto`][Gather.valuesInto] * * Each of these methods returns a new reshaped [DataFrame]. * @@ -61,7 +61,7 @@ import kotlin.reflect.typeOf internal interface GatherDocs { /** - * ## [gather][gather] Operation Grammar + * ## [`gather`][gather] Operation Grammar * {@include [LineBreak]} * {@include [DslGrammarLink]} * {@include [LineBreak]} @@ -98,7 +98,7 @@ internal interface GatherDocs { typealias Grammar = Nothing } -/** {@set [SelectingColumns.OPERATION] [gather][gather]} */ +/** {@set [SelectingColumns.OPERATION] [`gather`][gather]} */ @ExcludeFromSources private typealias SetGatherOperationArg = Nothing @@ -427,8 +427,8 @@ public class Gather( * without modifying the values themselves. * * This is useful when the type cannot be automatically inferred and needs to be explicitly specified - * for further [Gather] operations such as [filter][Gather.where], [notNull][Gather.notNull], - * or [mapValues][Gather.mapValues]. + * for further [Gather] operations such as [filter][Gather.where], [`notNull`][Gather.notNull], + * or [`mapValues`][Gather.mapValues]. * It does not affect the actual content of the values — * only the type used for compile-time safety and transformation configuration. * diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/generateCode.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/generateCode.kt index 1cea61e720..7ec12e41ab 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/generateCode.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/generateCode.kt @@ -26,7 +26,7 @@ import org.jetbrains.kotlinx.dataframe.util.GENERATE_INTERFACES // region Docs /** - * Generates a [CodeString] containing generated [@DataSchema][DataSchema] $[TYPES] + * Generates a [CodeString] containing generated [`@DataSchema`][DataSchema] $[TYPES] * for the given $[RECEIVER] * (including all nested [frame columns][FrameColumn] and [column groups][ColumnGroup]). * @@ -36,7 +36,7 @@ import org.jetbrains.kotlinx.dataframe.util.GENERATE_INTERFACES * * This function is a simplified wrapper for the more advanced and customizable * [CodeGenerator] API. - * For more customizability, have a look at [CodeGenerator.create()][CodeGenerator.create]. + * For more customizability, have a look at [`CodeGenerator.create()`][CodeGenerator.create]. * * For more information: {@include [DocumentationUrls.DataSchemaGeneration]} * @@ -85,8 +85,8 @@ private interface Params { * @param nameNormalizer Strategy for converting column names (with spaces, underscores, etc.) * to Kotlin-style identifiers. * Generated properties will still refer to columns by their actual name - * using the [@ColumnName][ColumnName] annotation. - * Default is [NameNormalizer.default][NameNormalizer.Companion.default]. + * using the [`@ColumnName`][ColumnName] annotation. + * Default is [`NameNormalizer.default`][NameNormalizer.Companion.default]. */ typealias NameNormalizer = Nothing @@ -317,7 +317,7 @@ public value class CodeString(public val value: String) { internal fun String.toCodeString(): CodeString = CodeString(this) /** - * Generates a [CodeString] containing generated [@DataSchema][DataSchema] declarations (markers). + * Generates a [CodeString] containing generated [`@DataSchema`][DataSchema] declarations (markers). */ @PublishedApi internal fun DataFrameSchema.generateCodeImpl( diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt index b95042b701..ee93460aad 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt @@ -32,7 +32,7 @@ import kotlin.reflect.KProperty * which serves as an intermediate step. * The [GroupClause] allows specifying the final * destination of the selected columns using methods such - * as [into][GroupClause.into] and, + * as [`into`][GroupClause.into] and, * that return a new [DataFrame] with grouped columns. * Check out [Grammar]. * @@ -78,7 +78,7 @@ internal interface GroupDocs { typealias Grammar = Nothing } -/** {@set [SelectingColumns.OPERATION] [group][group]} */ +/** {@set [SelectingColumns.OPERATION] [`group`][group]} */ @ExcludeFromSources private typealias SetGroupOperationArg = Nothing diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt index 6f77aacc94..5b16450f31 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt @@ -63,11 +63,11 @@ import kotlin.reflect.KProperty * Don't confuse this with [group], which groups column into * [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]. * - * See also [pivot][DataFrame.pivot] that groups rows of [DataFrame] vertically. + * See also [`pivot`][DataFrame.pivot] that groups rows of [DataFrame] vertically. */ internal interface GroupByDocs { /** - * ## [groupBy][groupBy] Operation Grammar + * ## [`groupBy`][groupBy] Operation Grammar * {@include [LineBreak]} * {@include [DslGrammarLink]} * {@include [LineBreak]} @@ -112,7 +112,7 @@ internal interface GroupByDocs { * ### Reduce [GroupBy] into [DataFrame] * * {@include [Indent]} - * [GroupBy][GroupBy]`.`[**`minBy`**][GroupBy.minBy]**` { `**`rowExpression: `[`RowExpression`][RowExpression]**` }`** + * [`GroupBy`][GroupBy]`.`[**`minBy`**][GroupBy.minBy]**` { `**`rowExpression: `[`RowExpression`][RowExpression]**` }`** * * {@include [Indent]} * `| `__`.`__[**`maxBy`**][GroupBy.maxBy]**` { `**`rowExpression: `[`RowExpression`][RowExpression]**` }`** @@ -141,7 +141,7 @@ internal interface GroupByDocs { * ### Aggregate [GroupBy] into [DataFrame] * * {@include [Indent]} - * [GroupBy][GroupBy]`.`[**`concat`**][GroupBy.concat]**`() `** + * [`GroupBy`][GroupBy]`.`[**`concat`**][GroupBy.concat]**`() `** * * {@include [Indent]} * `| `__`.`__[**`concatWithKeys`**][GroupBy.concatWithKeys]**`() `** @@ -167,7 +167,7 @@ internal interface GroupByDocs { * ### Pivot [GroupBy] into [PivotGroupBy] and reduce / aggregate it * * {@include [Indent]} - * [GroupBy][GroupBy]`.`[**`pivot`**][GroupBy.pivot]**` { `**`columns: `[`ColumnsSelector`][ColumnsSelector]**` }`** + * [`GroupBy`][GroupBy]`.`[**`pivot`**][GroupBy.pivot]**` { `**`columns: `[`ColumnsSelector`][ColumnsSelector]**` }`** * * {@include [Indent]} * ` \[ `__`.`__[**`default`**][PivotGroupBy.default]**`(`**`defaultValue`**`) `**`]` @@ -197,29 +197,29 @@ internal interface GroupByDocs { * Each function computes a statistic across the rows of a group and returns the result as * a new column (or several columns) in the resulting [DataFrame]. * - * * [count][Grouped.count] — calculate the number of rows in each group + * * [`count`][Grouped.count] — calculate the number of rows in each group * (optionally counting only rows that satisfy the given predicate); * * [`countDistinct`][Grouped.countDistinct] — calculate the number of distinct rows in each group * (or distinct combinations of values in selected columns); - * * [max][Grouped.max] / [maxOf][Grouped.maxOf] / [maxFor][Grouped.maxFor] — + * * [`max`][Grouped.max] / [`maxOf`][Grouped.maxOf] / [`maxFor`][Grouped.maxFor] — * calculate the maximum of all values on the selected columns / by a row expression / * for each of the selected columns within each group; - * * [min][Grouped.min] / [minOf][Grouped.minOf] / [minFor][Grouped.minFor] — + * * [`min`][Grouped.min] / [`minOf`][Grouped.minOf] / [`minFor`][Grouped.minFor] — * calculate the minimum of all values on the selected columns / by a row expression / * for each of the selected columns within each group; - * * [sum][Grouped.sum] / [sumOf][Grouped.sumOf] / [sumFor][Grouped.sumFor] — + * * [`sum`][Grouped.sum] / [`sumOf`][Grouped.sumOf] / [`sumFor`][Grouped.sumFor] — * calculate the sum of all values on the selected columns / by a row expression / * for each of the selected columns within each group; - * * [mean][Grouped.mean] / [meanOf][Grouped.meanOf] / [meanFor][Grouped.meanFor] — + * * [`mean`][Grouped.mean] / [`meanOf`][Grouped.meanOf] / [`meanFor`][Grouped.meanFor] — * calculate the mean (average) of all values on the selected columns / by a row expression / * for each of the selected columns within each group; - * * [std][Grouped.std] / [stdOf][Grouped.stdOf] / [stdFor][Grouped.stdFor] — + * * [`std`][Grouped.std] / [`stdOf`][Grouped.stdOf] / [`stdFor`][Grouped.stdFor] — * calculate the standard deviation of all values on the selected columns / by a row expression / * for each of the selected columns within each group; - * * [median][Grouped.median] / [medianOf][Grouped.medianOf] / [medianFor][Grouped.medianFor] — + * * [`median`][Grouped.median] / [`medianOf`][Grouped.medianOf] / [`medianFor`][Grouped.medianFor] — * calculate the median of all values on the selected columns / by a row expression / * for each of the selected columns within each group; - * * [percentile][Grouped.percentile] / [percentileOf][Grouped.percentileOf] / [percentileFor][Grouped.percentileFor] — + * * [`percentile`][Grouped.percentile] / [`percentileOf`][Grouped.percentileOf] / [`percentileFor`][Grouped.percentileFor] — * calculate a specified percentile of all values on the selected columns / by a row expression / * for each of the selected columns within each group. * @@ -231,17 +231,17 @@ internal interface GroupByDocs { * ### [GroupBy] transformations * * A [GroupBy] can be transformed into a new [GroupBy] using one of the following methods: - * * [sortByGroup][GroupBy.sortByGroup] / [sortByGroupDesc][GroupBy.sortByGroupDesc] — sorts the **order + * * [`sortByGroup`][GroupBy.sortByGroup] / [`sortByGroupDesc`][GroupBy.sortByGroupDesc] — sorts the **order * of groups** (and their corresponding keys) by values computed with a [DataFrameExpression] applied to each group; - * * [sortByCount][GroupBy.sortByCount] / [sortByCountAsc][GroupBy.sortByCountAsc] — sorts the **order + * * [`sortByCount`][GroupBy.sortByCount] / [`sortByCountAsc`][GroupBy.sortByCountAsc] — sorts the **order * of groups** (and their corresponding keys) by the number of rows they contain; - * * [sortByKey][GroupBy.sortByKey] / [sortByKeyDesc][GroupBy.sortByKeyDesc] — sorts the **order + * * [`sortByKey`][GroupBy.sortByKey] / [`sortByKeyDesc`][GroupBy.sortByKeyDesc] — sorts the **order * of groups** (and their corresponding keys) by the grouping key values; - * * [sortBy][GroupBy.sortBy] / [sortByDesc][GroupBy.sortByDesc] — sorts the **order of rows within each group** + * * [`sortBy`][GroupBy.sortBy] / [`sortByDesc`][GroupBy.sortByDesc] — sorts the **order of rows within each group** * by one or more column values; - * * [updateGroups][GroupBy.updateGroups] — transforms each group into a new one; - * * [filter][GroupBy.filter] — filters group rows by the given predicate (as usual [DataFrame.filter]); - * * [add][GroupBy.add] — adds a new column to each group. + * * [`updateGroups`][GroupBy.updateGroups] — transforms each group into a new one; + * * [`filter`][GroupBy.filter] — filters group rows by the given predicate (as usual [DataFrame.filter]); + * * [`add`][GroupBy.add] — adds a new column to each group. * * Each method returns a new [GroupBy] with updated group order or modified group content. * @@ -258,19 +258,19 @@ internal interface GroupByDocs { * Reducing is a specific case of [aggregation][Aggregation]. * * First, choose a [GroupBy] reducing method: - * * [first][GroupBy.first], [last][GroupBy.last] — take the first or last row + * * [`first`][GroupBy.first], [`last`][GroupBy.last] — take the first or last row * (optionally, the first or last one that satisfies a predicate) of each group; - * * [minBy][GroupBy.minBy] / [maxBy][GroupBy.maxBy] — take the row with the minimum or maximum value + * * [`minBy`][GroupBy.minBy] / [`maxBy`][GroupBy.maxBy] — take the row with the minimum or maximum value * of the given [RowExpression] calculated on rows within each group; - * * [medianBy][GroupBy.medianBy] / [percentileBy][GroupBy.percentileBy] — take the row at the position closest + * * [`medianBy`][GroupBy.medianBy] / [`percentileBy`][GroupBy.percentileBy] — take the row at the position closest * to the estimated median/percentile index of the [RowExpression]'s results calculated on rows within each group. * * These functions return a [ReducedGroupBy], which can then be transformed into a new [DataFrame] * containing the reduced rows (either original or transformed) using one of the following methods: - * * [concat][ReducedGroupBy.concat] — simply concatenates all reduced rows; - * * [values][ReducedGroupBy.values] — creates a [DataFrame] containing the values + * * [`concat`][ReducedGroupBy.concat] — simply concatenates all reduced rows; + * * [`values`][ReducedGroupBy.values] — creates a [DataFrame] containing the values * from the reduced rows in the selected columns. - * * [into][ReducedGroupBy.into] — creates a new column with values computed with [RowExpression] on each row, + * * [`into`][ReducedGroupBy.into] — creates a new column with values computed with [RowExpression] on each row, * or a new [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] * containing each group reduced to a single row; * @@ -293,29 +293,29 @@ internal interface GroupByDocs { * Aggregation is a generalization of [reducing][Reducing]. * * The following aggregation methods are available: - * * [concat][GroupBy.concat] — concatenates all rows from all groups into a single [DataFrame], + * * [`concat`][GroupBy.concat] — concatenates all rows from all groups into a single [DataFrame], * without preserving grouping keys; - * * [toDataFrame][GroupBy.toDataFrame] — returns this [GroupBy] as [DataFrame] with the grouping keys and + * * [`toDataFrame`][GroupBy.toDataFrame] — returns this [GroupBy] as [DataFrame] with the grouping keys and * corresponding groups in [FrameColumn]. - * * [concatWithKeys][GroupBy.concatWithKeys] — a variant of [concat][GroupBy.concat] that also includes + * * [`concatWithKeys`][GroupBy.concatWithKeys] — a variant of [`concat`][GroupBy.concat] that also includes * grouping keys that were not present in the original [DataFrame]; - * * [into][GroupBy.into] — creates a new column containing a list of values computed with a [RowExpression] + * * [`into`][GroupBy.into] — creates a new column containing a list of values computed with a [RowExpression] * for each group, or a new [frame column][org.jetbrains.kotlinx.dataframe.columns.FrameColumn] * containing the groups themselves; - * * [values][Grouped.values] — creates a [DataFrame] containing values collected into a single [List] + * * [`values`][Grouped.values] — creates a [DataFrame] containing values collected into a single [List] * from all rows of each group for the selected columns. - * * [count][Grouped.count] — creates a [DataFrame] containing the grouping key columns and an additional column + * * [`count`][Grouped.count] — creates a [DataFrame] containing the grouping key columns and an additional column * with the number of rows in each corresponding group; - * * [countDistinct][Grouped.countDistinct] — creates a [DataFrame] containing the grouping key columns + * * [`countDistinct`][Grouped.countDistinct] — creates a [DataFrame] containing the grouping key columns * and an additional column with the number of distinct rows in each corresponding group; - * * [aggregate][Grouped.aggregate] — performs a set of custom aggregations using [AggregateDsl], + * * [`aggregate`][Grouped.aggregate] — performs a set of custom aggregations using [AggregateDsl], * allowing you to compute one or more derived values per group; * * [Various aggregation statistics][AggregationStatistics] — predefined shortcuts - * for common statistical aggregations such as [sum][Grouped.sum], [mean][Grouped.mean], - * [median][Grouped.median], and others. + * for common statistical aggregations such as [`sum`][Grouped.sum], [`mean`][Grouped.mean], + * [`median`][Grouped.median], and others. * * Each of these methods returns a new [DataFrame] that includes the grouping key columns - * (except for [concat][GroupBy.concat]) along with the columns of values aggregated + * (except for [`concat`][GroupBy.concat]) along with the columns of values aggregated * from the corresponding groups. * * Check out [`GroupBy grammar`][Grammar]. @@ -327,7 +327,7 @@ internal interface GroupByDocs { /** * ### [GroupBy] pivoting * - * [GroupBy] can be pivoted with [pivot][GroupBy.pivot] method. It will produce a [PivotGroupBy]. + * [GroupBy] can be pivoted with [`pivot`][GroupBy.pivot] method. It will produce a [PivotGroupBy]. * * @include [PivotGroupByDocs.CommonDescription] */ @@ -347,7 +347,7 @@ internal interface GroupByDocs { typealias GroupingKeysInline = Nothing } -/** {@set [SelectingColumns.OPERATION] [groupBy][groupBy]} */ +/** {@set [SelectingColumns.OPERATION] [`groupBy`][groupBy]} */ @ExcludeFromSources private typealias SetGroupByOperationArg = Nothing @@ -363,7 +363,7 @@ private typealias CommonGroupByDocs = Nothing * @include [SelectingColumns.ColumnsSelectionDsl.ColumnsSelectionDslWithExample] {@include [SetGroupByOperationArg]} * * @param [moveToTop] Specifies whether nested grouping columns should be moved to the top level - * or kept inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]. + * or kept inside a [`ColumnGroup`][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]. * Defaults to `true`. * @param [cols] The [Columns Selector][ColumnsSelector] that defines which columns are used * as keys for grouping. @@ -422,7 +422,7 @@ private typealias CommonGroupByForPivotDocs = Nothing * @include [SelectingColumns.ColumnsSelectionDsl.ColumnsSelectionDslWithExample] {@include [SetGroupByOperationArg] {@set [SelectingColumns.RECEIVER] `pivot`}} * * @param moveToTop Specifies whether nested grouping columns should be moved to the top level - * or kept inside a [ColumnGroup][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]. + * or kept inside a [`ColumnGroup`][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup]. * Defaults to `true`. * @param [columns] The [Columns Selector][ColumnsSelector] that defines which columns are used * as keys for grouping. @@ -559,7 +559,7 @@ public interface GroupBy : Grouped { * Filters the rows of this [GroupBy] — that is, the key–group pairs — based on the specified [predicate]. * * The [predicate] is a [GroupedRowFilter], which behaves similarly to a [RowFilter] used in [DataFrame.filter], - * but also provides access to the [group][GroupedDataRow.group] in the current row. + * but also provides access to the [`group`][GroupedDataRow.group] in the current row. * * ### Example * ```kotlin @@ -621,10 +621,10 @@ public interface Grouped : Aggregatable * in a new [DataFrame]. * * Available transformation methods: - * * [concat][ReducedGroupBy.concat] — concatenates all reduced rows into a single [DataFrame]; - * * [values][ReducedGroupBy.values] — creates a [DataFrame] with new rows by transforming each reduced row + * * [`concat`][ReducedGroupBy.concat] — concatenates all reduced rows into a single [DataFrame]; + * * [`values`][ReducedGroupBy.values] — creates a [DataFrame] with new rows by transforming each reduced row * using [ColumnsForAggregateSelectionDsl]; - * * [into][ReducedGroupBy.into] — creates a new column with values computed using a [RowExpression] for each row, + * * [`into`][ReducedGroupBy.into] — creates a new column with values computed using a [RowExpression] for each row, * or a new [column group][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] * containing each group reduced to a single row. * diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/insert.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/insert.kt index f2b11c1efc..2f5d91e064 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/insert.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/insert.kt @@ -38,9 +38,9 @@ import kotlin.reflect.KProperty * returns an [InsertClause], * which serves as an intermediate step. * The [InsertClause] object provides methods to insert a new column using: - * - [under][InsertClause.under] - inserts a new column under the specified column group. - * - [after][InsertClause.after] - inserts a new column after the specified column. - * - [at][InsertClause.at]- inserts a new column at the specified position. + * - [`under`][InsertClause.under] - inserts a new column under the specified column group. + * - [`after`][InsertClause.after] - inserts a new column after the specified column. + * - [`at`][InsertClause.at]- inserts a new column at the specified position. * * Each method returns a new [DataFrame] with the inserted column. * @@ -53,8 +53,8 @@ import kotlin.reflect.KProperty * For more information: {@include [DocumentationUrls.Insert]} * * See also: - * - [move][DataFrame.move] - move columns to a new position within the [DataFrame]. - * - [add][DataFrame.add] - add new columns to the [DataFrame] + * - [`move`][DataFrame.move] - move columns to a new position within the [DataFrame]. + * - [`add`][DataFrame.add] - add new columns to the [DataFrame] * (without specifying a position, to the end of the [DataFrame]). */ internal interface InsertDocs { @@ -87,7 +87,7 @@ internal interface InsertDocs { typealias Grammar = Nothing } -/** {@set [SelectingColumns.OPERATION] [insert][insert]} */ +/** {@set [SelectingColumns.OPERATION] [`insert`][insert]} */ @ExcludeFromSources private typealias SetInsertOperationArg = Nothing @@ -172,9 +172,9 @@ public inline fun DataFrame.insert( * to produce a new [DataFrame] with an inserted column. * * Use the following methods to perform the insertion: - * - [under][InsertClause.under] - inserts a new column under the specified column group. - * - [after][InsertClause.after] - inserts a new column after the specified column. - * - [at][InsertClause.at]- inserts a new column at the specified position. + * - [`under`][InsertClause.under] - inserts a new column under the specified column group. + * - [`after`][InsertClause.after] - inserts a new column after the specified column. + * - [`at`][InsertClause.at]- inserts a new column at the specified position. * * See [Grammar][InsertDocs.Grammar] for more details. */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt index 6d6badc72e..29aeb89cbf 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/join.kt @@ -73,8 +73,8 @@ private typealias JOIN_METHOD = Nothing * * Provides the left [DataFrame] both as the receiver (`this`) and as the argument (`it`), * allowing you to reference its columns directly. - * Use [right][JoinDsl.right] to access columns from the right [DataFrame], - * and [match][JoinDsl.match] to explicitly pair columns with different names. + * Use [`right`][JoinDsl.right] to access columns from the right [DataFrame], + * and [`match`][JoinDsl.match] to explicitly pair columns with different names. * * See also [Columns selection via DSL][SelectingColumns.ColumnsSelectionDsl]. * @@ -563,7 +563,7 @@ internal class ColumnMatchImpl(override val left: ColumnReference, overrid /** * Creates a [ColumnMatch]. * - * Not intended for public API consumption. Please use [match][JoinDsl.match] instead. + * Not intended for public API consumption. Please use [`match`][JoinDsl.match] instead. */ public fun ColumnMatch(left: ColumnReference, right: ColumnReference): ColumnMatch = ColumnMatchImpl(left, right) @@ -575,7 +575,7 @@ public fun ColumnMatch(left: ColumnReference, right: ColumnReference): * a [ColumnsResolver] as the return value. * * Enables defining matching columns from left and right [DataFrame]s - * using [right][JoinDsl.right] and [match][JoinDsl.match]. + * using [`right`][JoinDsl.right] and [`match`][JoinDsl.match]. */ public typealias JoinColumnsSelector = JoinDsl.(ColumnsContainer) -> ColumnsResolver<*> diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/joinWith.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/joinWith.kt index 29fb10a7c9..f580fe7947 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/joinWith.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/joinWith.kt @@ -70,7 +70,7 @@ public interface JoinedDataRow : DataRow { * allowing you to reference its values directly. * * The [row][DataRow] of the right [DataFrame] is available - * as [right][JoinedDataRow.right]. + * as [`right`][JoinedDataRow.right]. * * The expression must return a [Boolean] indicating whether * the rows from the left and right [DataFrame]s match. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt index 53ebbfdd52..7449e90895 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/last.kt @@ -121,11 +121,11 @@ public inline fun DataColumn.lastOrNull(predicate: (T) -> Boolean): T? = * df.lastOrNull { amount > 100 } * ``` * - * See also [last][DataFrame.last], - * [first][DataFrame.first], - * [take][DataFrame.take], - * [takeLast][DataFrame.takeLast], - * [takeWhile][DataFrame.takeWhile]. + * See also [`last`][DataFrame.last], + * [`first`][DataFrame.first], + * [`take`][DataFrame.take], + * [`takeLast`][DataFrame.takeLast], + * [`takeWhile`][DataFrame.takeWhile]. * * @param [predicate] A [row filter][RowFilter] used to get the last value * that satisfies a condition specified in this filter. @@ -150,11 +150,11 @@ public inline fun DataFrame.lastOrNull(predicate: RowFilter): DataRow< * df.last { amount > 100 } * ``` * - * See also [lastOrNull][DataFrame.lastOrNull], - * [first][DataFrame.first], - * [take][DataFrame.take], - * [takeLast][DataFrame.takeLast], - * [takeWhile][DataFrame.takeWhile]. + * See also [`lastOrNull`][DataFrame.lastOrNull], + * [`first`][DataFrame.first], + * [`take`][DataFrame.take], + * [`takeLast`][DataFrame.takeLast], + * [`takeWhile`][DataFrame.takeWhile]. * * @param [predicate] A [row filter][RowFilter] used to get the last value * that satisfies a condition specified in this filter. @@ -171,10 +171,10 @@ public inline fun DataFrame.last(predicate: RowFilter): DataRow = /** * Returns the last [row][DataRow] in this [DataFrame]. If the [DataFrame] does not contain any rows, returns `null`. * - * See also [last][DataFrame.last], - * [first][DataFrame.first], - * [take][DataFrame.take], - * [takeLast][DataFrame.takeLast]. + * See also [`last`][DataFrame.last], + * [`first`][DataFrame.first], + * [`take`][DataFrame.take], + * [`takeLast`][DataFrame.takeLast]. * * @return A [DataRow] containing the last row in this [DataFrame], or `null` if the [DataFrame] is empty. */ @@ -183,10 +183,10 @@ public fun DataFrame.lastOrNull(): DataRow? = if (nrow > 0) get(nrow - /** * Returns the last [row][DataRow] in this [DataFrame]. * - * See also [lastOrNull][DataFrame.lastOrNull], - * [first][DataFrame.first], - * [take][DataFrame.take], - * [takeLast][DataFrame.takeLast]. + * See also [`lastOrNull`][DataFrame.lastOrNull], + * [`first`][DataFrame.first], + * [`take`][DataFrame.take], + * [`takeLast`][DataFrame.takeLast]. * * @return A [DataRow] containing the last row in this [DataFrame]. * @@ -220,7 +220,7 @@ public fun DataFrame.last(): DataRow { * df.groupBy { orderId }.last().concat() * ``` * - * See also [first][GroupBy.first]. + * See also [`first`][GroupBy.first]. * * @return A [ReducedGroupBy] containing the last [row][DataRow] * (or a [row][DataRow] with `null` values, except the grouping key) from each group. @@ -249,7 +249,7 @@ public fun GroupBy.last(): ReducedGroupBy = reduce { lastOrNu * df.groupBy { orderId }.last { !isInternal }.concat() * ``` * - * See also [first][GroupBy.first]. + * See also [`first`][GroupBy.first]. * * @param [predicate] A [row filter][RowFilter] used to get the last value * that satisfies a condition specified in this filter. @@ -277,7 +277,7 @@ public fun GroupBy.last(predicate: RowFilter): ReducedGroupBy Pivot.last(): ReducedPivot = reduce { lastOrNull() } * df.pivot { type }.last { price < 500_000 }.values() * ``` * - * See also [pivot], [reduce][Pivot.reduce], [first][Pivot.first]. + * See also [pivot], [`reduce`][Pivot.reduce], [`first`][Pivot.first]. * * @param [predicate] A [row filter][RowFilter] used to get the last value * that satisfies a condition specified in this filter. @@ -333,10 +333,10 @@ public fun Pivot.last(predicate: RowFilter): ReducedPivot = reduce * df.pivot { type }.groupBy { city }.last().values() * ``` * - * See also [groupBy][Pivot.groupBy], - * [pivot][GroupBy.pivot], - * [reduce][PivotGroupBy.reduce], - * [first][PivotGroupBy.first]. + * See also [`groupBy`][Pivot.groupBy], + * [`pivot`][GroupBy.pivot], + * [`reduce`][PivotGroupBy.reduce], + * [`first`][PivotGroupBy.first]. * * @return A [ReducedPivotGroupBy] containing in each combination of a [groupBy] key and a [pivot] key either * the last [row][DataRow] of the corresponding [DataFrame] formed by this pivot–group pair, @@ -372,10 +372,10 @@ public fun PivotGroupBy.last(): ReducedPivotGroupBy = reduce { lastOrN * df.pivot { type }.groupBy { city }.last { price < 500_000 }.values() * ``` * - * See also [groupBy][Pivot.groupBy], - * [pivot][GroupBy.pivot], - * [reduce][PivotGroupBy.reduce], - * [first][PivotGroupBy.first]. + * See also [`groupBy`][Pivot.groupBy], + * [`pivot`][GroupBy.pivot], + * [`reduce`][PivotGroupBy.reduce], + * [`first`][PivotGroupBy.first]. * * @param [predicate] A [row filter][RowFilter] used to get the last value * that satisfies a condition specified in this filter. @@ -446,9 +446,9 @@ public interface LastColumnsSelectionDsl { * * #### Examples: * - * `df.`[select][DataFrame.select]` { `[last][ColumnsSelectionDsl.last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }` + * `df.`[`select`][DataFrame.select]` { `[`last`][ColumnsSelectionDsl.last]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("order") } }` * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[lastCol][String.lastCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("order") } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`lastCol`][String.lastCol]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("order") } }` * * #### Examples for this overload: * @@ -469,9 +469,9 @@ public interface LastColumnsSelectionDsl { /** * @include [CommonLastDocs] * @set [CommonLastDocs.Examples] - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[last][ColumnSet.last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>().`[`last`][ColumnSet.last]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[last][ColumnSet.last]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`last`][ColumnSet.last]`() }` */ @Suppress("UNCHECKED_CAST") @Interpretable("Last0") @@ -484,7 +484,7 @@ public interface LastColumnsSelectionDsl { * @include [CommonLastDocs] * @set [CommonLastDocs.Examples] * - * `df.`[select][DataFrame.select]` { `[last][ColumnsSelectionDsl.last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { `[`last`][ColumnsSelectionDsl.last]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` */ @Interpretable("Last1") public fun ColumnsSelectionDsl<*>.last(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*> = @@ -494,7 +494,7 @@ public interface LastColumnsSelectionDsl { * @include [CommonLastDocs] * @set [CommonLastDocs.Examples] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[lastCol][SingleColumn.lastCol]`() }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`lastCol`][SingleColumn.lastCol]`() }` */ @Interpretable("Last2") public fun SingleColumn>.lastCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*> = @@ -503,7 +503,7 @@ public interface LastColumnsSelectionDsl { /** * @include [CommonLastDocs] * @set [CommonLastDocs.Examples] - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[lastCol][String.lastCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`lastCol`][String.lastCol]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` */ public fun String.lastCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*> = columnGroup(this).lastCol(condition) @@ -511,9 +511,9 @@ public interface LastColumnsSelectionDsl { /** * @include [CommonLastDocs] * @set [CommonLastDocs.Examples] - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[lastCol][SingleColumn.lastCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`lastCol`][SingleColumn.lastCol]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[lastCol][KProperty.lastCol]`() }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`lastCol`][KProperty.lastCol]`() }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -523,7 +523,7 @@ public interface LastColumnsSelectionDsl { /** * @include [CommonLastDocs] * @set [CommonLastDocs.Examples] - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[lastCol][ColumnPath.lastCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`lastCol`][ColumnPath.lastCol]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` */ public fun ColumnPath.lastCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*> = columnGroup(this).lastCol(condition) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt index 36b951e39d..13ac2eb2fb 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt @@ -50,18 +50,18 @@ import kotlin.reflect.KProperty * Depending on what exactly you want the maximum of, there are several modes. * They are shown here for [DataFrame], but they exist for the other receivers too: * - * - [max][DataFrame.max]`()` — the maximum of each suitable column separately. - * - [max][DataFrame.max]` { columns }` — a single maximum of all values in all selected columns. - * - [maxFor][DataFrame.maxFor]` { columns }` — the maximum of each selected column separately. - * - [maxOf][DataFrame.maxOf]` { expression }` — the maximum of the values that the given expression + * - [`max`][DataFrame.max]`()` — the maximum of each suitable column separately. + * - [`max`][DataFrame.max]` { columns }` — a single maximum of all values in all selected columns. + * - [`maxFor`][DataFrame.maxFor]` { columns }` — the maximum of each selected column separately. + * - [`maxOf`][DataFrame.maxOf]` { expression }` — the maximum of the values that the given expression * returns for each row. - * - [maxBy][DataFrame.maxBy]` { expression }` — the first row for which the given expression returns + * - [`maxBy`][DataFrame.maxBy]` { expression }` — the first row for which the given expression returns * the maximum value. * - * [max][DataFrame.max], [maxOf][DataFrame.maxOf], and [maxBy][DataFrame.maxBy] all have an `-OrNull` + * [`max`][DataFrame.max], [`maxOf`][DataFrame.maxOf], and [`maxBy`][DataFrame.maxBy] all have an `-OrNull` * counterpart which returns `null` instead of throwing an exception when there's nothing to compare. * - * Mirror operation: [min][DataFrame.min]. + * Mirror operation: [`min`][DataFrame.min]. * * For more information: {@include [DocumentationUrls.MinMax]} * @@ -86,15 +86,15 @@ internal interface MaxDocs : CommonMinMaxDocs { @ExcludeFromSources private typealias MaxDocsLink = Nothing -/** {@set [SelectingColumns.OPERATION] [max][max]} */ +/** {@set [SelectingColumns.OPERATION] [`max`][max]} */ @ExcludeFromSources private typealias SetMaxOperationArg = Nothing -/** {@set [SelectingColumns.OPERATION] [maxFor][maxFor]} */ +/** {@set [SelectingColumns.OPERATION] [`maxFor`][maxFor]} */ @ExcludeFromSources private typealias SetMaxForOperationArg = Nothing -/** {@set [SelectingColumns.OPERATION] [maxOrNull][maxOrNull]} */ +/** {@set [SelectingColumns.OPERATION] [`maxOrNull`][maxOrNull]} */ @ExcludeFromSources private typealias SetMaxOrNullOperationArg = Nothing @@ -110,10 +110,10 @@ private typealias SetMaxOrNullOperationArg = Nothing * {@include [MaxDocs.ThrowsOnEmptySnippet]} * * See also: - * - [maxOrNull][DataColumn.maxOrNull] — returns `null` instead of throwing for a column with nothing to compare. - * - [maxOf][DataColumn.maxOf] — the maximum of the values a selector returns for each element. - * - [maxBy][DataColumn.maxBy] — the element for which a selector returns the maximum value. - * - [min][DataColumn.min] — the mirror operation. + * - [`maxOrNull`][DataColumn.maxOrNull] — returns `null` instead of throwing for a column with nothing to compare. + * - [`maxOf`][DataColumn.maxOf] — the maximum of the values a selector returns for each element. + * - [`maxBy`][DataColumn.maxBy] — the element for which a selector returns the maximum value. + * - [`min`][DataColumn.min] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -141,12 +141,12 @@ public fun > DataColumn.max(skipNaN: Boolean = skipNaNDefa * {@include [MaxDocs.NullOnEmptySnippet]} * * See also: - * - [max][DataColumn.max] — throws instead of returning `null` for a column with nothing to compare. - * - [maxOfOrNull][DataColumn.maxOfOrNull] — the maximum of the values a selector returns + * - [`max`][DataColumn.max] — throws instead of returning `null` for a column with nothing to compare. + * - [`maxOfOrNull`][DataColumn.maxOfOrNull] — the maximum of the values a selector returns * for each element. - * - [maxByOrNull][DataColumn.maxByOrNull] — the element for which a selector returns + * - [`maxByOrNull`][DataColumn.maxByOrNull] — the element for which a selector returns * the maximum value. - * - [minOrNull][DataColumn.minOrNull] — the mirror operation. + * - [`minOrNull`][DataColumn.minOrNull] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -172,12 +172,12 @@ public fun > DataColumn.maxOrNull(skipNaN: Boolean = skipN * * {@include [MaxDocs.ThrowsOnEmptySnippet]} * - * Don't confuse [maxBy] with [maxOf][DataColumn.maxOf], which returns the maximum [selector] value itself + * Don't confuse [maxBy] with [`maxOf`][DataColumn.maxOf], which returns the maximum [selector] value itself * instead of the element it belongs to. * * See also: - * - [maxByOrNull][DataColumn.maxByOrNull] — returns `null` instead of throwing for a column with nothing to compare. - * - [minBy][DataColumn.minBy] — the mirror operation. + * - [`maxByOrNull`][DataColumn.maxByOrNull] — returns `null` instead of throwing for a column with nothing to compare. + * - [`minBy`][DataColumn.minBy] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MaxBy]} @@ -206,12 +206,12 @@ public inline fun ?> DataColumn.maxBy( * * {@include [MaxDocs.NullOnEmptySnippet]} * - * Don't confuse [maxByOrNull] with [maxOfOrNull][DataColumn.maxOfOrNull], which returns the maximum + * Don't confuse [maxByOrNull] with [`maxOfOrNull`][DataColumn.maxOfOrNull], which returns the maximum * [selector] value itself instead of the element it belongs to. * * See also: - * - [maxBy][DataColumn.maxBy] — throws instead of returning `null` for a column with nothing to compare. - * - [minByOrNull][DataColumn.minByOrNull] — the mirror operation. + * - [`maxBy`][DataColumn.maxBy] — throws instead of returning `null` for a column with nothing to compare. + * - [`minByOrNull`][DataColumn.minByOrNull] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MaxBy]} @@ -241,12 +241,12 @@ public inline fun ?> DataColumn.maxByOrNul * * {@include [MaxDocs.ThrowsOnEmptySnippet]} * - * Don't confuse [maxOf] with [maxBy][DataColumn.maxBy], which returns the element the maximum + * Don't confuse [maxOf] with [`maxBy`][DataColumn.maxBy], which returns the element the maximum * [selector] value belongs to instead of that value. * * See also: - * - [maxOfOrNull][DataColumn.maxOfOrNull] — returns `null` instead of throwing for a column with nothing to compare. - * - [minOf][DataColumn.minOf] — the mirror operation. + * - [`maxOfOrNull`][DataColumn.maxOfOrNull] — returns `null` instead of throwing for a column with nothing to compare. + * - [`minOf`][DataColumn.minOf] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -275,12 +275,12 @@ public inline fun ?> DataColumn.maxOf( * * {@include [MaxDocs.NullOnEmptySnippet]} * - * Don't confuse [maxOfOrNull] with [maxByOrNull][DataColumn.maxByOrNull], which returns the element + * Don't confuse [maxOfOrNull] with [`maxByOrNull`][DataColumn.maxByOrNull], which returns the element * the maximum [selector] value belongs to instead of that value. * * See also: - * - [maxOf][DataColumn.maxOf] — throws instead of returning `null` for a column with nothing to compare. - * - [minOfOrNull][DataColumn.minOfOrNull] — the mirror operation. + * - [`maxOf`][DataColumn.maxOf] — throws instead of returning `null` for a column with nothing to compare. + * - [`minOfOrNull`][DataColumn.minOfOrNull] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -324,9 +324,9 @@ public fun DataRow<*>.rowMax(): Nothing = error(ROW_MAX) * {@include [MaxDocs.NullOnEmptySnippet]} * * See also: - * - [rowMaxOf][DataRow.rowMaxOf] — throws instead of returning `null` when there's nothing to compare. - * - [rowMinOfOrNull][DataRow.rowMinOfOrNull] — the mirror operation. - * - [maxOrNull][DataFrame.maxOrNull] — the maximum of the values in specific columns of a [DataFrame]. + * - [`rowMaxOf`][DataRow.rowMaxOf] — throws instead of returning `null` when there's nothing to compare. + * - [`rowMinOfOrNull`][DataRow.rowMinOfOrNull] — the mirror operation. + * - [`maxOrNull`][DataFrame.maxOrNull] — the maximum of the values in specific columns of a [DataFrame]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.RowStatistics]} @@ -355,10 +355,10 @@ public inline fun > DataRow<*>.rowMaxOfOrNull(skipNaN: * {@include [MaxDocs.ThrowsOnEmptySnippet]} * * See also: - * - [rowMaxOfOrNull][DataRow.rowMaxOfOrNull] — returns `null` instead of throwing + * - [`rowMaxOfOrNull`][DataRow.rowMaxOfOrNull] — returns `null` instead of throwing * when there's nothing to compare. - * - [rowMinOf][DataRow.rowMinOf] — the mirror operation. - * - [max][DataFrame.max] — the maximum of the values in specific columns of a [DataFrame]. + * - [`rowMinOf`][DataRow.rowMinOf] — the mirror operation. + * - [`max`][DataFrame.max] — the maximum of the values in specific columns of a [DataFrame]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.RowStatistics]} @@ -392,9 +392,9 @@ public inline fun > DataRow<*>.rowMaxOf(skipNaN: Boole * {@include [MaxDocs.NullCellOnEmptySnippet]} * * See also: - * - [maxFor][DataFrame.maxFor] — the same, but for an explicit selection of columns. - * - [max][DataFrame.max]` { columns }` — a single maximum of all values in the selected columns. - * - [min][DataFrame.min] — the mirror operation. + * - [`maxFor`][DataFrame.maxFor] — the same, but for an explicit selection of columns. + * - [`max`][DataFrame.max]` { columns }` — a single maximum of all values in the selected columns. + * - [`min`][DataFrame.min] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -428,9 +428,9 @@ public fun DataFrame.max(skipNaN: Boolean = skipNaNDefault): DataRow = * See [Selecting Columns][MaxDocs.MaxForSelectingOptions]. * * See also: - * - [max][DataFrame.max]`()` — the same, but for all suitable columns at once. - * - [max][DataFrame.max]` { columns }` — a single maximum of all values in the selected columns. - * - [minFor][DataFrame.minFor] — the mirror operation. + * - [`max`][DataFrame.max]`()` — the same, but for all suitable columns at once. + * - [`max`][DataFrame.max]` { columns }` — a single maximum of all values in the selected columns. + * - [`minFor`][DataFrame.minFor] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -467,9 +467,9 @@ public fun ?> DataFrame.maxFor( * See [Selecting Columns][MaxDocs.MaxForSelectingOptions]. * * See also: - * - [max][DataFrame.max]`()` — the same, but for all suitable columns at once. - * - [max][DataFrame.max]` { columns }` — a single maximum of all values in the selected columns. - * - [minFor][DataFrame.minFor] — the mirror operation. + * - [`max`][DataFrame.max]`()` — the same, but for all suitable columns at once. + * - [`max`][DataFrame.max]` { columns }` — a single maximum of all values in the selected columns. + * - [`minFor`][DataFrame.minFor] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -511,11 +511,11 @@ public fun ?> DataFrame.maxFor( * {@include [SelectingColumns.ColumnGroupsAndNestedColumnsSnippet]} * * See also: - * - [maxOrNull][DataFrame.maxOrNull] — returns `null` instead of throwing when there's + * - [`maxOrNull`][DataFrame.maxOrNull] — returns `null` instead of throwing when there's * nothing to compare. - * - [maxFor][DataFrame.maxFor] — the maximum of each selected column separately. - * - [maxOf][DataFrame.maxOf] — the maximum of the values a row expression returns for each row. - * - [min][DataFrame.min] — the mirror operation. + * - [`maxFor`][DataFrame.maxFor] — the maximum of each selected column separately. + * - [`maxOf`][DataFrame.maxOf] — the maximum of the values a row expression returns for each row. + * - [`min`][DataFrame.min] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -549,11 +549,11 @@ public fun ?> DataFrame.max( * {@include [SelectingColumns.ColumnGroupsAndNestedColumnsSnippet]} * * See also: - * - [maxOrNull][DataFrame.maxOrNull] — returns `null` instead of throwing when there's + * - [`maxOrNull`][DataFrame.maxOrNull] — returns `null` instead of throwing when there's * nothing to compare. - * - [maxFor][DataFrame.maxFor] — the maximum of each selected column separately. - * - [maxOf][DataFrame.maxOf] — the maximum of the values a row expression returns for each row. - * - [min][DataFrame.min] — the mirror operation. + * - [`maxFor`][DataFrame.maxFor] — the maximum of each selected column separately. + * - [`maxOf`][DataFrame.maxOf] — the maximum of the values a row expression returns for each row. + * - [`min`][DataFrame.min] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -599,11 +599,11 @@ public fun ?> DataFrame.max( * {@include [SelectingColumns.ColumnGroupsAndNestedColumnsSnippet]} * * See also: - * - [max][DataFrame.max] — throws instead of returning `null` when there's nothing to compare. - * - [maxFor][DataFrame.maxFor] — the maximum of each selected column separately. - * - [maxOfOrNull][DataFrame.maxOfOrNull] — the maximum of the values a row expression + * - [`max`][DataFrame.max] — throws instead of returning `null` when there's nothing to compare. + * - [`maxFor`][DataFrame.maxFor] — the maximum of each selected column separately. + * - [`maxOfOrNull`][DataFrame.maxOfOrNull] — the maximum of the values a row expression * returns for each row. - * - [minOrNull][DataFrame.minOrNull] — the mirror operation. + * - [`minOrNull`][DataFrame.minOrNull] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -639,11 +639,11 @@ public fun ?> DataFrame.maxOrNull( * {@include [SelectingColumns.ColumnGroupsAndNestedColumnsSnippet]} * * See also: - * - [max][DataFrame.max] — throws instead of returning `null` when there's nothing to compare. - * - [maxFor][DataFrame.maxFor] — the maximum of each selected column separately. - * - [maxOfOrNull][DataFrame.maxOfOrNull] — the maximum of the values a row expression + * - [`max`][DataFrame.max] — throws instead of returning `null` when there's nothing to compare. + * - [`maxFor`][DataFrame.maxFor] — the maximum of each selected column separately. + * - [`maxOfOrNull`][DataFrame.maxOfOrNull] — the maximum of the values a row expression * returns for each row. - * - [minOrNull][DataFrame.minOrNull] — the mirror operation. + * - [`minOrNull`][DataFrame.minOrNull] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -689,14 +689,14 @@ public fun ?> DataFrame.maxOrNull( * * {@include [MaxDocs.ThrowsOnEmptySnippet]} * - * Don't confuse [maxOf] with [maxBy][DataFrame.maxBy], which returns the row the maximum + * Don't confuse [maxOf] with [`maxBy`][DataFrame.maxBy], which returns the row the maximum * [expression] value belongs to instead of that value. * * See also: - * - [maxOfOrNull][DataFrame.maxOfOrNull] — returns `null` instead of throwing when there's + * - [`maxOfOrNull`][DataFrame.maxOfOrNull] — returns `null` instead of throwing when there's * nothing to compare. - * - [max][DataFrame.max] — a single maximum of all values in the selected columns. - * - [minOf][DataFrame.minOf] — the mirror operation. + * - [`max`][DataFrame.max] — a single maximum of all values in the selected columns. + * - [`minOf`][DataFrame.minOf] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -727,13 +727,13 @@ public inline fun ?> DataFrame.maxOf( * * {@include [MaxDocs.NullOnEmptySnippet]} * - * Don't confuse [maxOfOrNull] with [maxByOrNull][DataFrame.maxByOrNull], which returns the row the + * Don't confuse [maxOfOrNull] with [`maxByOrNull`][DataFrame.maxByOrNull], which returns the row the * maximum [expression] value belongs to instead of that value. * * See also: - * - [maxOf][DataFrame.maxOf] — throws instead of returning `null` when there's nothing to compare. - * - [maxOrNull][DataFrame.maxOrNull] — a single maximum of all values in the selected columns. - * - [minOfOrNull][DataFrame.minOfOrNull] — the mirror operation. + * - [`maxOf`][DataFrame.maxOf] — throws instead of returning `null` when there's nothing to compare. + * - [`maxOrNull`][DataFrame.maxOrNull] — a single maximum of all values in the selected columns. + * - [`minOfOrNull`][DataFrame.minOfOrNull] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -765,14 +765,14 @@ public inline fun ?> DataFrame.maxOfOrNull * * {@include [MaxDocs.ThrowsOnEmptySnippet]} * - * Don't confuse [maxBy] with [maxOf][DataFrame.maxOf], which returns the maximum [expression] value + * Don't confuse [maxBy] with [`maxOf`][DataFrame.maxOf], which returns the maximum [expression] value * itself instead of the row it belongs to. * * See also: - * - [maxByOrNull][DataFrame.maxByOrNull] — returns `null` instead of throwing when there's + * - [`maxByOrNull`][DataFrame.maxByOrNull] — returns `null` instead of throwing when there's * nothing to compare. - * - [minBy][DataFrame.minBy] — the mirror operation. - * - [sortByDesc][DataFrame.sortByDesc] — orders all rows instead of taking just the largest one. + * - [`minBy`][DataFrame.minBy] — the mirror operation. + * - [`sortByDesc`][DataFrame.sortByDesc] — orders all rows instead of taking just the largest one. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MaxBy]} @@ -803,15 +803,15 @@ public inline fun ?> DataFrame.maxBy( * * {@include [MaxDocs.ThrowsOnEmptySnippet]} * - * Don't confuse [maxBy] with [maxOf][DataFrame.maxOf], which returns the maximum value a row + * Don't confuse [maxBy] with [`maxOf`][DataFrame.maxOf], which returns the maximum value a row * expression returns itself, instead of the row it belongs to. * * See also: - * - [maxByOrNull][DataFrame.maxByOrNull] — returns `null` instead of throwing when there's + * - [`maxByOrNull`][DataFrame.maxByOrNull] — returns `null` instead of throwing when there's * nothing to compare. - * - [max][DataFrame.max] — returns the largest value itself instead of the row it belongs to. - * - [minBy][DataFrame.minBy] — the mirror operation. - * - [sortByDesc][DataFrame.sortByDesc] — orders all rows instead of taking just the largest one. + * - [`max`][DataFrame.max] — returns the largest value itself instead of the row it belongs to. + * - [`minBy`][DataFrame.minBy] — the mirror operation. + * - [`sortByDesc`][DataFrame.sortByDesc] — orders all rows instead of taking just the largest one. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MaxBy]} @@ -854,12 +854,12 @@ public inline fun ?> DataFrame.maxBy( * * {@include [MaxDocs.NullOnEmptySnippet]} * - * Don't confuse [maxByOrNull] with [maxOfOrNull][DataFrame.maxOfOrNull], which returns the maximum + * Don't confuse [maxByOrNull] with [`maxOfOrNull`][DataFrame.maxOfOrNull], which returns the maximum * [expression] value itself instead of the row it belongs to. * * See also: - * - [maxBy][DataFrame.maxBy] — throws instead of returning `null` when there's nothing to compare. - * - [minByOrNull][DataFrame.minByOrNull] — the mirror operation. + * - [`maxBy`][DataFrame.maxBy] — throws instead of returning `null` when there's nothing to compare. + * - [`minByOrNull`][DataFrame.minByOrNull] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MaxBy]} @@ -888,14 +888,14 @@ public inline fun ?> DataFrame.maxByOrNull * * {@include [MaxDocs.NullOnEmptySnippet]} * - * Don't confuse [maxByOrNull] with [maxOfOrNull][DataFrame.maxOfOrNull], which returns the maximum + * Don't confuse [maxByOrNull] with [`maxOfOrNull`][DataFrame.maxOfOrNull], which returns the maximum * value a row expression returns itself, instead of the row it belongs to. * * See also: - * - [maxBy][DataFrame.maxBy] — throws instead of returning `null` when there's nothing to compare. - * - [maxOrNull][DataFrame.maxOrNull] — returns the largest value itself instead of + * - [`maxBy`][DataFrame.maxBy] — throws instead of returning `null` when there's nothing to compare. + * - [`maxOrNull`][DataFrame.maxOrNull] — returns the largest value itself instead of * the row it belongs to. - * - [minByOrNull][DataFrame.minByOrNull] — the mirror operation. + * - [`minByOrNull`][DataFrame.minByOrNull] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MaxBy]} @@ -946,11 +946,11 @@ public inline fun ?> DataFrame.maxByOrNull * {@include [MaxDocs.NullCellOnEmptySnippet]} * * See also: - * - [maxFor][Grouped.maxFor] — the same, but for an explicit selection of columns. - * - [max][Grouped.max]` { columns }` — a single maximum of all values in the selected columns, + * - [`maxFor`][Grouped.maxFor] — the same, but for an explicit selection of columns. + * - [`max`][Grouped.max]` { columns }` — a single maximum of all values in the selected columns, * per group. - * - [min][Grouped.min] — the mirror operation. - * - [aggregate][Grouped.aggregate] — the general way to aggregate groups. + * - [`min`][Grouped.min] — the mirror operation. + * - [`aggregate`][Grouped.aggregate] — the general way to aggregate groups. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.GroupByStatistics]}, @@ -988,11 +988,11 @@ public fun Grouped.max(skipNaN: Boolean = skipNaNDefault): DataFrame = * See [Selecting Columns][MaxDocs.MaxForSelectingOptions]. * * See also: - * - [max][Grouped.max]`()` — the same, but for all suitable columns at once. - * - [max][Grouped.max]` { columns }` — a single maximum of all values in the selected columns, + * - [`max`][Grouped.max]`()` — the same, but for all suitable columns at once. + * - [`max`][Grouped.max]` { columns }` — a single maximum of all values in the selected columns, * per group. - * - [minFor][Grouped.minFor] — the mirror operation. - * - [aggregate][Grouped.aggregate] — the general way to aggregate groups. + * - [`minFor`][Grouped.minFor] — the mirror operation. + * - [`aggregate`][Grouped.aggregate] — the general way to aggregate groups. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.GroupByStatistics]}, @@ -1032,11 +1032,11 @@ public fun ?> Grouped.maxFor( * See [Selecting Columns][MaxDocs.MaxForSelectingOptions]. * * See also: - * - [max][Grouped.max]`()` — the same, but for all suitable columns at once. - * - [max][Grouped.max]` { columns }` — a single maximum of all values in the selected columns, + * - [`max`][Grouped.max]`()` — the same, but for all suitable columns at once. + * - [`max`][Grouped.max]` { columns }` — a single maximum of all values in the selected columns, * per group. - * - [minFor][Grouped.minFor] — the mirror operation. - * - [aggregate][Grouped.aggregate] — the general way to aggregate groups. + * - [`minFor`][Grouped.minFor] — the mirror operation. + * - [`aggregate`][Grouped.aggregate] — the general way to aggregate groups. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.GroupByStatistics]}, @@ -1087,11 +1087,11 @@ public fun ?> Grouped.maxFor( * See [Selecting Columns][MaxDocs.MaxSelectingOptions]. * * See also: - * - [maxFor][Grouped.maxFor] — the maximum of each selected column separately, per group. - * - [maxOf][Grouped.maxOf] — the maximum of the values a row expression returns + * - [`maxFor`][Grouped.maxFor] — the maximum of each selected column separately, per group. + * - [`maxOf`][Grouped.maxOf] — the maximum of the values a row expression returns * for each row of a group. - * - [min][Grouped.min] — the mirror operation. - * - [aggregate][Grouped.aggregate] — the general way to aggregate groups. + * - [`min`][Grouped.min] — the mirror operation. + * - [`aggregate`][Grouped.aggregate] — the general way to aggregate groups. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.GroupByStatistics]}, @@ -1137,11 +1137,11 @@ public fun ?> Grouped.max( * See [Selecting Columns][MaxDocs.MaxSelectingOptions]. * * See also: - * - [maxFor][Grouped.maxFor] — the maximum of each selected column separately, per group. - * - [maxOf][Grouped.maxOf] — the maximum of the values a row expression returns + * - [`maxFor`][Grouped.maxFor] — the maximum of each selected column separately, per group. + * - [`maxOf`][Grouped.maxOf] — the maximum of the values a row expression returns * for each row of a group. - * - [min][Grouped.min] — the mirror operation. - * - [aggregate][Grouped.aggregate] — the general way to aggregate groups. + * - [`min`][Grouped.min] — the mirror operation. + * - [`aggregate`][Grouped.aggregate] — the general way to aggregate groups. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.GroupByStatistics]}, @@ -1196,13 +1196,13 @@ public fun ?> Grouped.max( * * {@include [MaxDocs.NullCellOnEmptySnippet]} * - * Don't confuse [maxOf] with [maxBy][GroupBy.maxBy], which returns the row of each group for which + * Don't confuse [maxOf] with [`maxBy`][GroupBy.maxBy], which returns the row of each group for which * the expression returns the maximum value, instead of that value. * * See also: - * - [max][Grouped.max] — a single maximum of all values in the selected columns, per group. - * - [minOf][Grouped.minOf] — the mirror operation. - * - [aggregate][Grouped.aggregate] — the general way to aggregate groups. + * - [`max`][Grouped.max] — a single maximum of all values in the selected columns, per group. + * - [`minOf`][Grouped.minOf] — the mirror operation. + * - [`aggregate`][Grouped.aggregate] — the general way to aggregate groups. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.GroupByStatistics]}, @@ -1239,11 +1239,11 @@ public inline fun ?> Grouped.maxOf( * * Groups that have no values to compare cannot select a row, and produce `null` values instead. * - * Don't confuse [maxBy] with [maxOf][Grouped.maxOf], which returns the maximum value itself + * Don't confuse [maxBy] with [`maxOf`][Grouped.maxOf], which returns the maximum value itself * instead of the row it belongs to. * * See also: - * - [minBy][GroupBy.minBy] — the mirror operation. + * - [`minBy`][GroupBy.minBy] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MaxBy]} @@ -1282,12 +1282,12 @@ public inline fun ?> GroupBy.maxBy( * * Groups that have no values to compare cannot select a row, and produce `null` values instead. * - * Don't confuse [maxBy] with [maxOf][Grouped.maxOf], which returns the maximum value a row + * Don't confuse [maxBy] with [`maxOf`][Grouped.maxOf], which returns the maximum value a row * expression returns itself, instead of the row it belongs to. * * See also: - * - [max][Grouped.max] — the maximum value itself instead of the row it belongs to. - * - [minBy][GroupBy.minBy] — the mirror operation. + * - [`max`][Grouped.max] — the maximum value itself instead of the row it belongs to. + * - [`minBy`][GroupBy.minBy] — the mirror operation. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * * For more information: {@include [DocumentationUrls.MaxBy]} @@ -1333,10 +1333,10 @@ public inline fun ?> GroupBy.maxBy( * Check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [maxFor][Pivot.maxFor] — the same, but for an explicit selection of columns. - * - [max][Pivot.max]` { columns }` — a single maximum of all values in the selected columns, + * - [`maxFor`][Pivot.maxFor] — the same, but for an explicit selection of columns. + * - [`max`][Pivot.max]` { columns }` — a single maximum of all values in the selected columns, * per group. - * - [min][Pivot.min] — the mirror operation. + * - [`min`][Pivot.min] — the mirror operation. * - [Pivot aggregation][PivotDocs.Aggregation] — all other ways to aggregate a [Pivot]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * @@ -1374,10 +1374,10 @@ public fun Pivot.max(separate: Boolean = false, skipNaN: Boolean = skipNa * See [Selecting Columns][MaxDocs.MaxForSelectingOptions], or check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [max][Pivot.max]`()` — the same, but for all suitable columns at once. - * - [max][Pivot.max]` { columns }` — a single maximum of all values in the selected columns, + * - [`max`][Pivot.max]`()` — the same, but for all suitable columns at once. + * - [`max`][Pivot.max]` { columns }` — a single maximum of all values in the selected columns, * per group. - * - [minFor][Pivot.minFor] — the mirror operation. + * - [`minFor`][Pivot.minFor] — the mirror operation. * - [Pivot aggregation][PivotDocs.Aggregation] — all other ways to aggregate a [Pivot]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * @@ -1420,10 +1420,10 @@ public fun ?> Pivot.maxFor( * See [Selecting Columns][MaxDocs.MaxForSelectingOptions], or check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [max][Pivot.max]`()` — the same, but for all suitable columns at once. - * - [max][Pivot.max]` { columns }` — a single maximum of all values in the selected columns, + * - [`max`][Pivot.max]`()` — the same, but for all suitable columns at once. + * - [`max`][Pivot.max]` { columns }` — a single maximum of all values in the selected columns, * per group. - * - [minFor][Pivot.minFor] — the mirror operation. + * - [`minFor`][Pivot.minFor] — the mirror operation. * - [Pivot aggregation][PivotDocs.Aggregation] — all other ways to aggregate a [Pivot]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * @@ -1479,9 +1479,9 @@ public fun ?> Pivot.maxFor( * See [Selecting Columns][MaxDocs.MaxSelectingOptions], or check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [max][Pivot.max]`()` — the maximum of each suitable column separately, per group. - * - [maxFor][Pivot.maxFor] — the maximum of each selected column separately, per group. - * - [min][Pivot.min] — the mirror operation. + * - [`max`][Pivot.max]`()` — the maximum of each suitable column separately, per group. + * - [`maxFor`][Pivot.maxFor] — the maximum of each selected column separately, per group. + * - [`min`][Pivot.min] — the mirror operation. * - [Pivot aggregation][PivotDocs.Aggregation] — all other ways to aggregate a [Pivot]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * @@ -1520,9 +1520,9 @@ public fun ?> Pivot.max( * See [Selecting Columns][MaxDocs.MaxSelectingOptions], or check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [max][Pivot.max]`()` — the maximum of each suitable column separately, per group. - * - [maxFor][Pivot.maxFor] — the maximum of each selected column separately, per group. - * - [min][Pivot.min] — the mirror operation. + * - [`max`][Pivot.max]`()` — the maximum of each suitable column separately, per group. + * - [`maxFor`][Pivot.maxFor] — the maximum of each selected column separately, per group. + * - [`min`][Pivot.min] — the mirror operation. * - [Pivot aggregation][PivotDocs.Aggregation] — all other ways to aggregate a [Pivot]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * @@ -1570,15 +1570,15 @@ public fun ?> Pivot.max( * * {@include [MaxDocs.NullCellOnEmptySnippet]} * - * Don't confuse [maxOf] with [maxBy][Pivot.maxBy], which returns the first row of each group for + * Don't confuse [maxOf] with [`maxBy`][Pivot.maxBy], which returns the first row of each group for * which the expression returns the maximum value, instead of that value. * * Check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [max][Pivot.max]` { columns }` — a single maximum of all values in the selected columns, + * - [`max`][Pivot.max]` { columns }` — a single maximum of all values in the selected columns, * per group. - * - [minOf][Pivot.minOf] — the mirror operation. + * - [`minOf`][Pivot.minOf] — the mirror operation. * - [Pivot aggregation][PivotDocs.Aggregation] — all other ways to aggregate a [Pivot]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * @@ -1612,13 +1612,13 @@ public inline fun ?> Pivot.maxOf( * * {@include [MaxDocs.ReducedPivotSnippet]} * - * Don't confuse [maxBy] with [maxOf][Pivot.maxOf], which returns the maximum value the expression + * Don't confuse [maxBy] with [`maxOf`][Pivot.maxOf], which returns the maximum value the expression * returns itself, instead of the row. * * Check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [minBy][Pivot.minBy] — the mirror operation. + * - [`minBy`][Pivot.minBy] — the mirror operation. * - [Pivot reducing][PivotDocs.Reducing] — all other ways to reduce a [Pivot]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * @@ -1657,14 +1657,14 @@ public inline fun ?> Pivot.maxBy( * * {@include [MaxDocs.ReducedPivotSnippet]} * - * Don't confuse [maxBy] with [maxOf][Pivot.maxOf], which returns the maximum value a row expression + * Don't confuse [maxBy] with [`maxOf`][Pivot.maxOf], which returns the maximum value a row expression * returns itself, instead of the row. * * Check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [max][Pivot.max]` { columns }` — the maximum value itself, instead of the row. - * - [minBy][Pivot.minBy] — the mirror operation. + * - [`max`][Pivot.max]` { columns }` — the maximum value itself, instead of the row. + * - [`minBy`][Pivot.minBy] — the mirror operation. * - [Pivot reducing][PivotDocs.Reducing] — all other ways to reduce a [Pivot]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. * @@ -1711,10 +1711,10 @@ public inline fun ?> Pivot.maxBy( * Check out the [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [maxFor][PivotGroupBy.maxFor] — the same, but for an explicit selection of columns. - * - [max][PivotGroupBy.max]` { columns }` — a single maximum of all values in the selected columns, + * - [`maxFor`][PivotGroupBy.maxFor] — the same, but for an explicit selection of columns. + * - [`max`][PivotGroupBy.max]` { columns }` — a single maximum of all values in the selected columns, * per group. - * - [min][PivotGroupBy.min] — the mirror operation. + * - [`min`][PivotGroupBy.min] — the mirror operation. * - [PivotGroupBy aggregation][PivotGroupByDocs.Aggregation] — all other ways to aggregate * a [PivotGroupBy]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. @@ -1754,10 +1754,10 @@ public fun PivotGroupBy.max(separate: Boolean = false, skipNaN: Boolean = * [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [max][PivotGroupBy.max]`()` — the same, but for all suitable columns at once. - * - [max][PivotGroupBy.max]` { columns }` — a single maximum of all values in the selected columns, + * - [`max`][PivotGroupBy.max]`()` — the same, but for all suitable columns at once. + * - [`max`][PivotGroupBy.max]` { columns }` — a single maximum of all values in the selected columns, * per group. - * - [minFor][PivotGroupBy.minFor] — the mirror operation. + * - [`minFor`][PivotGroupBy.minFor] — the mirror operation. * - [PivotGroupBy aggregation][PivotGroupByDocs.Aggregation] — all other ways to aggregate * a [PivotGroupBy]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. @@ -1800,10 +1800,10 @@ public fun ?> PivotGroupBy.maxFor( * [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [max][PivotGroupBy.max]`()` — the same, but for all suitable columns at once. - * - [max][PivotGroupBy.max]` { columns }` — a single maximum of all values in the selected columns, + * - [`max`][PivotGroupBy.max]`()` — the same, but for all suitable columns at once. + * - [`max`][PivotGroupBy.max]` { columns }` — a single maximum of all values in the selected columns, * per group. - * - [minFor][PivotGroupBy.minFor] — the mirror operation. + * - [`minFor`][PivotGroupBy.minFor] — the mirror operation. * - [PivotGroupBy aggregation][PivotGroupByDocs.Aggregation] — all other ways to aggregate * a [PivotGroupBy]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. @@ -1862,9 +1862,9 @@ public fun ?> PivotGroupBy.maxFor( * [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [max][PivotGroupBy.max]`()` — the maximum of each suitable column separately, per group. - * - [maxFor][PivotGroupBy.maxFor] — the maximum of each selected column separately, per group. - * - [min][PivotGroupBy.min] — the mirror operation. + * - [`max`][PivotGroupBy.max]`()` — the maximum of each suitable column separately, per group. + * - [`maxFor`][PivotGroupBy.maxFor] — the maximum of each selected column separately, per group. + * - [`min`][PivotGroupBy.min] — the mirror operation. * - [PivotGroupBy aggregation][PivotGroupByDocs.Aggregation] — all other ways to aggregate * a [PivotGroupBy]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. @@ -1906,9 +1906,9 @@ public fun ?> PivotGroupBy.max( * [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [max][PivotGroupBy.max]`()` — the maximum of each suitable column separately, per group. - * - [maxFor][PivotGroupBy.maxFor] — the maximum of each selected column separately, per group. - * - [min][PivotGroupBy.min] — the mirror operation. + * - [`max`][PivotGroupBy.max]`()` — the maximum of each suitable column separately, per group. + * - [`maxFor`][PivotGroupBy.maxFor] — the maximum of each selected column separately, per group. + * - [`min`][PivotGroupBy.min] — the mirror operation. * - [PivotGroupBy aggregation][PivotGroupByDocs.Aggregation] — all other ways to aggregate * a [PivotGroupBy]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. @@ -1957,15 +1957,15 @@ public fun ?> PivotGroupBy.max( * * {@include [MaxDocs.NullCellOnEmptySnippet]} * - * Don't confuse [maxOf] with [maxBy][PivotGroupBy.maxBy], which returns the first row of each group + * Don't confuse [maxOf] with [`maxBy`][PivotGroupBy.maxBy], which returns the first row of each group * for which the expression returns the maximum value, instead of that value. * * Check out the [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [max][PivotGroupBy.max]` { columns }` — a single maximum of all values in the selected columns, + * - [`max`][PivotGroupBy.max]` { columns }` — a single maximum of all values in the selected columns, * per group. - * - [minOf][PivotGroupBy.minOf] — the mirror operation. + * - [`minOf`][PivotGroupBy.minOf] — the mirror operation. * - [PivotGroupBy aggregation][PivotGroupByDocs.Aggregation] — all other ways to aggregate * a [PivotGroupBy]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. @@ -2000,13 +2000,13 @@ public inline fun ?> PivotGroupBy.maxOf( * * {@include [MaxDocs.ReducedPivotGroupBySnippet]} * - * Don't confuse [maxBy] with [maxOf][PivotGroupBy.maxOf], which returns the maximum value the + * Don't confuse [maxBy] with [`maxOf`][PivotGroupBy.maxOf], which returns the maximum value the * expression returns itself, instead of the row. * * Check out the [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [minBy][PivotGroupBy.minBy] — the mirror operation. + * - [`minBy`][PivotGroupBy.minBy] — the mirror operation. * - [PivotGroupBy reducing][PivotGroupByDocs.Reducing] — all other ways to reduce * a [PivotGroupBy]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. @@ -2046,14 +2046,14 @@ public inline fun ?> PivotGroupBy.maxBy( * * {@include [MaxDocs.ReducedPivotGroupBySnippet]} * - * Don't confuse [maxBy] with [maxOf][PivotGroupBy.maxOf], which returns the maximum value a row + * Don't confuse [maxBy] with [`maxOf`][PivotGroupBy.maxOf], which returns the maximum value a row * expression returns itself, instead of the row. * * Check out the [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [max][PivotGroupBy.max]` { columns }` — the maximum value itself, instead of the row. - * - [minBy][PivotGroupBy.minBy] — the mirror operation. + * - [`max`][PivotGroupBy.max]` { columns }` — the maximum value itself, instead of the row. + * - [`minBy`][PivotGroupBy.minBy] — the mirror operation. * - [PivotGroupBy reducing][PivotGroupByDocs.Reducing] — all other ways to reduce * a [PivotGroupBy]. * - {@include [MaxDocsLink]} — an overview of all `max` modes. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt index 0ef4a7ffe5..acb0e63821 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt @@ -50,18 +50,18 @@ import kotlin.reflect.KProperty * Depending on what exactly you want the minimum of, there are several modes. * They are shown here for [DataFrame], but they exist for the other receivers too: * - * - [min][DataFrame.min]`()` — the minimum of each suitable column separately. - * - [min][DataFrame.min]` { columns }` — a single minimum of all values in all selected columns. - * - [minFor][DataFrame.minFor]` { columns }` — the minimum of each selected column separately. - * - [minOf][DataFrame.minOf]` { expression }` — the minimum of the values that the given expression + * - [`min`][DataFrame.min]`()` — the minimum of each suitable column separately. + * - [`min`][DataFrame.min]` { columns }` — a single minimum of all values in all selected columns. + * - [`minFor`][DataFrame.minFor]` { columns }` — the minimum of each selected column separately. + * - [`minOf`][DataFrame.minOf]` { expression }` — the minimum of the values that the given expression * returns for each row. - * - [minBy][DataFrame.minBy]` { expression }` — the first row for which the given expression returns + * - [`minBy`][DataFrame.minBy]` { expression }` — the first row for which the given expression returns * the minimum value. * - * [min][DataFrame.min], [minOf][DataFrame.minOf], and [minBy][DataFrame.minBy] all have an `-OrNull` + * [`min`][DataFrame.min], [`minOf`][DataFrame.minOf], and [`minBy`][DataFrame.minBy] all have an `-OrNull` * counterpart which returns `null` instead of throwing an exception when there's nothing to compare. * - * Mirror operation: [max][DataFrame.max]. + * Mirror operation: [`max`][DataFrame.max]. * * For more information: {@include [DocumentationUrls.MinMax]} * @@ -86,15 +86,15 @@ internal interface MinDocs : CommonMinMaxDocs { @ExcludeFromSources private typealias MinDocsLink = Nothing -/** {@set [SelectingColumns.OPERATION] [min][min]} */ +/** {@set [SelectingColumns.OPERATION] [`min`][min]} */ @ExcludeFromSources private typealias SetMinOperationArg = Nothing -/** {@set [SelectingColumns.OPERATION] [minFor][minFor]} */ +/** {@set [SelectingColumns.OPERATION] [`minFor`][minFor]} */ @ExcludeFromSources private typealias SetMinForOperationArg = Nothing -/** {@set [SelectingColumns.OPERATION] [minOrNull][minOrNull]} */ +/** {@set [SelectingColumns.OPERATION] [`minOrNull`][minOrNull]} */ @ExcludeFromSources private typealias SetMinOrNullOperationArg = Nothing @@ -110,10 +110,10 @@ private typealias SetMinOrNullOperationArg = Nothing * {@include [MinDocs.ThrowsOnEmptySnippet]} * * See also: - * - [minOrNull][DataColumn.minOrNull] — returns `null` instead of throwing for a column with nothing to compare. - * - [minOf][DataColumn.minOf] — the minimum of the values a selector returns for each element. - * - [minBy][DataColumn.minBy] — the element for which a selector returns the minimum value. - * - [max][DataColumn.max] — the mirror operation. + * - [`minOrNull`][DataColumn.minOrNull] — returns `null` instead of throwing for a column with nothing to compare. + * - [`minOf`][DataColumn.minOf] — the minimum of the values a selector returns for each element. + * - [`minBy`][DataColumn.minBy] — the element for which a selector returns the minimum value. + * - [`max`][DataColumn.max] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -141,12 +141,12 @@ public fun > DataColumn.min(skipNaN: Boolean = skipNaNDefa * {@include [MinDocs.NullOnEmptySnippet]} * * See also: - * - [min][DataColumn.min] — throws instead of returning `null` for a column with nothing to compare. - * - [minOfOrNull][DataColumn.minOfOrNull] — the minimum of the values a selector returns + * - [`min`][DataColumn.min] — throws instead of returning `null` for a column with nothing to compare. + * - [`minOfOrNull`][DataColumn.minOfOrNull] — the minimum of the values a selector returns * for each element. - * - [minByOrNull][DataColumn.minByOrNull] — the element for which a selector returns + * - [`minByOrNull`][DataColumn.minByOrNull] — the element for which a selector returns * the minimum value. - * - [maxOrNull][DataColumn.maxOrNull] — the mirror operation. + * - [`maxOrNull`][DataColumn.maxOrNull] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -172,12 +172,12 @@ public fun > DataColumn.minOrNull(skipNaN: Boolean = skipN * * {@include [MinDocs.ThrowsOnEmptySnippet]} * - * Don't confuse [minBy] with [minOf][DataColumn.minOf], which returns the minimum [selector] value itself + * Don't confuse [minBy] with [`minOf`][DataColumn.minOf], which returns the minimum [selector] value itself * instead of the element it belongs to. * * See also: - * - [minByOrNull][DataColumn.minByOrNull] — returns `null` instead of throwing for a column with nothing to compare. - * - [maxBy][DataColumn.maxBy] — the mirror operation. + * - [`minByOrNull`][DataColumn.minByOrNull] — returns `null` instead of throwing for a column with nothing to compare. + * - [`maxBy`][DataColumn.maxBy] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinBy]} @@ -206,12 +206,12 @@ public inline fun ?> DataColumn.minBy( * * {@include [MinDocs.NullOnEmptySnippet]} * - * Don't confuse [minByOrNull] with [minOfOrNull][DataColumn.minOfOrNull], which returns the minimum + * Don't confuse [minByOrNull] with [`minOfOrNull`][DataColumn.minOfOrNull], which returns the minimum * [selector] value itself instead of the element it belongs to. * * See also: - * - [minBy][DataColumn.minBy] — throws instead of returning `null` for a column with nothing to compare. - * - [maxByOrNull][DataColumn.maxByOrNull] — the mirror operation. + * - [`minBy`][DataColumn.minBy] — throws instead of returning `null` for a column with nothing to compare. + * - [`maxByOrNull`][DataColumn.maxByOrNull] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinBy]} @@ -241,12 +241,12 @@ public inline fun ?> DataColumn.minByOrNul * * {@include [MinDocs.ThrowsOnEmptySnippet]} * - * Don't confuse [minOf] with [minBy][DataColumn.minBy], which returns the element the minimum + * Don't confuse [minOf] with [`minBy`][DataColumn.minBy], which returns the element the minimum * [selector] value belongs to instead of that value. * * See also: - * - [minOfOrNull][DataColumn.minOfOrNull] — returns `null` instead of throwing for a column with nothing to compare. - * - [maxOf][DataColumn.maxOf] — the mirror operation. + * - [`minOfOrNull`][DataColumn.minOfOrNull] — returns `null` instead of throwing for a column with nothing to compare. + * - [`maxOf`][DataColumn.maxOf] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -275,12 +275,12 @@ public inline fun ?> DataColumn.minOf( * * {@include [MinDocs.NullOnEmptySnippet]} * - * Don't confuse [minOfOrNull] with [minByOrNull][DataColumn.minByOrNull], which returns the element + * Don't confuse [minOfOrNull] with [`minByOrNull`][DataColumn.minByOrNull], which returns the element * the minimum [selector] value belongs to instead of that value. * * See also: - * - [minOf][DataColumn.minOf] — throws instead of returning `null` for a column with nothing to compare. - * - [maxOfOrNull][DataColumn.maxOfOrNull] — the mirror operation. + * - [`minOf`][DataColumn.minOf] — throws instead of returning `null` for a column with nothing to compare. + * - [`maxOfOrNull`][DataColumn.maxOfOrNull] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -324,9 +324,9 @@ public fun DataRow<*>.rowMin(): Nothing = error(ROW_MIN) * {@include [MinDocs.NullOnEmptySnippet]} * * See also: - * - [rowMinOf][DataRow.rowMinOf] — throws instead of returning `null` when there's nothing to compare. - * - [rowMaxOfOrNull][DataRow.rowMaxOfOrNull] — the mirror operation. - * - [minOrNull][DataFrame.minOrNull] — the minimum of the values in specific columns of a [DataFrame]. + * - [`rowMinOf`][DataRow.rowMinOf] — throws instead of returning `null` when there's nothing to compare. + * - [`rowMaxOfOrNull`][DataRow.rowMaxOfOrNull] — the mirror operation. + * - [`minOrNull`][DataFrame.minOrNull] — the minimum of the values in specific columns of a [DataFrame]. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.RowStatistics]} @@ -355,10 +355,10 @@ public inline fun > DataRow<*>.rowMinOfOrNull(skipNaN: * {@include [MinDocs.ThrowsOnEmptySnippet]} * * See also: - * - [rowMinOfOrNull][DataRow.rowMinOfOrNull] — returns `null` instead of throwing + * - [`rowMinOfOrNull`][DataRow.rowMinOfOrNull] — returns `null` instead of throwing * when there's nothing to compare. - * - [rowMaxOf][DataRow.rowMaxOf] — the mirror operation. - * - [min][DataFrame.min] — the minimum of the values in specific columns of a [DataFrame]. + * - [`rowMaxOf`][DataRow.rowMaxOf] — the mirror operation. + * - [`min`][DataFrame.min] — the minimum of the values in specific columns of a [DataFrame]. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.RowStatistics]} @@ -392,9 +392,9 @@ public inline fun > DataRow<*>.rowMinOf(skipNaN: Boole * {@include [MinDocs.NullCellOnEmptySnippet]} * * See also: - * - [minFor][DataFrame.minFor] — the same, but for an explicit selection of columns. - * - [min][DataFrame.min]` { columns }` — a single minimum of all values in the selected columns. - * - [max][DataFrame.max] — the mirror operation. + * - [`minFor`][DataFrame.minFor] — the same, but for an explicit selection of columns. + * - [`min`][DataFrame.min]` { columns }` — a single minimum of all values in the selected columns. + * - [`max`][DataFrame.max] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -428,9 +428,9 @@ public fun DataFrame.min(skipNaN: Boolean = skipNaNDefault): DataRow = * See [Selecting Columns][MinDocs.MinForSelectingOptions]. * * See also: - * - [min][DataFrame.min]`()` — the same, but for all suitable columns at once. - * - [min][DataFrame.min]` { columns }` — a single minimum of all values in the selected columns. - * - [maxFor][DataFrame.maxFor] — the mirror operation. + * - [`min`][DataFrame.min]`()` — the same, but for all suitable columns at once. + * - [`min`][DataFrame.min]` { columns }` — a single minimum of all values in the selected columns. + * - [`maxFor`][DataFrame.maxFor] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -467,9 +467,9 @@ public fun ?> DataFrame.minFor( * See [Selecting Columns][MinDocs.MinForSelectingOptions]. * * See also: - * - [min][DataFrame.min]`()` — the same, but for all suitable columns at once. - * - [min][DataFrame.min]` { columns }` — a single minimum of all values in the selected columns. - * - [maxFor][DataFrame.maxFor] — the mirror operation. + * - [`min`][DataFrame.min]`()` — the same, but for all suitable columns at once. + * - [`min`][DataFrame.min]` { columns }` — a single minimum of all values in the selected columns. + * - [`maxFor`][DataFrame.maxFor] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -511,11 +511,11 @@ public fun ?> DataFrame.minFor( * {@include [SelectingColumns.ColumnGroupsAndNestedColumnsSnippet]} * * See also: - * - [minOrNull][DataFrame.minOrNull] — returns `null` instead of throwing when there's + * - [`minOrNull`][DataFrame.minOrNull] — returns `null` instead of throwing when there's * nothing to compare. - * - [minFor][DataFrame.minFor] — the minimum of each selected column separately. - * - [minOf][DataFrame.minOf] — the minimum of the values a row expression returns for each row. - * - [max][DataFrame.max] — the mirror operation. + * - [`minFor`][DataFrame.minFor] — the minimum of each selected column separately. + * - [`minOf`][DataFrame.minOf] — the minimum of the values a row expression returns for each row. + * - [`max`][DataFrame.max] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -549,11 +549,11 @@ public fun ?> DataFrame.min( * {@include [SelectingColumns.ColumnGroupsAndNestedColumnsSnippet]} * * See also: - * - [minOrNull][DataFrame.minOrNull] — returns `null` instead of throwing when there's + * - [`minOrNull`][DataFrame.minOrNull] — returns `null` instead of throwing when there's * nothing to compare. - * - [minFor][DataFrame.minFor] — the minimum of each selected column separately. - * - [minOf][DataFrame.minOf] — the minimum of the values a row expression returns for each row. - * - [max][DataFrame.max] — the mirror operation. + * - [`minFor`][DataFrame.minFor] — the minimum of each selected column separately. + * - [`minOf`][DataFrame.minOf] — the minimum of the values a row expression returns for each row. + * - [`max`][DataFrame.max] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -599,11 +599,11 @@ public fun ?> DataFrame.min( * {@include [SelectingColumns.ColumnGroupsAndNestedColumnsSnippet]} * * See also: - * - [min][DataFrame.min] — throws instead of returning `null` when there's nothing to compare. - * - [minFor][DataFrame.minFor] — the minimum of each selected column separately. - * - [minOfOrNull][DataFrame.minOfOrNull] — the minimum of the values a row expression + * - [`min`][DataFrame.min] — throws instead of returning `null` when there's nothing to compare. + * - [`minFor`][DataFrame.minFor] — the minimum of each selected column separately. + * - [`minOfOrNull`][DataFrame.minOfOrNull] — the minimum of the values a row expression * returns for each row. - * - [maxOrNull][DataFrame.maxOrNull] — the mirror operation. + * - [`maxOrNull`][DataFrame.maxOrNull] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -639,11 +639,11 @@ public fun ?> DataFrame.minOrNull( * {@include [SelectingColumns.ColumnGroupsAndNestedColumnsSnippet]} * * See also: - * - [min][DataFrame.min] — throws instead of returning `null` when there's nothing to compare. - * - [minFor][DataFrame.minFor] — the minimum of each selected column separately. - * - [minOfOrNull][DataFrame.minOfOrNull] — the minimum of the values a row expression + * - [`min`][DataFrame.min] — throws instead of returning `null` when there's nothing to compare. + * - [`minFor`][DataFrame.minFor] — the minimum of each selected column separately. + * - [`minOfOrNull`][DataFrame.minOfOrNull] — the minimum of the values a row expression * returns for each row. - * - [maxOrNull][DataFrame.maxOrNull] — the mirror operation. + * - [`maxOrNull`][DataFrame.maxOrNull] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -689,14 +689,14 @@ public fun ?> DataFrame.minOrNull( * * {@include [MinDocs.ThrowsOnEmptySnippet]} * - * Don't confuse [minOf] with [minBy][DataFrame.minBy], which returns the row the minimum + * Don't confuse [minOf] with [`minBy`][DataFrame.minBy], which returns the row the minimum * [expression] value belongs to instead of that value. * * See also: - * - [minOfOrNull][DataFrame.minOfOrNull] — returns `null` instead of throwing when there's + * - [`minOfOrNull`][DataFrame.minOfOrNull] — returns `null` instead of throwing when there's * nothing to compare. - * - [min][DataFrame.min] — a single minimum of all values in the selected columns. - * - [maxOf][DataFrame.maxOf] — the mirror operation. + * - [`min`][DataFrame.min] — a single minimum of all values in the selected columns. + * - [`maxOf`][DataFrame.maxOf] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -727,13 +727,13 @@ public inline fun ?> DataFrame.minOf( * * {@include [MinDocs.NullOnEmptySnippet]} * - * Don't confuse [minOfOrNull] with [minByOrNull][DataFrame.minByOrNull], which returns the row the + * Don't confuse [minOfOrNull] with [`minByOrNull`][DataFrame.minByOrNull], which returns the row the * minimum [expression] value belongs to instead of that value. * * See also: - * - [minOf][DataFrame.minOf] — throws instead of returning `null` when there's nothing to compare. - * - [minOrNull][DataFrame.minOrNull] — a single minimum of all values in the selected columns. - * - [maxOfOrNull][DataFrame.maxOfOrNull] — the mirror operation. + * - [`minOf`][DataFrame.minOf] — throws instead of returning `null` when there's nothing to compare. + * - [`minOrNull`][DataFrame.minOrNull] — a single minimum of all values in the selected columns. + * - [`maxOfOrNull`][DataFrame.maxOfOrNull] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinMax]} @@ -765,14 +765,14 @@ public inline fun ?> DataFrame.minOfOrNull * * {@include [MinDocs.ThrowsOnEmptySnippet]} * - * Don't confuse [minBy] with [minOf][DataFrame.minOf], which returns the minimum [expression] value + * Don't confuse [minBy] with [`minOf`][DataFrame.minOf], which returns the minimum [expression] value * itself instead of the row it belongs to. * * See also: - * - [minByOrNull][DataFrame.minByOrNull] — returns `null` instead of throwing when there's + * - [`minByOrNull`][DataFrame.minByOrNull] — returns `null` instead of throwing when there's * nothing to compare. - * - [maxBy][DataFrame.maxBy] — the mirror operation. - * - [sortBy][DataFrame.sortBy] — orders all rows instead of taking just the smallest one. + * - [`maxBy`][DataFrame.maxBy] — the mirror operation. + * - [`sortBy`][DataFrame.sortBy] — orders all rows instead of taking just the smallest one. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinBy]} @@ -803,15 +803,15 @@ public inline fun ?> DataFrame.minBy( * * {@include [MinDocs.ThrowsOnEmptySnippet]} * - * Don't confuse [minBy] with [minOf][DataFrame.minOf], which returns the minimum value a row + * Don't confuse [minBy] with [`minOf`][DataFrame.minOf], which returns the minimum value a row * expression returns itself, instead of the row it belongs to. * * See also: - * - [minByOrNull][DataFrame.minByOrNull] — returns `null` instead of throwing when there's + * - [`minByOrNull`][DataFrame.minByOrNull] — returns `null` instead of throwing when there's * nothing to compare. - * - [min][DataFrame.min] — returns the smallest value itself instead of the row it belongs to. - * - [maxBy][DataFrame.maxBy] — the mirror operation. - * - [sortBy][DataFrame.sortBy] — orders all rows instead of taking just the smallest one. + * - [`min`][DataFrame.min] — returns the smallest value itself instead of the row it belongs to. + * - [`maxBy`][DataFrame.maxBy] — the mirror operation. + * - [`sortBy`][DataFrame.sortBy] — orders all rows instead of taking just the smallest one. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinBy]} @@ -854,12 +854,12 @@ public inline fun ?> DataFrame.minBy( * * {@include [MinDocs.NullOnEmptySnippet]} * - * Don't confuse [minByOrNull] with [minOfOrNull][DataFrame.minOfOrNull], which returns the minimum + * Don't confuse [minByOrNull] with [`minOfOrNull`][DataFrame.minOfOrNull], which returns the minimum * [expression] value itself instead of the row it belongs to. * * See also: - * - [minBy][DataFrame.minBy] — throws instead of returning `null` when there's nothing to compare. - * - [maxByOrNull][DataFrame.maxByOrNull] — the mirror operation. + * - [`minBy`][DataFrame.minBy] — throws instead of returning `null` when there's nothing to compare. + * - [`maxByOrNull`][DataFrame.maxByOrNull] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinBy]} @@ -888,14 +888,14 @@ public inline fun ?> DataFrame.minByOrNull * * {@include [MinDocs.NullOnEmptySnippet]} * - * Don't confuse [minByOrNull] with [minOfOrNull][DataFrame.minOfOrNull], which returns the minimum + * Don't confuse [minByOrNull] with [`minOfOrNull`][DataFrame.minOfOrNull], which returns the minimum * value a row expression returns itself, instead of the row it belongs to. * * See also: - * - [minBy][DataFrame.minBy] — throws instead of returning `null` when there's nothing to compare. - * - [minOrNull][DataFrame.minOrNull] — returns the smallest value itself instead of + * - [`minBy`][DataFrame.minBy] — throws instead of returning `null` when there's nothing to compare. + * - [`minOrNull`][DataFrame.minOrNull] — returns the smallest value itself instead of * the row it belongs to. - * - [maxByOrNull][DataFrame.maxByOrNull] — the mirror operation. + * - [`maxByOrNull`][DataFrame.maxByOrNull] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinBy]} @@ -946,11 +946,11 @@ public inline fun ?> DataFrame.minByOrNull * {@include [MinDocs.NullCellOnEmptySnippet]} * * See also: - * - [minFor][Grouped.minFor] — the same, but for an explicit selection of columns. - * - [min][Grouped.min]` { columns }` — a single minimum of all values in the selected columns, + * - [`minFor`][Grouped.minFor] — the same, but for an explicit selection of columns. + * - [`min`][Grouped.min]` { columns }` — a single minimum of all values in the selected columns, * per group. - * - [max][Grouped.max] — the mirror operation. - * - [aggregate][Grouped.aggregate] — the general way to aggregate groups. + * - [`max`][Grouped.max] — the mirror operation. + * - [`aggregate`][Grouped.aggregate] — the general way to aggregate groups. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.GroupByStatistics]}, @@ -988,11 +988,11 @@ public fun Grouped.min(skipNaN: Boolean = skipNaNDefault): DataFrame = * See [Selecting Columns][MinDocs.MinForSelectingOptions]. * * See also: - * - [min][Grouped.min]`()` — the same, but for all suitable columns at once. - * - [min][Grouped.min]` { columns }` — a single minimum of all values in the selected columns, + * - [`min`][Grouped.min]`()` — the same, but for all suitable columns at once. + * - [`min`][Grouped.min]` { columns }` — a single minimum of all values in the selected columns, * per group. - * - [maxFor][Grouped.maxFor] — the mirror operation. - * - [aggregate][Grouped.aggregate] — the general way to aggregate groups. + * - [`maxFor`][Grouped.maxFor] — the mirror operation. + * - [`aggregate`][Grouped.aggregate] — the general way to aggregate groups. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.GroupByStatistics]}, @@ -1032,11 +1032,11 @@ public fun ?> Grouped.minFor( * See [Selecting Columns][MinDocs.MinForSelectingOptions]. * * See also: - * - [min][Grouped.min]`()` — the same, but for all suitable columns at once. - * - [min][Grouped.min]` { columns }` — a single minimum of all values in the selected columns, + * - [`min`][Grouped.min]`()` — the same, but for all suitable columns at once. + * - [`min`][Grouped.min]` { columns }` — a single minimum of all values in the selected columns, * per group. - * - [maxFor][Grouped.maxFor] — the mirror operation. - * - [aggregate][Grouped.aggregate] — the general way to aggregate groups. + * - [`maxFor`][Grouped.maxFor] — the mirror operation. + * - [`aggregate`][Grouped.aggregate] — the general way to aggregate groups. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.GroupByStatistics]}, @@ -1087,11 +1087,11 @@ public fun ?> Grouped.minFor( * See [Selecting Columns][MinDocs.MinSelectingOptions]. * * See also: - * - [minFor][Grouped.minFor] — the minimum of each selected column separately, per group. - * - [minOf][Grouped.minOf] — the minimum of the values a row expression returns + * - [`minFor`][Grouped.minFor] — the minimum of each selected column separately, per group. + * - [`minOf`][Grouped.minOf] — the minimum of the values a row expression returns * for each row of a group. - * - [max][Grouped.max] — the mirror operation. - * - [aggregate][Grouped.aggregate] — the general way to aggregate groups. + * - [`max`][Grouped.max] — the mirror operation. + * - [`aggregate`][Grouped.aggregate] — the general way to aggregate groups. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.GroupByStatistics]}, @@ -1137,11 +1137,11 @@ public fun ?> Grouped.min( * See [Selecting Columns][MinDocs.MinSelectingOptions]. * * See also: - * - [minFor][Grouped.minFor] — the minimum of each selected column separately, per group. - * - [minOf][Grouped.minOf] — the minimum of the values a row expression returns + * - [`minFor`][Grouped.minFor] — the minimum of each selected column separately, per group. + * - [`minOf`][Grouped.minOf] — the minimum of the values a row expression returns * for each row of a group. - * - [max][Grouped.max] — the mirror operation. - * - [aggregate][Grouped.aggregate] — the general way to aggregate groups. + * - [`max`][Grouped.max] — the mirror operation. + * - [`aggregate`][Grouped.aggregate] — the general way to aggregate groups. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.GroupByStatistics]}, @@ -1196,13 +1196,13 @@ public fun ?> Grouped.min( * * {@include [MinDocs.NullCellOnEmptySnippet]} * - * Don't confuse [minOf] with [minBy][GroupBy.minBy], which returns the row of each group for which + * Don't confuse [minOf] with [`minBy`][GroupBy.minBy], which returns the row of each group for which * the expression returns the minimum value, instead of that value. * * See also: - * - [min][Grouped.min] — a single minimum of all values in the selected columns, per group. - * - [maxOf][Grouped.maxOf] — the mirror operation. - * - [aggregate][Grouped.aggregate] — the general way to aggregate groups. + * - [`min`][Grouped.min] — a single minimum of all values in the selected columns, per group. + * - [`maxOf`][Grouped.maxOf] — the mirror operation. + * - [`aggregate`][Grouped.aggregate] — the general way to aggregate groups. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.GroupByStatistics]}, @@ -1239,11 +1239,11 @@ public inline fun ?> Grouped.minOf( * * Groups that have no values to compare cannot select a row, and produce `null` values instead. * - * Don't confuse [minBy] with [minOf][Grouped.minOf], which returns the minimum value itself + * Don't confuse [minBy] with [`minOf`][Grouped.minOf], which returns the minimum value itself * instead of the row it belongs to. * * See also: - * - [maxBy][GroupBy.maxBy] — the mirror operation. + * - [`maxBy`][GroupBy.maxBy] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinBy]} @@ -1282,12 +1282,12 @@ public inline fun ?> GroupBy.minBy( * * Groups that have no values to compare cannot select a row, and produce `null` values instead. * - * Don't confuse [minBy] with [minOf][Grouped.minOf], which returns the minimum value a row + * Don't confuse [minBy] with [`minOf`][Grouped.minOf], which returns the minimum value a row * expression returns itself, instead of the row it belongs to. * * See also: - * - [min][Grouped.min] — the minimum value itself instead of the row it belongs to. - * - [maxBy][GroupBy.maxBy] — the mirror operation. + * - [`min`][Grouped.min] — the minimum value itself instead of the row it belongs to. + * - [`maxBy`][GroupBy.maxBy] — the mirror operation. * - {@include [MinDocsLink]} — an overview of all `min` modes. * * For more information: {@include [DocumentationUrls.MinBy]} @@ -1333,10 +1333,10 @@ public inline fun ?> GroupBy.minBy( * Check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [minFor][Pivot.minFor] — the same, but for an explicit selection of columns. - * - [min][Pivot.min]` { columns }` — a single minimum of all values in the selected columns, + * - [`minFor`][Pivot.minFor] — the same, but for an explicit selection of columns. + * - [`min`][Pivot.min]` { columns }` — a single minimum of all values in the selected columns, * per group. - * - [max][Pivot.max] — the mirror operation. + * - [`max`][Pivot.max] — the mirror operation. * - [Pivot aggregation][PivotDocs.Aggregation] — all other ways to aggregate a [Pivot]. * - {@include [MinDocsLink]} — an overview of all `min` modes. * @@ -1374,10 +1374,10 @@ public fun Pivot.min(separate: Boolean = false, skipNaN: Boolean = skipNa * See [Selecting Columns][MinDocs.MinForSelectingOptions], or check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [min][Pivot.min]`()` — the same, but for all suitable columns at once. - * - [min][Pivot.min]` { columns }` — a single minimum of all values in the selected columns, + * - [`min`][Pivot.min]`()` — the same, but for all suitable columns at once. + * - [`min`][Pivot.min]` { columns }` — a single minimum of all values in the selected columns, * per group. - * - [maxFor][Pivot.maxFor] — the mirror operation. + * - [`maxFor`][Pivot.maxFor] — the mirror operation. * - [Pivot aggregation][PivotDocs.Aggregation] — all other ways to aggregate a [Pivot]. * - {@include [MinDocsLink]} — an overview of all `min` modes. * @@ -1420,10 +1420,10 @@ public fun ?> Pivot.minFor( * See [Selecting Columns][MinDocs.MinForSelectingOptions], or check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [min][Pivot.min]`()` — the same, but for all suitable columns at once. - * - [min][Pivot.min]` { columns }` — a single minimum of all values in the selected columns, + * - [`min`][Pivot.min]`()` — the same, but for all suitable columns at once. + * - [`min`][Pivot.min]` { columns }` — a single minimum of all values in the selected columns, * per group. - * - [maxFor][Pivot.maxFor] — the mirror operation. + * - [`maxFor`][Pivot.maxFor] — the mirror operation. * - [Pivot aggregation][PivotDocs.Aggregation] — all other ways to aggregate a [Pivot]. * - {@include [MinDocsLink]} — an overview of all `min` modes. * @@ -1479,9 +1479,9 @@ public fun ?> Pivot.minFor( * See [Selecting Columns][MinDocs.MinSelectingOptions], or check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [min][Pivot.min]`()` — the minimum of each suitable column separately, per group. - * - [minFor][Pivot.minFor] — the minimum of each selected column separately, per group. - * - [max][Pivot.max] — the mirror operation. + * - [`min`][Pivot.min]`()` — the minimum of each suitable column separately, per group. + * - [`minFor`][Pivot.minFor] — the minimum of each selected column separately, per group. + * - [`max`][Pivot.max] — the mirror operation. * - [Pivot aggregation][PivotDocs.Aggregation] — all other ways to aggregate a [Pivot]. * - {@include [MinDocsLink]} — an overview of all `min` modes. * @@ -1520,9 +1520,9 @@ public fun ?> Pivot.min( * See [Selecting Columns][MinDocs.MinSelectingOptions], or check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [min][Pivot.min]`()` — the minimum of each suitable column separately, per group. - * - [minFor][Pivot.minFor] — the minimum of each selected column separately, per group. - * - [max][Pivot.max] — the mirror operation. + * - [`min`][Pivot.min]`()` — the minimum of each suitable column separately, per group. + * - [`minFor`][Pivot.minFor] — the minimum of each selected column separately, per group. + * - [`max`][Pivot.max] — the mirror operation. * - [Pivot aggregation][PivotDocs.Aggregation] — all other ways to aggregate a [Pivot]. * - {@include [MinDocsLink]} — an overview of all `min` modes. * @@ -1570,15 +1570,15 @@ public fun ?> Pivot.min( * * {@include [MinDocs.NullCellOnEmptySnippet]} * - * Don't confuse [minOf] with [minBy][Pivot.minBy], which returns the first row of each group for + * Don't confuse [minOf] with [`minBy`][Pivot.minBy], which returns the first row of each group for * which the expression returns the minimum value, instead of that value. * * Check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [min][Pivot.min]` { columns }` — a single minimum of all values in the selected columns, + * - [`min`][Pivot.min]` { columns }` — a single minimum of all values in the selected columns, * per group. - * - [maxOf][Pivot.maxOf] — the mirror operation. + * - [`maxOf`][Pivot.maxOf] — the mirror operation. * - [Pivot aggregation][PivotDocs.Aggregation] — all other ways to aggregate a [Pivot]. * - {@include [MinDocsLink]} — an overview of all `min` modes. * @@ -1612,13 +1612,13 @@ public inline fun ?> Pivot.minOf( * * {@include [MinDocs.ReducedPivotSnippet]} * - * Don't confuse [minBy] with [minOf][Pivot.minOf], which returns the minimum value the expression + * Don't confuse [minBy] with [`minOf`][Pivot.minOf], which returns the minimum value the expression * returns itself, instead of the row. * * Check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [maxBy][Pivot.maxBy] — the mirror operation. + * - [`maxBy`][Pivot.maxBy] — the mirror operation. * - [Pivot reducing][PivotDocs.Reducing] — all other ways to reduce a [Pivot]. * - {@include [MinDocsLink]} — an overview of all `min` modes. * @@ -1657,14 +1657,14 @@ public inline fun ?> Pivot.minBy( * * {@include [MinDocs.ReducedPivotSnippet]} * - * Don't confuse [minBy] with [minOf][Pivot.minOf], which returns the minimum value a row expression + * Don't confuse [minBy] with [`minOf`][Pivot.minOf], which returns the minimum value a row expression * returns itself, instead of the row. * * Check out the [`Pivot` Grammar][PivotDocs.Grammar]. * * See also: - * - [min][Pivot.min]` { columns }` — the minimum value itself, instead of the row. - * - [maxBy][Pivot.maxBy] — the mirror operation. + * - [`min`][Pivot.min]` { columns }` — the minimum value itself, instead of the row. + * - [`maxBy`][Pivot.maxBy] — the mirror operation. * - [Pivot reducing][PivotDocs.Reducing] — all other ways to reduce a [Pivot]. * - {@include [MinDocsLink]} — an overview of all `min` modes. * @@ -1711,10 +1711,10 @@ public inline fun ?> Pivot.minBy( * Check out the [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [minFor][PivotGroupBy.minFor] — the same, but for an explicit selection of columns. - * - [min][PivotGroupBy.min]` { columns }` — a single minimum of all values in the selected columns, + * - [`minFor`][PivotGroupBy.minFor] — the same, but for an explicit selection of columns. + * - [`min`][PivotGroupBy.min]` { columns }` — a single minimum of all values in the selected columns, * per group. - * - [max][PivotGroupBy.max] — the mirror operation. + * - [`max`][PivotGroupBy.max] — the mirror operation. * - [PivotGroupBy aggregation][PivotGroupByDocs.Aggregation] — all other ways to aggregate * a [PivotGroupBy]. * - {@include [MinDocsLink]} — an overview of all `min` modes. @@ -1754,10 +1754,10 @@ public fun PivotGroupBy.min(separate: Boolean = false, skipNaN: Boolean = * [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [min][PivotGroupBy.min]`()` — the same, but for all suitable columns at once. - * - [min][PivotGroupBy.min]` { columns }` — a single minimum of all values in the selected columns, + * - [`min`][PivotGroupBy.min]`()` — the same, but for all suitable columns at once. + * - [`min`][PivotGroupBy.min]` { columns }` — a single minimum of all values in the selected columns, * per group. - * - [maxFor][PivotGroupBy.maxFor] — the mirror operation. + * - [`maxFor`][PivotGroupBy.maxFor] — the mirror operation. * - [PivotGroupBy aggregation][PivotGroupByDocs.Aggregation] — all other ways to aggregate * a [PivotGroupBy]. * - {@include [MinDocsLink]} — an overview of all `min` modes. @@ -1800,10 +1800,10 @@ public fun ?> PivotGroupBy.minFor( * [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [min][PivotGroupBy.min]`()` — the same, but for all suitable columns at once. - * - [min][PivotGroupBy.min]` { columns }` — a single minimum of all values in the selected columns, + * - [`min`][PivotGroupBy.min]`()` — the same, but for all suitable columns at once. + * - [`min`][PivotGroupBy.min]` { columns }` — a single minimum of all values in the selected columns, * per group. - * - [maxFor][PivotGroupBy.maxFor] — the mirror operation. + * - [`maxFor`][PivotGroupBy.maxFor] — the mirror operation. * - [PivotGroupBy aggregation][PivotGroupByDocs.Aggregation] — all other ways to aggregate * a [PivotGroupBy]. * - {@include [MinDocsLink]} — an overview of all `min` modes. @@ -1862,9 +1862,9 @@ public fun ?> PivotGroupBy.minFor( * [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [min][PivotGroupBy.min]`()` — the minimum of each suitable column separately, per group. - * - [minFor][PivotGroupBy.minFor] — the minimum of each selected column separately, per group. - * - [max][PivotGroupBy.max] — the mirror operation. + * - [`min`][PivotGroupBy.min]`()` — the minimum of each suitable column separately, per group. + * - [`minFor`][PivotGroupBy.minFor] — the minimum of each selected column separately, per group. + * - [`max`][PivotGroupBy.max] — the mirror operation. * - [PivotGroupBy aggregation][PivotGroupByDocs.Aggregation] — all other ways to aggregate * a [PivotGroupBy]. * - {@include [MinDocsLink]} — an overview of all `min` modes. @@ -1906,9 +1906,9 @@ public fun ?> PivotGroupBy.min( * [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [min][PivotGroupBy.min]`()` — the minimum of each suitable column separately, per group. - * - [minFor][PivotGroupBy.minFor] — the minimum of each selected column separately, per group. - * - [max][PivotGroupBy.max] — the mirror operation. + * - [`min`][PivotGroupBy.min]`()` — the minimum of each suitable column separately, per group. + * - [`minFor`][PivotGroupBy.minFor] — the minimum of each selected column separately, per group. + * - [`max`][PivotGroupBy.max] — the mirror operation. * - [PivotGroupBy aggregation][PivotGroupByDocs.Aggregation] — all other ways to aggregate * a [PivotGroupBy]. * - {@include [MinDocsLink]} — an overview of all `min` modes. @@ -1957,15 +1957,15 @@ public fun ?> PivotGroupBy.min( * * {@include [MinDocs.NullCellOnEmptySnippet]} * - * Don't confuse [minOf] with [minBy][PivotGroupBy.minBy], which returns the first row of each group + * Don't confuse [minOf] with [`minBy`][PivotGroupBy.minBy], which returns the first row of each group * for which the expression returns the minimum value, instead of that value. * * Check out the [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [min][PivotGroupBy.min]` { columns }` — a single minimum of all values in the selected columns, + * - [`min`][PivotGroupBy.min]` { columns }` — a single minimum of all values in the selected columns, * per group. - * - [maxOf][PivotGroupBy.maxOf] — the mirror operation. + * - [`maxOf`][PivotGroupBy.maxOf] — the mirror operation. * - [PivotGroupBy aggregation][PivotGroupByDocs.Aggregation] — all other ways to aggregate * a [PivotGroupBy]. * - {@include [MinDocsLink]} — an overview of all `min` modes. @@ -2000,13 +2000,13 @@ public inline fun ?> PivotGroupBy.minOf( * * {@include [MinDocs.ReducedPivotGroupBySnippet]} * - * Don't confuse [minBy] with [minOf][PivotGroupBy.minOf], which returns the minimum value the + * Don't confuse [minBy] with [`minOf`][PivotGroupBy.minOf], which returns the minimum value the * expression returns itself, instead of the row. * * Check out the [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [maxBy][PivotGroupBy.maxBy] — the mirror operation. + * - [`maxBy`][PivotGroupBy.maxBy] — the mirror operation. * - [PivotGroupBy reducing][PivotGroupByDocs.Reducing] — all other ways to reduce * a [PivotGroupBy]. * - {@include [MinDocsLink]} — an overview of all `min` modes. @@ -2046,14 +2046,14 @@ public inline fun ?> PivotGroupBy.minBy( * * {@include [MinDocs.ReducedPivotGroupBySnippet]} * - * Don't confuse [minBy] with [minOf][PivotGroupBy.minOf], which returns the minimum value a row + * Don't confuse [minBy] with [`minOf`][PivotGroupBy.minOf], which returns the minimum value a row * expression returns itself, instead of the row. * * Check out the [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * * See also: - * - [min][PivotGroupBy.min]` { columns }` — the minimum value itself, instead of the row. - * - [maxBy][PivotGroupBy.maxBy] — the mirror operation. + * - [`min`][PivotGroupBy.min]` { columns }` — the minimum value itself, instead of the row. + * - [`maxBy`][PivotGroupBy.maxBy] — the mirror operation. * - [PivotGroupBy reducing][PivotGroupByDocs.Reducing] — all other ways to reduce * a [PivotGroupBy]. * - {@include [MinDocsLink]} — an overview of all `min` modes. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt index cb437abc79..4a2294dd81 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/move.kt @@ -44,9 +44,9 @@ import kotlin.reflect.KProperty * This function does not immediately move the columns but instead select columns to move and * returns a [MoveClause], * which serves as an intermediate step. The [MoveClause] allows specifying the final - * destination of the selected columns using methods such as [to][MoveClause.to], [toStart][MoveClause.toStart], - * [toEnd][MoveClause.toEnd], [into][MoveClause.into], [intoIndexed][MoveClause.intoIndexed], [toTop][MoveClause.toTop], - * [after][MoveClause.after] or [under][MoveClause.under], that return a new [DataFrame] with updated columns structure. + * destination of the selected columns using methods such as [`to`][MoveClause.to], [`toStart`][MoveClause.toStart], + * [`toEnd`][MoveClause.toEnd], [`into`][MoveClause.into], [`intoIndexed`][MoveClause.intoIndexed], [`toTop`][MoveClause.toTop], + * [`after`][MoveClause.after] or [`under`][MoveClause.under], that return a new [DataFrame] with updated columns structure. * * Check out [Grammar]. * @@ -99,7 +99,7 @@ internal interface Move { typealias Grammar = Nothing } -/** {@set [SelectingColumns.OPERATION] [move][move]} */ +/** {@set [SelectingColumns.OPERATION] [`move`][move]} */ @ExcludeFromSources private typealias SetMoveOperationArg = Nothing @@ -169,7 +169,7 @@ internal interface MoveTo { typealias MoveToSelectingOptions = Nothing } -/** {@set [SelectingColumns.OPERATION] [moveTo][moveTo]} */ +/** {@set [SelectingColumns.OPERATION] [`moveTo`][moveTo]} */ @ExcludeFromSources private typealias SetMoveToOperationArg = Nothing @@ -271,7 +271,7 @@ internal interface MoveToStart { typealias MoveToStartSelectingOptions = Nothing } -/** {@set [SelectingColumns.OPERATION] [moveToStart][moveToStart]} */ +/** {@set [SelectingColumns.OPERATION] [`moveToStart`][moveToStart]} */ @ExcludeFromSources private typealias SetMoveToStartOperationArg = Nothing @@ -358,7 +358,7 @@ internal interface MoveToEnd { typealias MoveToEndSelectingOptions = Nothing } -/** {@set [SelectingColumns.OPERATION] [moveToEnd][moveToEnd]} */ +/** {@set [SelectingColumns.OPERATION] [`moveToEnd`][moveToEnd]} */ @ExcludeFromSources private typealias SetMoveToEndOperationArg = Nothing diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/none.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/none.kt index 51b958b6ee..f55bf7e96f 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/none.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/none.kt @@ -72,13 +72,13 @@ public interface NoneColumnsSelectionDsl { * * Creates an empty [ColumnsResolver] / [ColumnSet], essentially selecting no columns at all. * - * This is the opposite of [all][ColumnsSelectionDsl.all]. + * This is the opposite of [`all`][ColumnsSelectionDsl.all]. * * ### Check out: [Grammar] * * #### For example: * - * `df.`[groupBy][DataFrame.groupBy]` { `[`none`][none]`() }` + * `df.`[`groupBy`][DataFrame.groupBy]` { `[`none`][none]`() }` * * @return An empty [ColumnsResolver]. */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt index 302fe163b9..2a3cdebd50 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt @@ -64,7 +64,7 @@ import kotlin.reflect.KProperty internal interface PivotDocs { /** - * ## [pivot][pivot] Operation Grammar + * ## [`pivot`][pivot] Operation Grammar * {@include [LineBreak]} * {@include [DslGrammarLink]} * {@include [LineBreak]} @@ -75,7 +75,7 @@ internal interface PivotDocs { * * ### Reduce [Pivot] into [DataRow] * - * [Pivot][Pivot]`.`[**`minBy`**][Pivot.minBy]**` { `**`rowExpression: `[`RowExpression`][RowExpression]**` }`** + * [`Pivot`][Pivot]`.`[**`minBy`**][Pivot.minBy]**` { `**`rowExpression: `[`RowExpression`][RowExpression]**` }`** * * {@include [Indent]} * `| `__`.`__[**`maxBy`**][Pivot.maxBy]**` { `**`rowExpression: `[`RowExpression`][RowExpression]**` }`** @@ -100,7 +100,7 @@ internal interface PivotDocs { * * ### Aggregate [Pivot] into [DataRow] * - * [Pivot][Pivot]`.`[**`count`**][Pivot.count]**`()`** + * [`Pivot`][Pivot]`.`[**`count`**][Pivot.count]**`()`** * * {@include [Indent]} * `| `__`.`__[**`frames`**][Pivot.frames]**`()`** @@ -119,7 +119,7 @@ internal interface PivotDocs { * * ### Group [Pivot] into [PivotGroupBy] and reduce / aggregate it * - * [Pivot][Pivot]`.`[**`groupBy`**][Pivot.groupBy]**` { `**`columns: `[`ColumnsSelector`][ColumnsSelector]**` }`** + * [`Pivot`][Pivot]`.`[**`groupBy`**][Pivot.groupBy]**` { `**`columns: `[`ColumnsSelector`][ColumnsSelector]**` }`** * * {@include [Indent]} * `| `__`.`__[**`groupByOther`**][Pivot.groupByOther]**`()`** @@ -147,20 +147,20 @@ internal interface PivotDocs { * Reducing is a specific case of [aggregation][Aggregation]. * * First, choose a [Pivot] reducing method: - * * [first][Pivot.first], [last][Pivot.last] — take the first or last row + * * [`first`][Pivot.first], [`last`][Pivot.last] — take the first or last row * (optionally, the first or last one that satisfies a predicate) of each group; - * * [minBy][Pivot.minBy] / [maxBy][Pivot.maxBy] — take the row with the minimum or maximum value + * * [`minBy`][Pivot.minBy] / [`maxBy`][Pivot.maxBy] — take the row with the minimum or maximum value * of the given [RowExpression] evaluated on rows within each group; - * * [medianBy][Pivot.medianBy] / [percentileBy][Pivot.percentileBy] — take the row at the position closest + * * [`medianBy`][Pivot.medianBy] / [`percentileBy`][Pivot.percentileBy] — take the row at the position closest * to the estimated median/percentile index of the [RowExpression]'s results calculated on rows within each group. * * These functions return a [ReducedPivot], which can then be transformed into a new [DataFrame] * containing a single combined row (either using the original reduced rows or their transformed versions) * through one of the following methods: - * * [values][ReducedPivot.values] — creates a new row containing the values + * * [`values`][ReducedPivot.values] — creates a new row containing the values * from the reduced rows in the selected columns and produces a [DataRow] of * these values; - * * [with][ReducedPivot.with] — computes a new value for each reduced row using a [RowExpression], + * * [`with`][ReducedPivot.with] — computes a new value for each reduced row using a [RowExpression], * and produces a [DataRow] containing these computed values. * * Each method returns a new [DataRow] with [pivot] keys as top-level columns @@ -180,22 +180,22 @@ internal interface PivotDocs { * with [pivot] keys as top-level columns or as [column groups][ColumnGroup]. * * The following aggregation methods are available: - * * [frames][Pivot.frames] — returns this [Pivot] as a [DataRow] with pivot keys as columns + * * [`frames`][Pivot.frames] — returns this [Pivot] as a [DataRow] with pivot keys as columns * (or [column groups][ColumnGroup]) and corresponding groups stored as [FrameColumn]s; - * * [values][Pivot.values] — creates a [DataRow] containing values collected into a single [List] + * * [`values`][Pivot.values] — creates a [DataRow] containing values collected into a single [List] * from all rows of each group for the selected columns * (values from [column groups][ColumnGroup] are collected into a [DataFrame]); - * * [count][Pivot.count] — creates a [DataRow] containing the pivot key columns and an additional column + * * [`count`][Pivot.count] — creates a [DataRow] containing the pivot key columns and an additional column * with the number of rows in each corresponding group; - * * [with][Pivot.with] — creates a [DataRow] containing values computed using a [RowExpression] + * * [`with`][Pivot.with] — creates a [DataRow] containing values computed using a [RowExpression] * across all rows of each group. * Values of the [DataRow] type are collected into a [DataFrame], and the resulting column is a [FrameColumn]. * Values of other types are collected into a [List], and the resulting column is a [DataColumn] of [List]; - * * [aggregate][Pivot.aggregate] — performs a set of custom aggregations using [AggregateDsl], + * * [`aggregate`][Pivot.aggregate] — performs a set of custom aggregations using [AggregateDsl], * allowing computation of one or more derived values per group; * * [Various aggregation statistics][AggregationStatistics] — predefined shortcuts - * for common statistical aggregations such as [sum][Pivot.sum], [mean][Pivot.mean], - * [median][Pivot.median], and others. + * for common statistical aggregations such as [`sum`][Pivot.sum], [`mean`][Pivot.mean], + * [`median`][Pivot.median], and others. * * Each of these methods returns a new [DataRow] with [pivot] keys as top-level columns * (or as [column groups][ColumnGroup]) and values representing the aggregated results of each group. @@ -209,7 +209,7 @@ internal interface PivotDocs { /** * ### [Pivot] grouping * - * [Pivot] can be grouped with [groupBy][Pivot.groupBy] method. It will produce a [PivotGroupBy]. + * [Pivot] can be grouped with [`groupBy`][Pivot.groupBy] method. It will produce a [PivotGroupBy]. * * @include [PivotGroupByDocs.CommonDescription] */ @@ -224,27 +224,27 @@ internal interface PivotDocs { * Each function computes a statistic across the rows of a group and returns the result as * a new row of computed values in the resulting [DataFrame]. * - * * [count][Pivot.count] — calculate the number of rows in each group + * * [`count`][Pivot.count] — calculate the number of rows in each group * (optionally counting only rows that satisfy the given predicate); - * * [max][Pivot.max] / [maxOf][Pivot.maxOf] / [maxFor][Pivot.maxFor] — + * * [`max`][Pivot.max] / [`maxOf`][Pivot.maxOf] / [`maxFor`][Pivot.maxFor] — * calculate the maximum of all values on the selected columns / by a row expression / * for each of the selected columns within each group; - * * [min][Pivot.min] / [minOf][Pivot.minOf] / [minFor][Pivot.minFor] — + * * [`min`][Pivot.min] / [`minOf`][Pivot.minOf] / [`minFor`][Pivot.minFor] — * calculate the minimum of all values on the selected columns / by a row expression / * for each of the selected columns within each group; - * * [sum][Pivot.sum] / [sumOf][Pivot.sumOf] / [sumFor][Pivot.sumFor] — + * * [`sum`][Pivot.sum] / [`sumOf`][Pivot.sumOf] / [`sumFor`][Pivot.sumFor] — * calculate the sum of all values on the selected columns / by a row expression / * for each of the selected columns within each group; - * * [mean][Pivot.mean] / [meanOf][Pivot.meanOf] / [meanFor][Pivot.meanFor] — + * * [`mean`][Pivot.mean] / [`meanOf`][Pivot.meanOf] / [`meanFor`][Pivot.meanFor] — * calculate the mean (average) of all values on the selected columns / by a row expression / * for each of the selected columns within each group; - * * [std][Pivot.std] / [stdOf][Pivot.stdOf] / [stdFor][Pivot.stdFor] — + * * [`std`][Pivot.std] / [`stdOf`][Pivot.stdOf] / [`stdFor`][Pivot.stdFor] — * calculate the standard deviation of all values on the selected columns / by a row expression / * for each of the selected columns within each group; - * * [median][Pivot.median] / [medianOf][Pivot.medianOf] / [medianFor][Pivot.medianFor] — + * * [`median`][Pivot.median] / [`medianOf`][Pivot.medianOf] / [`medianFor`][Pivot.medianFor] — * calculate the median of all values on the selected columns / by a row expression / * for each of the selected columns within each group; - * * [percentile][Pivot.percentile] / [percentileOf][Pivot.percentileOf] / [percentileFor][Pivot.percentileFor] — + * * [`percentile`][Pivot.percentile] / [`percentileOf`][Pivot.percentileOf] / [`percentileFor`][Pivot.percentileFor] — * calculate a specified percentile of all values on the selected columns / by a row expression / * for each of the selected columns within each group. * @@ -286,7 +286,7 @@ internal interface PivotDocs { typealias InwardKDocsForGrouped = Nothing } -/** {@set [SelectingColumns.OPERATION] [pivot][pivot]} */ +/** {@set [SelectingColumns.OPERATION] [`pivot`][pivot]} */ @ExcludeFromSources private typealias SetPivotOperationArg = Nothing @@ -470,8 +470,8 @@ internal typealias PivotMatchesResultCellDescription = Nothing * @include [PivotGroupByDocs.ResultingMatrixShortcutDescription] {@set [PivotGroupByDocs.GroupingColumns] remaining} * @include [PivotMatchesResultCellDescription] * - * This function combines [pivot][DataFrame.pivot], [groupByOther][Pivot.groupByOther], - * and [matches][PivotGroupBy.matches] operations into a single call. + * This function combines [`pivot`][DataFrame.pivot], [`groupByOther`][Pivot.groupByOther], + * and [`matches`][PivotGroupBy.matches] operations into a single call. * * @include [SelectingColumns.ColumnGroupsAndNestedColumnsSnippet] * @@ -564,8 +564,8 @@ internal typealias PivotCountsResultCellDescription = Nothing * @include [PivotGroupByDocs.ResultingMatrixShortcutDescription] {@set [PivotGroupByDocs.GroupingColumns] remaining} * @include [PivotCountsResultCellDescription] * - * This function combines [pivot][DataFrame.pivot], [groupByOther][Pivot.groupByOther], - * and [count][PivotGroupBy.count] operations into a single call. + * This function combines [`pivot`][DataFrame.pivot], [`groupByOther`][Pivot.groupByOther], + * and [`count`][PivotGroupBy.count] operations into a single call. * * @include [SelectingColumns.ColumnGroupsAndNestedColumnsSnippet] * @@ -703,8 +703,8 @@ public fun GroupBy<*, G>.pivot(vararg columns: KProperty<*>, inward: Boolean * @include [PivotGroupByDocs.ResultingMatrixShortcutDescription] * @include [PivotMatchesResultCellDescription] * - * This function combines [pivot][GroupBy.pivot] - * and [matches][PivotGroupBy.matches] operations into a single call. + * This function combines [`pivot`][GroupBy.pivot] + * and [`matches`][PivotGroupBy.matches] operations into a single call. * * @include [SelectingColumns.ColumnGroupsAndNestedColumnsSnippet] * @@ -712,7 +712,7 @@ public fun GroupBy<*, G>.pivot(vararg columns: KProperty<*>, inward: Boolean * * For more information: {@include [DocumentationUrls.PivotMatches]} * - * See also: [pivotCounts][GroupBy.pivotCounts], which performs a similar operation + * See also: [`pivotCounts`][GroupBy.pivotCounts], which performs a similar operation * but counts the number of matching rows instead of checking for their presence. * * ### This `pivotMatches` Overload @@ -779,8 +779,8 @@ public fun GroupBy<*, G>.pivotMatches(vararg columns: KProperty<*>, inward: * @include [PivotGroupByDocs.ResultingMatrixShortcutDescription] * @include [PivotCountsResultCellDescription] * - * This function combines [pivot][GroupBy.pivot] - * and [count][PivotGroupBy.count] operations into a single call. + * This function combines [`pivot`][GroupBy.pivot] + * and [`count`][PivotGroupBy.count] operations into a single call. * * @include [SelectingColumns.ColumnGroupsAndNestedColumnsSnippet] * @@ -788,7 +788,7 @@ public fun GroupBy<*, G>.pivotMatches(vararg columns: KProperty<*>, inward: * * For more information: {@include [DocumentationUrls.PivotCounts]} * - * See also: [pivotMatches][GroupBy.pivotMatches], which performs a similar operation + * See also: [`pivotMatches`][GroupBy.pivotMatches], which performs a similar operation * but check if there is any matching row instead of counting then. * * ### This `pivotCounts` Overload @@ -857,10 +857,10 @@ public fun GroupBy<*, G>.pivotCounts(vararg columns: KProperty<*>, inward: B * Pivots the selected [\columns] within each group for further * [pivot aggregations][PivotGroupByDocs.Aggregation]. * - * This function itself does not directly modify the result of [aggregate][Grouped.aggregate], + * This function itself does not directly modify the result of [`aggregate`][Grouped.aggregate], * but instead creates an intermediate [PivotGroupBy]. * The resulting [DataFrame] columns produced by its [aggregations][PivotGroupByDocs.Aggregation] are then - * inserted into the final [DataFrame] returned by [aggregate][Grouped.aggregate] + * inserted into the final [DataFrame] returned by [`aggregate`][Grouped.aggregate] * when those aggregation functions are executed (as usual aggregations). * Their structure depends on the specific * [PivotGroupBy aggregations][PivotGroupByDocs.Aggregation] used. @@ -871,8 +871,8 @@ public fun GroupBy<*, G>.pivotCounts(vararg columns: KProperty<*>, inward: B * * Check out [`PivotGroupBy` Grammar][PivotGroupByDocs.Grammar]. * - * See also [pivotMatches][AggregateGroupedDsl.pivotMatches] - * and [pivotCounts][AggregateGroupedDsl.pivotCounts] shortcuts. + * See also [`pivotMatches`][AggregateGroupedDsl.pivotMatches] + * and [`pivotCounts`][AggregateGroupedDsl.pivotCounts] shortcuts. * * ### This `pivot` overload */ @@ -971,21 +971,21 @@ public fun AggregateGroupedDsl.pivot(vararg columns: KProperty<*>, inward // region pivotMatches /** - * Computes the [pivotMatches][DataFrame.pivotMatches] statistic for the selected [\columns] - * within each group and adds it to the [aggregate][Grouped.aggregate] result. + * Computes the [`pivotMatches`][DataFrame.pivotMatches] statistic for the selected [\columns] + * within each group and adds it to the [`aggregate`][Grouped.aggregate] result. * - * This is a shortcut for combining [pivot][AggregateGroupedDsl.pivot] - * and [matches][PivotGroupBy.matches]. + * This is a shortcut for combining [`pivot`][AggregateGroupedDsl.pivot] + * and [`matches`][PivotGroupBy.matches]. * * The resulting [DataFrame] columns are inserted into the final [DataFrame] - * returned by [aggregate][Grouped.aggregate]. + * returned by [`aggregate`][Grouped.aggregate]. * The resulting column name can be specified using [into]. * * See [GroupBy.pivotMatches] for more details. * * For more information: {@include [DocumentationUrls.PivotMatches]} * - * See also: [pivot][AggregateGroupedDsl.pivot], [pivotCounts][AggregateGroupedDsl.pivotCounts]. + * See also: [`pivot`][AggregateGroupedDsl.pivot], [`pivotCounts`][AggregateGroupedDsl.pivotCounts]. * * ### This `pivotMatches` overload */ @@ -1011,7 +1011,7 @@ internal typealias AggregateGroupedDslPivotMatchesDocs = Nothing * as keys for pivoting and in which order. * @return A new [DataFrame] representing a Boolean presence matrix — with grouping key columns as rows, * pivot key values as columns, and `true`/`false` cells indicating existing combinations. - * This [DataFrame] is added to the [aggregate][Grouped.aggregate] result. + * This [DataFrame] is added to the [`aggregate`][Grouped.aggregate] result. */ public fun AggregateGroupedDsl.pivotMatches( inward: Boolean = true, @@ -1035,7 +1035,7 @@ public fun AggregateGroupedDsl.pivotMatches( * as keys for pivoting and in which order. * @return A new [DataFrame] representing a Boolean presence matrix — with grouping key columns as rows, * pivot key values as columns, and `true`/`false` cells indicating existing combinations. - * This [DataFrame] is added to the [aggregate][Grouped.aggregate] result. + * This [DataFrame] is added to the [`aggregate`][Grouped.aggregate] result. */ public fun AggregateGroupedDsl.pivotMatches(vararg columns: String, inward: Boolean = true): DataFrame = pivotMatches(inward) { columns.toColumnSet() } @@ -1057,21 +1057,21 @@ public fun AggregateGroupedDsl.pivotMatches(vararg columns: KProperty<*>, // region pivotCounts /** - * Computes the [pivotCounts][DataFrame.pivotCounts] statistic for the selected [\columns] - * within each group and adds it to the [aggregate][Grouped.aggregate] result. + * Computes the [`pivotCounts`][DataFrame.pivotCounts] statistic for the selected [\columns] + * within each group and adds it to the [`aggregate`][Grouped.aggregate] result. * - * This is a shortcut for combining [pivot][AggregateGroupedDsl.pivot] - * and [count][PivotGroupBy.count]. + * This is a shortcut for combining [`pivot`][AggregateGroupedDsl.pivot] + * and [`count`][PivotGroupBy.count]. * * The resulting [DataFrame] columns are inserted into the final [DataFrame] - * returned by [aggregate][Grouped.aggregate]. + * returned by [`aggregate`][Grouped.aggregate]. * The resulting column name can be specified using [into]. * * See [GroupBy.pivotCounts] for more details. * * For more information: {@include [DocumentationUrls.PivotCounts]} * - * See also: [pivot][AggregateGroupedDsl.pivot], [pivotMatches][AggregateGroupedDsl.pivotMatches]. + * See also: [`pivot`][AggregateGroupedDsl.pivot], [`pivotMatches`][AggregateGroupedDsl.pivotMatches]. * * ### This `pivotCounts` overload */ @@ -1097,7 +1097,7 @@ internal typealias AggregateGroupedDslPivotCountsDocs = Nothing * as keys for pivoting and in which order. * @return A new [DataFrame] representing a counting matrix — with grouping key columns as rows, * pivot key values as columns, and the number of rows with the corresponding combinations in the cells. - * This [DataFrame] is added to the [aggregate][Grouped.aggregate] result. + * This [DataFrame] is added to the [`aggregate`][Grouped.aggregate] result. */ public fun AggregateGroupedDsl.pivotCounts( inward: Boolean = true, @@ -1121,7 +1121,7 @@ public fun AggregateGroupedDsl.pivotCounts( * as keys for pivoting and in which order. * @return A new [DataFrame] representing a counting matrix — with grouping key columns as rows, * pivot key values as columns, and the number of rows with the corresponding combinations in the cells. - * This [DataFrame] is added to the [aggregate][Grouped.aggregate] result. + * This [DataFrame] is added to the [`aggregate`][Grouped.aggregate] result. */ public fun AggregateGroupedDsl.pivotCounts(vararg columns: String, inward: Boolean = true): DataFrame = pivotCounts(inward) { columns.toColumnSet() } @@ -1167,7 +1167,7 @@ public interface Pivot : Aggregatable * Provides [PivotDsl] both as the receiver and the lambda parameter, and expects * a [ColumnsResolver] as the return value. * - * Enables defining the hierarchy of pivot columns using [then][PivotDsl.then]. + * Enables defining the hierarchy of pivot columns using [`then`][PivotDsl.then]. */ public typealias PivotColumnsSelector = Selector, ColumnsResolver> @@ -1179,10 +1179,10 @@ public typealias PivotColumnsSelector = Selector, ColumnsResol * in a resulting [DataRow]. * * Available transformation methods: - * * [values][ReducedPivot.values] — creates a new row containing the values + * * [`values`][ReducedPivot.values] — creates a new row containing the values * from the reduced rows in the selected columns and produces a [DataRow] of * these values; - * * [with][ReducedPivot.with] — computes a new value for each reduced row using a [RowExpression], + * * [`with`][ReducedPivot.with] — computes a new value for each reduced row using a [RowExpression], * and produces a [DataRow] containing these computed values. * * Each method returns a new [DataRow] with [pivot] keys as top-level columns @@ -1217,12 +1217,12 @@ internal interface PivotGroupByDocs { /** * * **Columns** represent all unique values from the selected [\columns] * (they become [column groups][ColumnGroup] - * corresponding to value combinations when using [then][PivotDsl.then], + * corresponding to value combinations when using [`then`][PivotDsl.then], * similar to [pivot]); * * **Rows** correspond to all unique combinations of values from the {@get [GroupingColumns] grouping} columns; * each combination is represented in dedicated key columns that store * a distinct set of values for each row - * (similar to [keys][GroupBy.keys] in [GroupBy]). + * (similar to [`keys`][GroupBy.keys] in [GroupBy]). */ typealias ResultingMatrixShortcutDescription = Nothing diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt index bd0b6b73cd..0e90769ed1 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/remove.kt @@ -34,7 +34,7 @@ import kotlin.reflect.KProperty */ internal typealias Remove = Nothing -/** {@set [SelectingColumns.OPERATION] [remove][remove]} */ +/** {@set [SelectingColumns.OPERATION] [`remove`][remove]} */ @ExcludeFromSources private typealias SetRemoveOperationArg = Nothing diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt index d42022f3fb..02de412e21 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt @@ -42,7 +42,7 @@ import kotlin.reflect.KProperty * - [to(name)][RenameClause.to] - renames selected columns to the specified names. * - [to { nameExpression }][RenameClause.to] - renames selected columns using a provided * expression assuming column with its path and returning a new name. - * - [toCamelCase()][RenameClause.toCamelCase] - renames all selected columns to "camelCase". + * - [`toCamelCase()`][RenameClause.toCamelCase] - renames all selected columns to "camelCase". * * Each method returns a new [DataFrame] with the renamed columns. * @@ -84,7 +84,7 @@ internal interface RenameDocs { typealias Grammar = Nothing } -/** {@set [SelectingColumns.OPERATION] [rename][rename]} */ +/** {@set [SelectingColumns.OPERATION] [`rename`][rename]} */ @ExcludeFromSources private typealias SetRenameOperationArg = Nothing @@ -176,7 +176,7 @@ public fun DataFrame.rename(vararg cols: String): RenameClause = * - [to(name)][RenameClause.to] — renames selected columns to the specified names. * - [to { nameExpression }][RenameClause.to] — renames selected columns using a custom expression, * which takes the column and its path and returns a new name. - * - [toCamelCase()][RenameClause.toCamelCase] — renames all selected columns to `camelCase`. + * - [`toCamelCase()`][RenameClause.toCamelCase] — renames all selected columns to `camelCase`. * * See [Grammar][RenameDocs.Grammar] for more details. */ @@ -230,7 +230,7 @@ public fun RenameClause.into(vararg newColumns: ColumnReference<*>) to(*newColumns.map { it.name() }.toTypedArray()) /** - * __NOTE:__ While you can keep using 'into', we recommend using [to][RenameClause.to] for + * __NOTE:__ While you can keep using 'into', we recommend using [`to`][RenameClause.to] for * better readability and more natural English. * * Renames the columns selected with [rename] to the specified [newNames], @@ -295,7 +295,7 @@ public fun RenameClause.into(vararg newNames: KProperty<*>): DataFr to(*newNames.map { it.name }.toTypedArray()) /** - * __NOTE:__ While you can keep using 'into', we recommend using [to][RenameClause.to] for + * __NOTE:__ While you can keep using 'into', we recommend using [`to`][RenameClause.to] for * better readability and more natural English. * * Renames the columns selected with [rename] by applying the [transform] expression @@ -507,7 +507,7 @@ public interface RenameColumnsSelectionDsl { /** * ## Rename: `named` / `into` * Renaming a column in the [ColumnsSelectionDsl] is done by calling the `infix` functions - * [named][ColumnReference.named] or [into][ColumnReference.into]. They behave exactly the same, + * [`named`][ColumnReference.named] or [`into`][ColumnReference.into]. They behave exactly the same, * so it's up to contextual preference which one to use. Any combination of {@include [AccessApiLink]} can be * used to specify the column to rename and which name should be used instead. * @@ -515,15 +515,15 @@ public interface RenameColumnsSelectionDsl { * * #### For Example: * - * `df.`[select][DataFrame.select]` { name `[named][ColumnReference.named]` "Full Name" }` + * `df.`[`select`][DataFrame.select]` { name `[`named`][ColumnReference.named]` "Full Name" }` * - * `df.`[select][DataFrame.select]` { `[expr][expr]` { 0 } `[into][ColumnReference.into]` "zeroes" }` + * `df.`[`select`][DataFrame.select]` { `[`expr`][expr]` { 0 } `[`into`][ColumnReference.into]` "zeroes" }` * - * `df.`[select][DataFrame.select]` { "colA" `[named][String.named]` Type::colB }` + * `df.`[`select`][DataFrame.select]` { "colA" `[`named`][String.named]` Type::colB }` * * #### Example for this overload: * - * `df.`[select][DataFrame.select]` { {@get [CommonRenameDocs.RECEIVER]} `[{@get [CommonRenameDocs.FUNCTION_NAME]}][{@get [CommonRenameDocs.RECEIVER_TYPE]}.{@get [CommonRenameDocs.FUNCTION_NAME]}]` {@get [CommonRenameDocs.PARAM]} }` + * `df.`[`select`][DataFrame.select]` { {@get [CommonRenameDocs.RECEIVER]} `[{@get [CommonRenameDocs.FUNCTION_NAME]}][{@get [CommonRenameDocs.RECEIVER_TYPE]}.{@get [CommonRenameDocs.FUNCTION_NAME]}]` {@get [CommonRenameDocs.PARAM]} }` * * @receiver The [{@get [RECEIVER_TYPE]}] referencing the column to rename. * @param [{@get [PARAM_NAME]}\] A [{@get [PARAM_TYPE]}\] used to specify the new name of the column. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt index 0b3c2a4ea0..4209a334f9 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/select.kt @@ -47,7 +47,7 @@ internal interface Select { typealias SelectSelectingOptions = Nothing } -/** {@set [SelectingColumns.OPERATION] [select][select]} */ +/** {@set [SelectingColumns.OPERATION] [`select`][select]} */ @ExcludeFromSources private typealias SetSelectOperationArg = Nothing @@ -136,25 +136,25 @@ public interface SelectColumnsSelectionDsl { * ## Select from [ColumnGroup] * * Perform a selection of columns using the {@include [ColumnsSelectionDslLink]} on - * any [ColumnGroup]. This is more powerful than the [cols][ColumnsSelectionDsl.cols] filter, because now all + * any [ColumnGroup]. This is more powerful than the [`cols`][ColumnsSelectionDsl.cols] filter, because now all * operations of the DSL are at your disposal. * * The scope of the new DSL instance is relative to * the [ColumnGroup] you are selecting from. * - * The [invoke][ColumnsSelectionDsl.invoke] operator is overloaded to work as a shortcut for this method. + * The [`invoke`][ColumnsSelectionDsl.invoke] operator is overloaded to work as a shortcut for this method. * * ### Check out: [Grammar] * * #### For example: * - * `df.`[select][DataFrame.select]` { myColGroup.`[select][SingleColumn.select]` { someCol `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() } }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`select`][SingleColumn.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` * - * `df.`[select][DataFrame.select]` { "myGroupCol" `[{][String.select]` "colA" and `[expr][ColumnsSelectionDsl.expr]` { 0 } `[}][String.select]` }` + * `df.`[`select`][DataFrame.select]` { "myGroupCol" `[`{`][String.select]` "colA" and `[`expr`][ColumnsSelectionDsl.expr]` { 0 } `[`}`][String.select]` }` * - * `df.`[select][DataFrame.select]` { "pathTo"["myGroupCol"].`[select][ColumnPath.select]` { "colA" and "colB" } }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myGroupCol"].`[`select`][ColumnPath.select]` { "colA" and "colB" } }` * - * `df.`[select][DataFrame.select]` { it["myGroupCol"].`[asColumnGroup][DataColumn.asColumnGroup]`()`[() {][SingleColumn.select]` "colA" and "colB" `[}][SingleColumn.select]` }` + * `df.`[`select`][DataFrame.select]` { it["myGroupCol"].`[`asColumnGroup`][DataColumn.asColumnGroup]`()`[`() {`][SingleColumn.select]` "colA" and "colB" `[`}`][SingleColumn.select]` }` * * #### Examples for this overload: * @@ -162,7 +162,7 @@ public interface SelectColumnsSelectionDsl { * * {@include [LineBreak]} * - * See also [except][ColumnsSelectionDsl.except]/[allExcept][ColumnsSelectionDsl.allColsExcept] for the inverted operation of this function. + * See also [`except`][ColumnsSelectionDsl.except]/[`allExcept`][ColumnsSelectionDsl.allColsExcept] for the inverted operation of this function. * * @param [selector\] The [ColumnsSelector] to use for the selection. * @receiver The [ColumnGroup] to select from. @@ -179,9 +179,9 @@ public interface SelectColumnsSelectionDsl { * @include [CommonSelectDocs] * @set [CommonSelectDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColGroup.`[select][SingleColumn.select]` { someCol `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() } }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`select`][SingleColumn.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` * - * `df.`[select][DataFrame.select]` { myColGroup `[`{`][SingleColumn.select]` colA `[and][ColumnsSelectionDsl.and]` colB `[`}`][SingleColumn.select]` }` + * `df.`[`select`][DataFrame.select]` { myColGroup `[`{`][SingleColumn.select]` colA `[`and`][ColumnsSelectionDsl.and]` colB `[`}`][SingleColumn.select]` }` */ @Interpretable("NestedSelect") public fun SingleColumn>.select(selector: ColumnsSelector): ColumnSet = @@ -191,9 +191,9 @@ public interface SelectColumnsSelectionDsl { * @include [CommonSelectDocs] * @set [CommonSelectDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { Type::myColGroup.`[select][KProperty.select]` { someCol `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() } }` + * `df.`[`select`][DataFrame.select]` { Type::myColGroup.`[`select`][KProperty.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColGroup `[`{`][KProperty.select]` colA `[and][ColumnsSelectionDsl.and]` colB `[`}`][KProperty.select]` }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColGroup `[`{`][KProperty.select]` colA `[`and`][ColumnsSelectionDsl.and]` colB `[`}`][KProperty.select]` }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -204,9 +204,9 @@ public interface SelectColumnsSelectionDsl { * @include [SelectColumnsSelectionDsl.CommonSelectDocs] * @set [SelectColumnsSelectionDsl.CommonSelectDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColGroup".`[select][String.select]` { someCol `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() } }` + * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`select`][String.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` * - * `df.`[select][DataFrame.select]` { "myColGroup" `[`{`][String.select]` colA `[and][ColumnsSelectionDsl.and]` colB `[`}`][String.select]` }` + * `df.`[`select`][DataFrame.select]` { "myColGroup" `[`{`][String.select]` colA `[`and`][ColumnsSelectionDsl.and]` colB `[`}`][String.select]` }` */ @Interpretable("StringSelect") public fun String.select(selector: ColumnsSelector<*, R>): ColumnSet = columnGroup(this).select(selector) @@ -215,13 +215,13 @@ public interface SelectColumnsSelectionDsl { * @include [CommonSelectDocs] * @set [CommonSelectDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColGroup"].`[select][ColumnPath.select]` { someCol `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() } }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColGroup"].`[`select`][ColumnPath.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` * - * `df.`[select][DataFrame.select]` { "pathTo"["myColGroup"] `[`{`][ColumnPath.select]` colA `[and][ColumnsSelectionDsl.and]` colB `[`}`][ColumnPath.select]` }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColGroup"] `[`{`][ColumnPath.select]` colA `[`and`][ColumnsSelectionDsl.and]` colB `[`}`][ColumnPath.select]` }` * - * `df.`[select][DataFrame.select]` { `[pathOf][pathOf]`("pathTo", "myColGroup").`[select][ColumnPath.select]` { someCol `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() } }` + * `df.`[`select`][DataFrame.select]` { `[`pathOf`][pathOf]`("pathTo", "myColGroup").`[`select`][ColumnPath.select]` { someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() } }` * - * `df.`[select][DataFrame.select]` { `[pathOf][pathOf]`("pathTo", "myColGroup")`[`() {`][ColumnPath.select]` someCol `[and][ColumnsSelectionDsl.and]` `[colsOf][SingleColumn.colsOf]`<`[String][String]`>() `[`}`][ColumnPath.select]` }` + * `df.`[`select`][DataFrame.select]` { `[`pathOf`][pathOf]`("pathTo", "myColGroup")`[`() {`][ColumnPath.select]` someCol `[`and`][ColumnsSelectionDsl.and]` `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>() `[`}`][ColumnPath.select]` }` */ @Interpretable("ColumnPathSelect") public fun ColumnPath.select(selector: ColumnsSelector<*, R>): ColumnSet = columnGroup(this).select(selector) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/simplify.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/simplify.kt index ae92138082..ebc00d1c78 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/simplify.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/simplify.kt @@ -53,11 +53,11 @@ public interface SimplifyColumnsSelectionDsl { * * ## For example: * - * [cols][ColumnsSelectionDsl.cols]`(a, a.b, d.c).`[simplify][SimplifyColumnsSelectionDsl.simplify]`() == `[cols][ColumnsSelectionDsl.cols]`(a, d.c)` + * [`cols`][ColumnsSelectionDsl.cols]`(a, a.b, d.c).`[`simplify`][SimplifyColumnsSelectionDsl.simplify]`() == `[`cols`][ColumnsSelectionDsl.cols]`(a, d.c)` * {@include [LineBreak]} - * `df.`[select][DataFrame.select]` { `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]` { "e" `[in][String.contains]` it.`[name][DataColumn.name]` }.`[simplify][ColumnSet.simplify]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]` { "e" `[`in`][String.contains]` it.`[`name`][DataColumn.name]` }.`[`simplify`][ColumnSet.simplify]`() }` * - * @return A [ColumnSet][ColumnSet]`<`[C][C]`>` containing only the columns that are not inside any column group in [this]. + * @return A [`ColumnSet`][ColumnSet]`<`[`C`][C]`>` containing only the columns that are not inside any column group in [this]. */ @Suppress("UNCHECKED_CAST") public fun ColumnSet.simplify(): ColumnSet = simplifyInternal() as ColumnSet diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt index cb3610a60d..5584374a35 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/single.kt @@ -112,9 +112,9 @@ public interface SingleColumnsSelectionDsl { * * #### Examples: * - * `df.`[select][DataFrame.select]` { `[nameStartsWith][ColumnsSelectionDsl.nameStartsWith]`("order").`[single][ColumnsSelectionDsl.single]`() }` + * `df.`[`select`][DataFrame.select]` { `[`nameStartsWith`][ColumnsSelectionDsl.nameStartsWith]`("order").`[`single`][ColumnsSelectionDsl.single]`() }` * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsNameStartsWith][ColumnNameFiltersColumnsSelectionDsl.colsNameStartsWith]`("order").`[singleCol][String.singleCol]`() }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`colsNameStartsWith`][ColumnNameFiltersColumnsSelectionDsl.colsNameStartsWith]`("order").`[`singleCol`][String.singleCol]`() }` * * #### Examples for this overload: * @@ -133,9 +133,9 @@ public interface SingleColumnsSelectionDsl { /** * @include [CommonSingleDocs] * @set [CommonSingleDocs.Examples] - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[single][ColumnSet.single]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>().`[`single`][ColumnSet.single]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[single][ColumnSet.single]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`single`][ColumnSet.single]`() }` */ @Interpretable("Single0") @Deprecated( @@ -149,9 +149,9 @@ public interface SingleColumnsSelectionDsl { /** * @include [CommonSingleDocs] * @set [CommonSingleDocs.Examples] - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().nameStartsWith("year").`[single][ColumnSet.single]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>().nameStartsWith("year").`[`single`][ColumnSet.single]`() }` * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[single][ColumnSet.single]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`Int`][Int]`>().`[`single`][ColumnSet.single]`() }` */ @Interpretable("Single0") public fun ColumnSet.single(): SingleColumn = singleInternal { true } @@ -160,7 +160,7 @@ public interface SingleColumnsSelectionDsl { * @include [CommonSingleDocs] * @set [CommonSingleDocs.Examples] * - * `df.`[select][DataFrame.select]` { `[single][ColumnsSelectionDsl.single]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { `[`single`][ColumnsSelectionDsl.single]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` */ @Interpretable("Single1") @Deprecated( @@ -175,7 +175,7 @@ public interface SingleColumnsSelectionDsl { * @include [CommonSingleDocs] * @set [CommonSingleDocs.Examples] * - * `df.`[select][DataFrame.select]` { nameStartsWith("year").`[single][ColumnsSelectionDsl.single]`() }` + * `df.`[`select`][DataFrame.select]` { nameStartsWith("year").`[`single`][ColumnsSelectionDsl.single]`() }` */ @Interpretable("Single1") public fun ColumnsSelectionDsl<*>.single(): SingleColumn<*> = asSingleColumn().singleCol { true } @@ -184,7 +184,7 @@ public interface SingleColumnsSelectionDsl { * @include [CommonSingleDocs] * @set [CommonSingleDocs.Examples] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[singleCol][SingleColumn.singleCol]`() }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`singleCol`][SingleColumn.singleCol]`() }` */ @Interpretable("Single2") @Deprecated( @@ -200,7 +200,7 @@ public interface SingleColumnsSelectionDsl { * @include [CommonSingleDocs] * @set [CommonSingleDocs.Examples] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[singleCol][SingleColumn.singleCol]`() }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`singleCol`][SingleColumn.singleCol]`() }` */ @Interpretable("Single2") public fun SingleColumn>.singleCol(): SingleColumn<*> = this.ensureIsColumnGroup().asColumnSet().single() @@ -208,7 +208,7 @@ public interface SingleColumnsSelectionDsl { /** * @include [CommonSingleDocs] * @set [CommonSingleDocs.Examples] - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[singleCol][String.singleCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`singleCol`][String.singleCol]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` */ @Deprecated( message = SINGLE, @@ -221,16 +221,16 @@ public interface SingleColumnsSelectionDsl { /** * @include [CommonSingleDocs] * @set [CommonSingleDocs.Examples] - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsNameStartsWith][ColumnNameFiltersColumnsSelectionDsl.colsNameStartsWith]`("year").`[singleCol][String.singleCol]`() }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`colsNameStartsWith`][ColumnNameFiltersColumnsSelectionDsl.colsNameStartsWith]`("year").`[`singleCol`][String.singleCol]`() }` */ public fun String.singleCol(): SingleColumn<*> = columnGroup(this).singleCol() /** * @include [CommonSingleDocs] * @set [CommonSingleDocs.Examples] - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[singleCol][SingleColumn.singleCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`singleCol`][SingleColumn.singleCol]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[singleCol][KProperty.singleCol]`() }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`singleCol`][KProperty.singleCol]`() }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -240,7 +240,7 @@ public interface SingleColumnsSelectionDsl { /** * @include [CommonSingleDocs] * @set [CommonSingleDocs.Examples] - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[singleCol][ColumnPath.singleCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`singleCol`][ColumnPath.singleCol]` { it.`[`name`][ColumnReference.name]`().`[`startsWith`][String.startsWith]`("year") } }` */ public fun ColumnPath.singleCol(condition: (ColumnWithPath<*>) -> Boolean = { true }): SingleColumn<*> = columnGroup(this).singleCol(condition) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt index bb7e05607c..69bc2aeef8 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/sort.kt @@ -81,19 +81,19 @@ public fun > DataColumn.sortDesc(): ValueColumn = * * #### For example * - * `df`[`[`][DataFrame.get]`"price"`[`]`][DataFrame.get]`.`[sortWith][sortWith]` { a, b -> a - b }` + * `df`[`[`][DataFrame.get]`"price"`[`]`][DataFrame.get]`.`[`sortWith`][sortWith]` { a, b -> a - b }` * * {@include [LineBreak]} - * `df.`[select][DataFrame.select]` {` + * `df.`[`select`][DataFrame.select]` {` * - * {@include [Indent]}`name.`[sortWith][sortWith]`(myComparator) `[and][ColumnsSelectionDsl.and]` `[allAfter][ColumnsSelectionDsl.allAfter]`(name)` + * {@include [Indent]}`name.`[`sortWith`][sortWith]`(myComparator) `[`and`][ColumnsSelectionDsl.and]` `[`allAfter`][ColumnsSelectionDsl.allAfter]`(name)` * * `}` * * @receiver The [DataColumn] to sort. This can be either a [ValueColumn], [FrameColumn], or [ColumnGroup] and will * dictate the return type of the function. * @param [comparator\] The [Comparator] to use for sorting the [DataColumn]. This can either be a [Comparator]<[T\]> or - * a lambda of type `(`[T][T\]`, `[T][T\]`) -> `[Int][Int]. + * a lambda of type `(`[`T`][T\]`, `[`T`][T\]`) -> `[`Int`][Int]. * @return The sorted [DataColumn] [this\] of the same type as the receiver. */ private typealias CommonDataColumnSortWithDocs = Nothing diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt index 760c3bdbe7..44008fe942 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/take.kt @@ -114,9 +114,9 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeFirstDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[take][ColumnSet.take]`(2) }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>().`[`take`][ColumnSet.take]`(2) }` * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[take][ColumnSet.take]`(2) }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`take`][ColumnSet.take]`(2) }` */ @Interpretable("Take0") public fun ColumnSet.take(n: Int): ColumnSet = transform { it.take(n) } @@ -125,7 +125,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeFirstDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[take][ColumnsSelectionDsl.take]`(5) }` + * `df.`[`select`][DataFrame.select]` { `[`take`][ColumnsSelectionDsl.take]`(5) }` */ @Interpretable("Take1") public fun ColumnsSelectionDsl<*>.take(n: Int): ColumnSet<*> = this.asSingleColumn().takeCols(n) @@ -134,7 +134,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeFirstDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[takeCols][SingleColumn.takeCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`takeCols`][SingleColumn.takeCols]`(1) }` */ @Interpretable("Take2") public fun SingleColumn>.takeCols(n: Int): ColumnSet<*> = @@ -144,7 +144,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeFirstDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[takeCols][String.takeCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`takeCols`][String.takeCols]`(1) }` */ public fun String.takeCols(n: Int): ColumnSet<*> = columnGroup(this).takeCols(n) @@ -152,9 +152,9 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeFirstDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[takeCols][SingleColumn.takeCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`takeCols`][SingleColumn.takeCols]`(1) }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[takeCols][KProperty.takeCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`takeCols`][KProperty.takeCols]`(1) }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -164,7 +164,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeFirstDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[takeCols][ColumnPath.takeCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`takeCols`][ColumnPath.takeCols]`(1) }` */ public fun ColumnPath.takeCols(n: Int): ColumnSet<*> = columnGroup(this).takeCols(n) @@ -185,9 +185,9 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeLastDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[takeLast][ColumnSet.takeLast]`(2) }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>().`[`takeLast`][ColumnSet.takeLast]`(2) }` * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[takeLast][ColumnSet.takeLast]`(2) }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`takeLast`][ColumnSet.takeLast]`(2) }` */ @Interpretable("TakeLast0") public fun ColumnSet.takeLast(n: Int = 1): ColumnSet = transform { it.takeLast(n) } @@ -196,7 +196,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeLastDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[takeLast][ColumnsSelectionDsl.takeLast]`(5) }` + * `df.`[`select`][DataFrame.select]` { `[`takeLast`][ColumnsSelectionDsl.takeLast]`(5) }` */ @Interpretable("TakeLast1") public fun ColumnsSelectionDsl<*>.takeLast(n: Int = 1): ColumnSet<*> = asSingleColumn().takeLastCols(n) @@ -205,7 +205,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeLastDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[takeLast][SingleColumn.takeLastCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`takeLast`][SingleColumn.takeLastCols]`(1) }` */ @Interpretable("TakeLast2") public fun SingleColumn>.takeLastCols(n: Int): ColumnSet<*> = @@ -215,7 +215,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeLastDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[takeLastCols][String.takeLastCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`takeLastCols`][String.takeLastCols]`(1) }` */ public fun String.takeLastCols(n: Int): ColumnSet<*> = columnGroup(this).takeLastCols(n) @@ -223,9 +223,9 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeLastDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[takeLastCols][SingleColumn.takeLastCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`takeLastCols`][SingleColumn.takeLastCols]`(1) }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[takeLastCols][KProperty.takeLastCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`takeLastCols`][KProperty.takeLastCols]`(1) }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -235,7 +235,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeLastDocs] * @set [CommonTakeAndDropDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[takeLastCols][ColumnPath.takeLastCols]`(1) }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`takeLastCols`][ColumnPath.takeLastCols]`(1) }` */ public fun ColumnPath.takeLastCols(n: Int): ColumnSet<*> = columnGroup(this).takeLastCols(n) @@ -256,9 +256,9 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeFirstWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[takeWhile][ColumnSet.takeWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>().`[`takeWhile`][ColumnSet.takeWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[takeWhile][ColumnSet.takeWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`takeWhile`][ColumnSet.takeWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun ColumnSet.takeWhile(predicate: (ColumnWithPath) -> Boolean): ColumnSet = transform { it.takeWhile(predicate) } @@ -267,7 +267,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeFirstWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[takeWhile][ColumnsSelectionDsl.takeWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { `[`takeWhile`][ColumnsSelectionDsl.takeWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` */ public fun ColumnsSelectionDsl<*>.takeWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = asSingleColumn().takeColsWhile(predicate) @@ -276,7 +276,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeFirstWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[takeWhile][SingleColumn.takeColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`takeWhile`][SingleColumn.takeColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun SingleColumn>.takeColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = this.ensureIsColumnGroup().transformSingle { it.cols().takeWhile(predicate) } @@ -285,7 +285,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeFirstWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[takeColsWhile][String.takeColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`takeColsWhile`][String.takeColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun String.takeColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = columnGroup(this).takeColsWhile(predicate) @@ -294,9 +294,9 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeFirstWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[takeColsWhile][SingleColumn.takeColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`takeColsWhile`][SingleColumn.takeColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[takeColsWhile][KProperty.takeColsWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`takeColsWhile`][KProperty.takeColsWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -307,7 +307,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeFirstWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[takeColsWhile][ColumnPath.takeColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`takeColsWhile`][ColumnPath.takeColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun ColumnPath.takeColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = columnGroup(this).takeColsWhile(predicate) @@ -329,9 +329,9 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeLastWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[takeLastWhile][ColumnSet.takeLastWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { `[`colsOf`][SingleColumn.colsOf]`<`[`String`][String]`>().`[`takeLastWhile`][ColumnSet.takeLastWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[takeLastWhile][ColumnSet.takeLastWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`takeLastWhile`][ColumnSet.takeLastWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun ColumnSet.takeLastWhile(predicate: (ColumnWithPath) -> Boolean): ColumnSet = transform { it.takeLastWhile(predicate) } @@ -340,7 +340,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeLastWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[takeLastWhile][ColumnsSelectionDsl.takeLastWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { `[`takeLastWhile`][ColumnsSelectionDsl.takeLastWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` */ public fun ColumnsSelectionDsl<*>.takeLastWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = asSingleColumn().takeLastColsWhile(predicate) @@ -349,7 +349,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeLastWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[takeLastColsWhile][SingleColumn.takeLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`takeLastColsWhile`][SingleColumn.takeLastColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun SingleColumn>.takeLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = this.ensureIsColumnGroup().transformSingle { it.cols().takeLastWhile(predicate) } @@ -358,7 +358,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeLastWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[takeLastColsWhile][String.takeLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`takeLastColsWhile`][String.takeLastColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun String.takeLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = columnGroup(this).takeLastColsWhile(predicate) @@ -367,9 +367,9 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeLastWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[takeLastColsWhile][SingleColumn.takeLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`takeLastColsWhile`][SingleColumn.takeLastColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[takeLastColsWhile][KProperty.takeLastColsWhile]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`takeLastColsWhile`][KProperty.takeLastColsWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -380,7 +380,7 @@ public interface TakeColumnsSelectionDsl { * @include [CommonTakeLastWhileDocs] * @set [CommonTakeAndDropWhileDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[takeLastColsWhile][ColumnPath.takeLastColsWhile]` { it.`[name][ColumnWithPath.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColumnGroup"].`[`takeLastColsWhile`][ColumnPath.takeLastColsWhile]` { it.`[`name`][ColumnWithPath.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ public fun ColumnPath.takeLastColsWhile(predicate: (ColumnWithPath<*>) -> Boolean): ColumnSet<*> = columnGroup(this).takeLastColsWhile(predicate) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/typeConversions.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/typeConversions.kt index 65a7560aef..90775a18b2 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/typeConversions.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/typeConversions.kt @@ -163,21 +163,21 @@ public fun ColumnGroup.asDataFrame(): DataFrame = this /** * ## As ColumnGroup * - * Creates a [ColumnAccessor][ColumnAccessor]`<`[DataRow][DataRow]`<`[C][C\]`>>` from [this][this\]. + * Creates a [`ColumnAccessor`][ColumnAccessor]`<`[`DataRow`][DataRow]`<`[`C`][C\]`>>` from [this][this\]. * This is especially useful when you want to use [ColumnGroup] functions in the [ColumnsSelectionDsl] but your column * type is not recognized as a [ColumnGroup]. - * If you're not sure whether a column is recognized as [ColumnGroup] or not, you can always call [asColumnGroup][asColumnGroup\] + * If you're not sure whether a column is recognized as [ColumnGroup] or not, you can always call [`asColumnGroup`][asColumnGroup\] * and it will return the same type if it is already a [ColumnGroup]. * * NOTE: This does not check whether the column is actually a [ColumnGroup] or not. It just casts it. * * #### For example: * - * `df.`[select][DataFrame.select]` { `[first][ColumnsSelectionDsl.first]`().`[asColumnGroup][SingleColumn.asColumnGroup]`().`[firstCol][ColumnsSelectionDsl.firstCol]`() }` + * `df.`[`select`][DataFrame.select]` { `[`first`][ColumnsSelectionDsl.first]`().`[`asColumnGroup`][SingleColumn.asColumnGroup]`().`[`firstCol`][ColumnsSelectionDsl.firstCol]`() }` * - * @receiver The column reference to cast to a [SingleColumn]`<`[DataRow][DataRow]`<`[C][C\]`>>`. + * @receiver The column reference to cast to a [SingleColumn]`<`[`DataRow`][DataRow]`<`[`C`][C\]`>>`. * @param [C\] The type of the (group) column. - * @return A [SingleColumn]`<`[DataRow][DataRow]`<`[C][C\]`>>`. + * @return A [SingleColumn]`<`[`DataRow`][DataRow]`<`[`C`][C\]`>>`. */ private typealias SingleColumnAsColumnGroupDocs = Nothing diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt index 74f2ee5687..82432f8cd8 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ungroup.kt @@ -45,7 +45,7 @@ internal interface UngroupDocs { typealias UngroupSelectingOptions = Nothing } -/** {@set [SelectingColumns.OPERATION] [ungroup][ungroup]} */ +/** {@set [SelectingColumns.OPERATION] [`ungroup`][ungroup]} */ @ExcludeFromSources private typealias SetUngroupOperationArg = Nothing diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt index 5427e7cd73..a1a8ddbe8e 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/update.kt @@ -138,7 +138,7 @@ public class Update( // region update -/** {@set [SelectingColumns.OPERATION] [update][update]} */ +/** {@set [SelectingColumns.OPERATION] [`update`][update]} */ @ExcludeFromSources private typealias SetSelectingColumnsOperationArg = Nothing @@ -153,8 +153,8 @@ private typealias CommonUpdateFunctionDoc = Nothing /** * ## Optional - * Combine `df.`[update][update]`(...).`[with][Update.with]` { ... }` - * into `df.`[update][update]`(...) { ... }` + * Combine `df.`[`update`][update]`(...).`[`with`][Update.with]` { ... }` + * into `df.`[`update`][update]`(...) { ... }` */ @ExcludeFromSources private typealias UpdateWithNote = Nothing @@ -200,8 +200,8 @@ public fun DataFrame.update(vararg columns: ColumnReference): Updat /** ## Where * @include [SelectingRows.RowValueCondition.WithExample] - * {@set [SelectingRows.FIRST_OPERATION] [update][update]} - * {@set [SelectingRows.SECOND_OPERATION] [where][where]} + * {@set [SelectingRows.FIRST_OPERATION] [`update`][update]} + * {@set [SelectingRows.SECOND_OPERATION] [`where`][where]} * * @param [predicate] The [row value filter][RowValueFilter] to select the rows to update. */ @@ -216,9 +216,9 @@ public fun Update.where(predicate: RowValueFilter): Update Update.at(rowRange: IntRange): Update = where { in /** ## Per Row Col * @include [ExpressionsGivenRowAndColumn.RowColumnExpression.WithExample] - * {@set [ExpressionsGivenRowAndColumn.OPERATION] [update][update]` { age \}.`[perRowCol][perRowCol]} + * {@set [ExpressionsGivenRowAndColumn.OPERATION] [`update`][update]` { age \}.`[`perRowCol`][perRowCol]} * * ## See Also * - {@include [SeeAlsoUpdateWith]} @@ -286,7 +286,7 @@ public typealias UpdateExpression = AddDataRow.(C) -> R /** ## With * {@include [ExpressionsGivenRow.RowValueExpression.WithExample]} - * {@set [ExpressionsGivenRow.OPERATION] [update][update]` { city \}.`[with][with]} + * {@set [ExpressionsGivenRow.OPERATION] [`update`][update]` { city \}.`[`with`][with]} * * ## Note * @include [ExpressionsGivenRow.AddDataRowNote] @@ -312,7 +312,7 @@ private typealias SeeAlsoUpdateWith = Nothing * Updates selected [column group][ColumnGroup] as a [DataFrame] with the given [expression]. * * {@include [ExpressionsGivenDataFrame.DataFrameExpression.WithExample]} - * {@set [ExpressionsGivenDataFrame.OPERATION] `df.`[update][update]` { name \}.`[asFrame][asFrame]} + * {@set [ExpressionsGivenDataFrame.OPERATION] `df.`[`update`][update]` { name \}.`[`asFrame`][asFrame]} * @param [expression] The {@include [ExpressionsGivenDataFrame.DataFrameExpressionLink]} to replace the selected column group with. */ public fun Update>.asFrame(expression: DataFrameExpression>): DataFrame = @@ -332,8 +332,8 @@ public fun Update>.asFrame(expression: DataFrameExpressi @ExcludeFromSources private typealias CommonUpdatePerColDoc = Nothing -/** Provide a new value for every selected cell per column using a [Map][Map]`<`[colName: String][String]`, value: C>` - * or [DataRow][DataRow] as Map. */ +/** Provide a new value for every selected cell per column using a [`Map`][Map]`<`[`colName: String`][String]`, value: C>` + * or [`DataRow`][DataRow] as Map. */ @ExcludeFromSources private typealias UpdatePerColMap = Nothing @@ -345,7 +345,7 @@ private typealias UpdatePerColMap = Nothing * * `val defaults = {@get [CommonUpdatePerColMapDoc]}` * - * `df.`[update][update]` { name and age }.`[where][Update.where]` { ... }.`[perCol][perCol]`(defaults)` + * `df.`[`update`][update]` { name and age }.`[`where`][Update.where]` { ... }.`[`perCol`][perCol]`(defaults)` * * @throws [IllegalArgumentException] if a value for a selected cell's column is not defined in [values\]. */ @@ -354,7 +354,7 @@ private typealias CommonUpdatePerColMapDoc = Nothing /** * @include [CommonUpdatePerColMapDoc] - * {@set [CommonUpdatePerColMapDoc] `[mapOf][mapOf]`("name" to "Empty", "age" to 0)} + * {@set [CommonUpdatePerColMapDoc] `[`mapOf`][mapOf]`("name" to "Empty", "age" to 0)} * * @param [values] The [Map]<[String], Value> to provide a new value for every selected cell. * For each selected column, there must be a value in the map with the same name. @@ -368,11 +368,11 @@ public fun Update.perCol(values: Map): DataFrame = /** * {@include [CommonUpdatePerColMapDoc]} - * {@set [CommonUpdatePerColMapDoc] df.`[getRows][DataFrame.getRows]`(`[listOf][listOf]`(0))` + * {@set [CommonUpdatePerColMapDoc] df.`[`getRows`][DataFrame.getRows]`(`[`listOf`][listOf]`(0))` * - * {@include [Indent]}`.`[update][update]` { name \}.`[with][Update.with]` { "Empty" \}` + * {@include [Indent]}`.`[`update`][update]` { name \}.`[`with`][Update.with]` { "Empty" \}` * - * {@include [Indent]}`.`[update][update]` { age \}.`[with][Update.with]` { 0 \}` + * {@include [Indent]}`.`[`update`][update]` { age \}.`[`with`][Update.with]` { 0 \}` * * {@include [Indent]}`.first()} * @@ -385,7 +385,7 @@ public fun Update.perCol(values: DataRow<*>): DataFrame = perCol /** * @include [CommonUpdatePerColDoc] * @include [ExpressionsGivenColumn.ColumnExpression.WithExample] - * {@set [ExpressionsGivenColumn.OPERATION] [update][update]` { age \}.`[perCol][perCol]} + * {@set [ExpressionsGivenColumn.OPERATION] [`update`][update]` { age \}.`[`perCol`][perCol]} * * @param [valueSelector] The {@include [ExpressionsGivenColumn.ColumnExpressionLink]} to provide a new value for every selected cell giving its column. */ @@ -409,13 +409,13 @@ internal infix fun RowValueFilter?.and(other: RowValueFilter) * ## Not Null * Filters the update-selection to only include cells where the value is not null. * - * This is shorthand for `.`[where][Update.where]` { it != null }`. + * This is shorthand for `.`[`where`][Update.where]` { it != null }`. * * For example: * - * `df.`[update][update]` { `[colsOf][colsOf]`<`[Int][Int]`?>() }.`[notNull][notNull]`().`[perRowCol][Update.perRowCol]` { row, col ->` + * `df.`[`update`][update]` { `[`colsOf`][colsOf]`<`[`Int`][Int]`?>() }.`[`notNull`][notNull]`().`[`perRowCol`][Update.perRowCol]` { row, col ->` * - * {@include [Indent]}`row\[col\] / col.`[mean][DataColumn.mean]`(skipNA = true)` + * {@include [Indent]}`row\[col\] / col.`[`mean`][DataColumn.mean]`(skipNA = true)` * * `}` */ @@ -428,19 +428,19 @@ public fun Update.notNull(): Update = where { it != null } a * * Selects only the rows where the values in the selected columns are not null. * - * Shorthand for: [update][update]` { ... }.`[where][Update.where]` { it != null }` + * Shorthand for: [`update`][update]` { ... }.`[`where`][Update.where]` { it != null }` * * For example: * - * `df.`[update][update]` { `[colsOf][colsOf]`<`[Number][Number]`?>() }.`[notNull][notNull]`().`[perCol][Update.perCol]` { `[mean][mean]`() }` + * `df.`[`update`][update]` { `[`colsOf`][colsOf]`<`[`Number`][Number]`?>() }.`[`notNull`][notNull]`().`[`perCol`][Update.perCol]` { `[`mean`][mean]`() }` * * ### Optional * Provide an [expression] to update the rows with. - * This combines [with][Update.with] with [notNull]. + * This combines [`with`][Update.with] with [notNull]. * * For example: * - * `df.`[update][update]` { city }.`[notNull][Update.notNull]` { it.`[toUpperCase][String.toUpperCase]`() }` + * `df.`[`update`][update]` { city }.`[`notNull`][Update.notNull]` { it.`[`toUpperCase`][String.toUpperCase]`() }` * {@comment No brackets around `expression` because this doc is copied to [Update.notNull]} * @param expression Optional {@include [ExpressionsGivenRow.RowExpressionLink]} to update the rows with. */ @@ -451,10 +451,10 @@ public fun Update.notNull(expression: UpdateExpression): /** * @include [CommonUpdateFunctionDoc] - * This overload is a combination of [update] and [with][Update.with]. + * This overload is a combination of [update] and [`with`][Update.with]. * * {@include [ExpressionsGivenRow.RowValueExpression.WithExample]} - * {@set [ExpressionsGivenRow.OPERATION] [update][update]`("city")`} + * {@set [ExpressionsGivenRow.OPERATION] [`update`][update]`("city")`} * * @include [Update.ColumnAccessorsParam] * @param [expression] The {@include [ExpressionsGivenRow.RowValueExpressionLink]} to update the rows with. @@ -469,10 +469,10 @@ public fun DataFrame.update( /** * @include [CommonUpdateFunctionDoc] - * This overload is a combination of [update] and [with][Update.with]. + * This overload is a combination of [update] and [`with`][Update.with]. * * {@include [ExpressionsGivenRow.RowValueExpression.WithExample]} - * {@set [ExpressionsGivenRow.OPERATION] [update][update]`("city")`} + * {@set [ExpressionsGivenRow.OPERATION] [`update`][update]`("city")`} * * @include [Update.KPropertiesParam] * @param [expression] The {@include [ExpressionsGivenRow.RowValueExpressionLink]} to update the rows with. @@ -487,12 +487,12 @@ public fun DataFrame.update( /** * @include [CommonUpdateFunctionDoc] - * This overload is a combination of [update] and [with][Update.with]. + * This overload is a combination of [update] and [`with`][Update.with]. * * @include [SelectingColumns.ColumnNamesApi] * * {@include [ExpressionsGivenRow.RowValueExpression.WithExample]} - * {@set [ExpressionsGivenRow.OPERATION] [update][update]`("city")`} + * {@set [ExpressionsGivenRow.OPERATION] [`update`][update]`("city")`} * * @include [Update.ColumnNamesParam] * @param [expression] The {@include [ExpressionsGivenRow.RowValueExpressionLink]} to update the rows with. @@ -508,7 +508,7 @@ public fun DataFrame.update( * * For example: * - * `df.`[update][update]` { id }.`[where][Update.where]` { it < 0 }.`{@get [SECOND]}` + * `df.`[`update`][update]` { id }.`[`where`][Update.where]` { it < 0 }.`{@get [SECOND]}` */ @ExcludeFromSources private interface CommonSpecificWithDoc { @@ -524,7 +524,7 @@ private interface CommonSpecificWithDoc { * ## With Null * @include [CommonSpecificWithDoc] * {@set [CommonSpecificWithDoc.FIRST] `null`} - * {@set [CommonSpecificWithDoc.SECOND] [withNull][withNull]`()} + * {@set [CommonSpecificWithDoc.SECOND] [`withNull`][withNull]`()} */ @Refine @Interpretable("UpdateWithNull") @@ -534,7 +534,7 @@ public fun Update.withNull(): DataFrame = with { null } * ## With Zero * @include [CommonSpecificWithDoc] * {@set [CommonSpecificWithDoc.FIRST] `0`} - * {@set [CommonSpecificWithDoc.SECOND] [withZero][withZero]`()} + * {@set [CommonSpecificWithDoc.SECOND] [`withZero`][withZero]`()} */ @Refine @Interpretable("UpdateWithZero") diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt index 67b207c23c..4eba990c73 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCol.kt @@ -93,20 +93,20 @@ public interface ValueColColumnsSelectionDsl { * * #### For example: * - * `df.`[select][DataFrame.select]` { `[valueCol][valueCol]`<`[String][String]`>("valueColA") }` + * `df.`[`select`][DataFrame.select]` { `[`valueCol`][valueCol]`<`[`String`][String]`>("valueColA") }` * - * `df.`[select][DataFrame.select]` { `[valueCol][valueCol]`(SomeType::valueColB) }` + * `df.`[`select`][DataFrame.select]` { `[`valueCol`][valueCol]`(SomeType::valueColB) }` * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[valueCol][valueCol]`(1) }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`valueCol`][valueCol]`(1) }` * * #### Examples for this overload: * * {@get [CommonValueColDocs.EXAMPLE]} * * To create a [ColumnAccessor] for another kind of column, take a look at the functions - * [col][ColumnsSelectionDsl.col], - * [colGroup][ColumnsSelectionDsl.colGroup], - * and [frameCol][ColumnsSelectionDsl.frameCol]. + * [`col`][ColumnsSelectionDsl.col], + * [`colGroup`][ColumnsSelectionDsl.colGroup], + * and [`frameCol`][ColumnsSelectionDsl.frameCol]. * * @return A [ColumnAccessor] for the value column with the given argument if possible, else a [SingleColumn]. * @throws [IllegalStateException\] if the column with the given argument does not exist. @@ -123,14 +123,14 @@ public interface ValueColColumnsSelectionDsl { typealias EXAMPLE = Nothing /** - * `df.`[select][DataFrame.select]` { {@get [CommonValueColDocs.RECEIVER]}`[valueCol][valueCol]`({@get [CommonValueColDocs.ARG]}) \}` + * `df.`[`select`][DataFrame.select]` { {@get [CommonValueColDocs.RECEIVER]}`[`valueCol`][valueCol]`({@get [CommonValueColDocs.ARG]}) \}` */ typealias SingleExample = Nothing /** - * `df.`[select][DataFrame.select]` { {@get [CommonValueColDocs.RECEIVER]}`[valueCol][valueCol]`({@get [CommonValueColDocs.ARG]}) \}` + * `df.`[`select`][DataFrame.select]` { {@get [CommonValueColDocs.RECEIVER]}`[`valueCol`][valueCol]`({@get [CommonValueColDocs.ARG]}) \}` * - * `df.`[select][DataFrame.select]` { {@get [CommonValueColDocs.RECEIVER]}`[valueCol][valueCol]`<`[String][String]`>({@get [CommonValueColDocs.ARG]}) \}` + * `df.`[`select`][DataFrame.select]` { {@get [CommonValueColDocs.RECEIVER]}`[`valueCol`][valueCol]`<`[`String`][String]`>({@get [CommonValueColDocs.ARG]}) \}` */ typealias DoubleExample = Nothing @@ -486,7 +486,7 @@ public interface ValueColColumnsSelectionDsl { private typealias ValueColIndexDocs = Nothing /** - * @include [ValueColIndexDocs] {@set [CommonValueColDocs.RECEIVER] `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Int][Int]`>().} + * @include [ValueColIndexDocs] {@set [CommonValueColDocs.RECEIVER] `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Int`][Int]`>().} * @include [CommonValueColDocs.ValueColumnTypeParam] * {@set [CommonValueColDocs.EXAMPLE] {@include [CommonValueColDocs.SingleExample]}} */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCols.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCols.kt index e85eba6f8f..045983467b 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCols.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCols.kt @@ -78,11 +78,11 @@ public interface ValueColsColumnsSelectionDsl { * * #### For example: * - * `df.`[select][DataFrame.select]` { `[valueCols][ColumnsSelectionDsl.valueCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`valueCols`][ColumnsSelectionDsl.valueCols]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` * - * `df.`[select][DataFrame.select]` { `[colsAtAnyDepth][ColumnsSelectionDsl.colsAtAnyDepth]`().`[valueCols][ColumnsSelectionDsl.valueCols]`() }` + * `df.`[`select`][DataFrame.select]` { `[`colsAtAnyDepth`][ColumnsSelectionDsl.colsAtAnyDepth]`().`[`valueCols`][ColumnsSelectionDsl.valueCols]`() }` * - * `df.`[select][DataFrame.select]` { "myColGroup".`[valueCols][String.valueCols]`() }` + * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`valueCols`][String.valueCols]`() }` * * #### Examples for this overload: * @@ -105,11 +105,11 @@ public interface ValueColsColumnsSelectionDsl { * @include [CommonValueColsDocs] * @set [CommonValueColsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") }.`[valueCols][ColumnSet.valueCols]`() }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") }.`[`valueCols`][ColumnSet.valueCols]`() }` * * `// NOTE: This can be shortened to just:` * - * `df.`[select][DataFrame.select]` { `[valueCols][ColumnsSelectionDsl.valueCols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`("my") } }` + * `df.`[`select`][DataFrame.select]` { `[`valueCols`][ColumnsSelectionDsl.valueCols]` { it.`[`name`][ColumnReference.name]`.`[`startsWith`][String.startsWith]`("my") } }` */ @Interpretable("ValueCols0") public fun ColumnSet<*>.valueCols(filter: Predicate> = { true }): ColumnSet<*> = @@ -119,9 +119,9 @@ public interface ValueColsColumnsSelectionDsl { * @include [CommonValueColsDocs] * @set [CommonValueColsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[valueCols][ColumnsSelectionDsl.valueCols]`() }` + * `df.`[`select`][DataFrame.select]` { `[`valueCols`][ColumnsSelectionDsl.valueCols]`() }` * - * `df.`[select][DataFrame.select]` { `[valueCols][ColumnsSelectionDsl.valueCols]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { `[`valueCols`][ColumnsSelectionDsl.valueCols]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` */ @Interpretable("ValueCols1") public fun ColumnsSelectionDsl<*>.valueCols(filter: Predicate> = { true }): ColumnSet<*> = @@ -131,9 +131,9 @@ public interface ValueColsColumnsSelectionDsl { * @include [CommonValueColsDocs] * @set [CommonValueColsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColGroup.`[valueCols][SingleColumn.valueCols]`() }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`valueCols`][SingleColumn.valueCols]`() }` * - * `df.`[select][DataFrame.select]` { myColGroup.`[valueCols][SingleColumn.valueCols]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { myColGroup.`[`valueCols`][SingleColumn.valueCols]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` */ @Interpretable("ValueCols2") public fun SingleColumn>.valueCols(filter: Predicate> = { true }): ColumnSet<*> = @@ -143,9 +143,9 @@ public interface ValueColsColumnsSelectionDsl { * @include [CommonValueColsDocs] * @set [CommonValueColsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColGroup".`[valueCols][String.valueCols]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`valueCols`][String.valueCols]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` * - * `df.`[select][DataFrame.select]` { "myColGroup".`[valueCols][String.valueCols]`() }` + * `df.`[`select`][DataFrame.select]` { "myColGroup".`[`valueCols`][String.valueCols]`() }` */ public fun String.valueCols(filter: Predicate> = { true }): ColumnSet<*> = columnGroup(this).valueCols(filter) @@ -154,11 +154,11 @@ public interface ValueColsColumnsSelectionDsl { * @include [CommonValueColsDocs] * @set [CommonValueColsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[valueCols][KProperty.valueCols]` { it.`[any][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`valueCols`][KProperty.valueCols]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` * - * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[valueCols][KProperty.valueCols]`() }` + * `df.`[`select`][DataFrame.select]` { Type::myColumnGroup.`[`valueCols`][KProperty.valueCols]`() }` * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[valueCols][KProperty.valueCols]`() }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`valueCols`][KProperty.valueCols]`() }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -169,7 +169,7 @@ public interface ValueColsColumnsSelectionDsl { * @include [CommonValueColsDocs] * @set [CommonValueColsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myGroupCol"].`[valueCols][ColumnPath.valueCols]`() }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myGroupCol"].`[`valueCols`][ColumnPath.valueCols]`() }` */ public fun ColumnPath.valueCols(filter: Predicate> = { true }): ColumnSet<*> = columnGroup(this).valueCols(filter) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/withoutNulls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/withoutNulls.kt index bd5d3a00dd..76051d04df 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/withoutNulls.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/withoutNulls.kt @@ -70,11 +70,11 @@ public interface WithoutNullsColumnsSelectionDsl { * * #### For Example: * - * `df.`[select][DataFrame.select]` { `[all][ColumnsSelectionDsl.all]`().`[nameContains][ColumnsSelectionDsl.colsNameContains]`("middleName").`[withoutNulls][ColumnSet.withoutNulls]`() }` + * `df.`[`select`][DataFrame.select]` { `[`all`][ColumnsSelectionDsl.all]`().`[`nameContains`][ColumnsSelectionDsl.colsNameContains]`("middleName").`[`withoutNulls`][ColumnSet.withoutNulls]`() }` * - * `df.`[select][DataFrame.select]` { `[withoutNulls][ColumnsSelectionDsl.withoutNulls]`() }` + * `df.`[`select`][DataFrame.select]` { `[`withoutNulls`][ColumnsSelectionDsl.withoutNulls]`() }` * - * `df.`[select][DataFrame.select]` { Type::userData.`[colsWithoutNulls][SingleColumn.colsWithoutNulls]`() }` + * `df.`[`select`][DataFrame.select]` { Type::userData.`[`colsWithoutNulls`][SingleColumn.colsWithoutNulls]`() }` * * #### Examples for this overload: * @@ -91,7 +91,7 @@ public interface WithoutNullsColumnsSelectionDsl { * @include [CommonWithoutNullsDocs] * @set [CommonWithoutNullsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[withoutNulls][ColumnSet.withoutNulls]`() }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { .. }.`[`withoutNulls`][ColumnSet.withoutNulls]`() }` */ @Suppress("UNCHECKED_CAST") @Interpretable("WithoutNulls0") @@ -102,7 +102,7 @@ public interface WithoutNullsColumnsSelectionDsl { * @include [CommonWithoutNullsDocs] * @set [CommonWithoutNullsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { `[withoutNulls][ColumnsSelectionDsl.colsWithoutNulls]`() }` + * `df.`[`select`][DataFrame.select]` { `[`withoutNulls`][ColumnsSelectionDsl.colsWithoutNulls]`() }` */ @Interpretable("WithoutNulls1") public fun ColumnsSelectionDsl<*>.withoutNulls(): ColumnSet = asSingleColumn().colsWithoutNulls() @@ -111,7 +111,7 @@ public interface WithoutNullsColumnsSelectionDsl { * @include [CommonWithoutNullsDocs] * @set [CommonWithoutNullsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsWithoutNulls][SingleColumn.colsWithoutNulls]`() }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[`colsWithoutNulls`][SingleColumn.colsWithoutNulls]`() }` */ @Interpretable("WithoutNulls2") public fun SingleColumn>.colsWithoutNulls(): ColumnSet = @@ -121,7 +121,7 @@ public interface WithoutNullsColumnsSelectionDsl { * @include [CommonWithoutNullsDocs] * @set [CommonWithoutNullsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[colsWithoutNulls][String.colsWithoutNulls]`() }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[`colsWithoutNulls`][String.colsWithoutNulls]`() }` */ public fun String.colsWithoutNulls(): ColumnSet = columnGroup(this).colsWithoutNulls() @@ -129,7 +129,7 @@ public interface WithoutNullsColumnsSelectionDsl { * @include [CommonWithoutNullsDocs] * @set [CommonWithoutNullsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[colsWithoutNulls][KProperty.colsWithoutNulls]`() }` + * `df.`[`select`][DataFrame.select]` { DataSchemaType::myColumnGroup.`[`colsWithoutNulls`][KProperty.colsWithoutNulls]`() }` */ @Deprecated(DEPRECATED_ACCESS_API) @AccessApiOverload @@ -139,7 +139,7 @@ public interface WithoutNullsColumnsSelectionDsl { * @include [CommonWithoutNullsDocs] * @set [CommonWithoutNullsDocs.EXAMPLE] * - * `df.`[select][DataFrame.select]` { "pathTo"["myColGroup"].`[colsWithoutNulls][ColumnPath.colsWithoutNulls]`() }` + * `df.`[`select`][DataFrame.select]` { "pathTo"["myColGroup"].`[`colsWithoutNulls`][ColumnPath.colsWithoutNulls]`() }` */ public fun ColumnPath.colsWithoutNulls(): ColumnSet = columnGroup(this).colsWithoutNulls() } diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithTypeCastGenerator.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithTypeCastGenerator.kt index f6be5d28d9..2b96ab046f 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithTypeCastGenerator.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithTypeCastGenerator.kt @@ -43,7 +43,7 @@ public typealias Expression = String * A [TypeCastGenerator] can generate [Code] given an [Expression] that casts or converts * it to a predefined target type. * - * To create a [TypeCastGenerator] that, for instance, casts everything you pass to [Any?][Any]: + * To create a [TypeCastGenerator] that, for instance, casts everything you pass to [`Any?`][Any]: * ```kt * val myCastGenerator = TypeCastGenerator { expression -> "(\$expression as Any?)" } * diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt index 6527cb3b6c..1c51a3a51a 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/Marker.kt @@ -7,9 +7,9 @@ import kotlin.reflect.KClass /** * Which type of visibility the marker (generated class-like code declaration) * will have: - * - [INTERNAL][INTERNAL]: "internal" - * - [IMPLICIT_PUBLIC][IMPLICIT_PUBLIC]: "" - * - [EXPLICIT_PUBLIC][EXPLICIT_PUBLIC]: "public" + * - [`INTERNAL`][INTERNAL]: "internal" + * - [`IMPLICIT_PUBLIC`][IMPLICIT_PUBLIC]: "" + * - [`EXPLICIT_PUBLIC`][EXPLICIT_PUBLIC]: "public" */ public enum class MarkerVisibility { INTERNAL, diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnAccessor.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnAccessor.kt index 4536755c61..2ace96ad33 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnAccessor.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnAccessor.kt @@ -15,7 +15,7 @@ import kotlin.reflect.KProperty * * Can be created by [column], [columnGroup] or [frameColumn] delegates. * - * @param T Expected [type][DataColumn.type] of values in the column + * @param T Expected [`type`][DataColumn.type] of values in the column */ public interface ColumnAccessor : ColumnReference { diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt index 768c6858e6..e478cfa469 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ColumnReference.kt @@ -16,7 +16,7 @@ import kotlin.reflect.KProperty * Entity that can retrieve [DataColumn] from [DataFrame] or value from [DataRow]. * * Base interface for [DataColumn] and [ColumnAccessor]. - * @param C Expected [type][DataColumn.type] of values in the column + * @param C Expected [`type`][DataColumn.type] of values in the column */ public interface ColumnReference : SingleColumn { diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt index b422c5414f..b53fc09acd 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/SingleColumn.kt @@ -8,7 +8,7 @@ import org.jetbrains.kotlinx.dataframe.impl.columns.TransformableSingleColumn * ## SingleColumn * Entity that can be [resolved][resolveSingle] into a single [DataColumn]. * - * @param C Column [type][BaseColumn.type] of resolved column. + * @param C Column [`type`][BaseColumn.type] of resolved column. * @see [ColumnsResolver] * @see [TransformableColumnSet] * @see [TransformableSingleColumn] diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ValueColumn.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ValueColumn.kt index 6e925067a2..0425c329da 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ValueColumn.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/columns/ValueColumn.kt @@ -27,8 +27,8 @@ public interface ValueColumn : DataColumn { public override operator fun get(range: IntRange): DataColumn /** - * Changes column [type][BaseColumn.type]. - * Doesn't change column [values][BaseColumn.values]. + * Changes column [`type`][BaseColumn.type]. + * Doesn't change column [`values`][BaseColumn.values]. * * @param type New column [type][KType]. */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonMinMaxDocs.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonMinMaxDocs.kt index 179af5b776..18aaa3198d 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonMinMaxDocs.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonMinMaxDocs.kt @@ -89,8 +89,8 @@ internal interface CommonMinMaxDocs { * * The columns are selected with the [ColumnsForAggregateSelectionDsl] — an extension of the * Columns Selection DSL which lets you rename the result of a column with - * [into][ColumnsForAggregateSelectionDsl.into] and supply a - * [default][ColumnsForAggregateSelectionDsl.default] value for columns without any values. + * [`into`][ColumnsForAggregateSelectionDsl.into] and supply a + * [`default`][ColumnsForAggregateSelectionDsl.default] value for columns without any values. */ @ExcludeFromSources typealias AggregateColumnsSelectorSnippet = Nothing @@ -100,8 +100,8 @@ internal interface CommonMinMaxDocs { * * This operation does not produce a result right away. * Instead, it returns a [ReducedGroupBy] — an intermediate step which can be finished with - * [concat][ReducedGroupBy.concat] (to get a [DataFrame] with the selected rows), - * [values][ReducedGroupBy.values], or [into][ReducedGroupBy.into]. + * [`concat`][ReducedGroupBy.concat] (to get a [DataFrame] with the selected rows), + * [`values`][ReducedGroupBy.values], or [`into`][ReducedGroupBy.into]. * * See [GroupBy reducing][GroupByDocs.Reducing] for more details. */ @@ -113,7 +113,7 @@ internal interface CommonMinMaxDocs { * * This operation does not produce a result right away. * Instead, it returns a [ReducedPivot] — an intermediate step which can be finished with - * [values][ReducedPivot.values] or [with][ReducedPivot.with]. + * [`values`][ReducedPivot.values] or [`with`][ReducedPivot.with]. */ @ExcludeFromSources typealias ReducedPivotSnippet = Nothing @@ -123,7 +123,7 @@ internal interface CommonMinMaxDocs { * * This operation does not produce a result right away. * Instead, it returns a [ReducedPivotGroupBy] — an intermediate step which can be finished with - * [values][ReducedPivotGroupBy.values] or [with][ReducedPivotGroupBy.with]. + * [`values`][ReducedPivotGroupBy.values] or [`with`][ReducedPivotGroupBy.with]. */ @ExcludeFromSources typealias ReducedPivotGroupBySnippet = Nothing diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonTakeAndDropDocs.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonTakeAndDropDocs.kt index efe647a393..631b6395a1 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonTakeAndDropDocs.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonTakeAndDropDocs.kt @@ -25,13 +25,13 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnSet * ### Check out: [Grammar\] * * #### Examples: - * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { "my" `[in][String.contains]` it.`[name][DataColumn.name]` }.`[{@get [OPERATION]}][ColumnSet.{@get [OPERATION]}]`(5) }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][DataColumn.name]` }.`[{@get [OPERATION]}][ColumnSet.{@get [OPERATION]}]`(5) }` * - * `df.`[select][DataFrame.select]` { `[{@get [OPERATION]}][ColumnsSelectionDsl.{@get [OPERATION]}]`(1) }` + * `df.`[`select`][DataFrame.select]` { `[{@get [OPERATION]}][ColumnsSelectionDsl.{@get [OPERATION]}]`(1) }` * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[{@get [OPERATION]}Cols][SingleColumn.{@get [OPERATION]}Cols]`(2) }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[{@get [OPERATION]}Cols][SingleColumn.{@get [OPERATION]}Cols]`(2) }` * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[{@get [OPERATION]}Cols][String.{@get [OPERATION]}Cols]`(3) }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[{@get [OPERATION]}Cols][String.{@get [OPERATION]}Cols]`(3) }` * * #### Examples for this overload: * diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonTakeAndDropWhileDocs.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonTakeAndDropWhileDocs.kt index ccb8be896a..b3103cada6 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonTakeAndDropWhileDocs.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/CommonTakeAndDropWhileDocs.kt @@ -29,11 +29,11 @@ import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath * ### Check out: [Usage\] * * #### Examples: - * `df.`[select][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][DataColumn.name]` }.`[\`{@get [OPERATION]}While\`][ColumnSet.{@get [OPERATION]}While]` { "my" `[`in`][String.contains]` it.`[`name`][DataColumn.name]` } }` + * `df.`[`select`][DataFrame.select]` { `[`cols`][ColumnsSelectionDsl.cols]` { "my" `[`in`][String.contains]` it.`[`name`][DataColumn.name]` }.`[\`{@get [OPERATION]}While\`][ColumnSet.{@get [OPERATION]}While]` { "my" `[`in`][String.contains]` it.`[`name`][DataColumn.name]` } }` * - * `df.`[select][DataFrame.select]` { myColumnGroup.`[\`{@get [OPERATION]}While\`][SingleColumn.{@get [OPERATION]}ColsWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` + * `df.`[`select`][DataFrame.select]` { myColumnGroup.`[\`{@get [OPERATION]}While\`][SingleColumn.{@get [OPERATION]}ColsWhile]` { it.`[`any`][ColumnWithPath.any]` { it == "Alice" } } }` * - * `df.`[select][DataFrame.select]` { "myColumnGroup".`[\`{@get [OPERATION]}ColsWhile\`][String.{@get [OPERATION]}ColsWhile]` { it.`[`kind`][ColumnWithPath.kind]`() == `[`ColumnKind.Value`][ColumnKind.Value]` } }` + * `df.`[`select`][DataFrame.select]` { "myColumnGroup".`[\`{@get [OPERATION]}ColsWhile\`][String.{@get [OPERATION]}ColsWhile]` { it.`[`kind`][ColumnWithPath.kind]`() == `[`ColumnKind.Value`][ColumnKind.Value]` } }` * * #### Examples for this overload: * diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DslGrammarTemplateColumnsSelectionDsl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DslGrammarTemplateColumnsSelectionDsl.kt index 5feff5537d..1fdfe5969c 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DslGrammarTemplateColumnsSelectionDsl.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DslGrammarTemplateColumnsSelectionDsl.kt @@ -37,7 +37,7 @@ public interface DslGrammarTemplateColumnsSelectionDsl { * {@comment -------------------------------------------------------------------------------------------- } * {@get [DslGrammarTemplate.COLUMN_SET_PART] * {@include [LineBreak]} - * ### What can be called on a [ColumnSet][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]: + * ### What can be called on a [`ColumnSet`][org.jetbrains.kotlinx.dataframe.columns.ColumnSet]: * * {@include [LineBreak]} * {@include [ColumnSetRef]} diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt index 1adfe5816d..1864423379 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenColumn.kt @@ -31,9 +31,9 @@ internal interface ExpressionsGivenColumn { * * For example: * - * `df.`{@get [OPERATION]}` { `[mean][DataColumn.mean]`(skipNA = true) }` + * `df.`{@get [OPERATION]}` { `[`mean`][DataColumn.mean]`(skipNA = true) }` * - * `df.`{@get [OPERATION]}` { `[count][DataColumn.count]` { it > 10 } }` + * `df.`{@get [OPERATION]}` { `[`count`][DataColumn.count]` { it > 10 } }` * @include [SetDefaultOperationArg] */ typealias WithExample = Nothing diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt index da34de846c..178bf600f7 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenDataFrame.kt @@ -22,7 +22,7 @@ internal interface ExpressionsGivenDataFrame { * * For example: * - * {@get [OPERATION]}` { `[select][DataFrame.select]` { lastName } }` + * {@get [OPERATION]}` { `[`select`][DataFrame.select]` { lastName } }` */ typealias WithExample = Nothing } diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt index 656f7d8e0f..2fb868b839 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRow.kt @@ -19,11 +19,11 @@ import org.jetbrains.kotlinx.dataframe.RowValueExpression as DfRowValueExpressio * can occur in the following two types of operations: * * - Providing a new value for every selected cell given the row of that cell ({@include [RowExpressionLink]}), - * for instance in [map][DataFrame.map], [add][DataFrame.add], and [insert][DataFrame.insert] + * for instance in [`map`][DataFrame.map], [`add`][DataFrame.add], and [`insert`][DataFrame.insert] * (using [RowExpression][DfRowExpression]). * * - Providing a new value for every selected cell given the row of that cell and its previous value ({@include [RowValueExpressionLink]}), - * for instance in [update.with][Update.with], and [convert.notNull][Convert.notNull] + * for instance in [`update.with`][Update.with], and [`convert.notNull`][Convert.notNull] * (using [RowValueExpression][DfRowValueExpression]). * * NOTE: @@ -49,7 +49,7 @@ internal interface ExpressionsGivenRow { /** * [update with][org.jetbrains.kotlinx.dataframe.api.Update.with]-, * [convert with][org.jetbrains.kotlinx.dataframe.api.Convert.with]- - * and [add][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow] instead of [DataRow] as the DSL's receiver type. + * and [`add`][org.jetbrains.kotlinx.dataframe.api.add]-like expressions use [AddDataRow] instead of [DataRow] as the DSL's receiver type. * This is an extension to [RowValueExpression][DfRowValueExpression] and * [RowExpression][DfRowExpression] that provides access to * the modified/generated value of the preceding row ([AddDataRow.newValue]). diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt index c2c1d02100..db2fa794c6 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/ExpressionsGivenRowAndColumn.kt @@ -33,7 +33,7 @@ internal interface ExpressionsGivenRowAndColumn { * * `df.`{@get [OPERATION]}` { row, col ->` * - * {@include [Indent]}`row.age / col.`[mean][DataColumn.mean]`(skipNA = true)` + * {@include [Indent]}`row.age / col.`[`mean`][DataColumn.mean]`(skipNA = true)` * * `}` * diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt index f81ce5e6ef..f6bfb4fbc8 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NA.kt @@ -21,8 +21,8 @@ import org.jetbrains.kotlinx.dataframe.api.fillNA * * A [DataFrame] is considered `NA` if it has no rows or columns, so if it's empty. * - * You can also use [fillNA][fillNA] to replace `NAs` in certain columns with a given value or expression - * or [dropNA][dropNA] to drop rows with `NAs` in them. + * You can also use [`fillNA`][fillNA] to replace `NAs` in certain columns with a given value or expression + * or [`dropNA`][dropNA] to drop rows with `NAs` in them. * * For more information: {@include [DocumentationUrls.NanAndNa.NA]} * diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt index 4ca91fbc63..e2ff7dc38e 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/NaN.kt @@ -14,8 +14,8 @@ import org.jetbrains.kotlinx.dataframe.api.fillNaNs * [Floats][Float] or [Doubles][Double] can be represented as [Float.NaN] or [Double.NaN], respectively, * in cases where a mathematical operation is undefined, such as dividing by zero. * - * You can also use [fillNaNs][fillNaNs] to replace `NaNs` in certain columns with a given value or expression - * or [dropNaNs][dropNaNs] to drop rows with `NaNs` in them. + * You can also use [`fillNaNs`][fillNaNs] to replace `NaNs` in certain columns with a given value or expression + * or [`dropNaNs`][dropNaNs] to drop rows with `NaNs` in them. * * For more information: {@include [DocumentationUrls.NanAndNa.NaN]} * diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt index 5468b71490..49572dd526 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingColumns.kt @@ -98,11 +98,11 @@ internal interface SelectingColumns { * * #### For example: * - * {@get [RECEIVER]}`.`{@get [OPERATION]}` { length `[and][ColumnsSelectionDsl.and]` age }` + * {@get [RECEIVER]}`.`{@get [OPERATION]}` { length `[`and`][ColumnsSelectionDsl.and]` age }` * - * {@get [RECEIVER]}`.`{@get [OPERATION]}` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }` + * {@get [RECEIVER]}`.`{@get [OPERATION]}` { `[`cols`][ColumnsSelectionDsl.cols]`(1..5) }` * - * {@get [RECEIVER]}`.`{@get [OPERATION]}` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>() }` + * {@get [RECEIVER]}`.`{@get [OPERATION]}` { `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Double`][Double]`>() }` * * @include [SetDefaultOperationArg] * @include [SetDefaultReceiverArg] @@ -153,9 +153,9 @@ internal interface SelectingColumns { * * {@get [RECEIVER]}`.`{@get [OPERATION]}` { length }` * - * {@get [RECEIVER]}`.`{@get [OPERATION]}` { `[col][ColumnsSelectionDsl.col]`(1) }` + * {@get [RECEIVER]}`.`{@get [OPERATION]}` { `[`col`][ColumnsSelectionDsl.col]`(1) }` * - * {@get [RECEIVER]}`.`{@get [OPERATION]}` { `[colsOf][ColumnsSelectionDsl.colsOf]`<`[Double][Double]`>().`[first][ColumnsSelectionDsl.first]`() }` + * {@get [RECEIVER]}`.`{@get [OPERATION]}` { `[`colsOf`][ColumnsSelectionDsl.colsOf]`<`[`Double`][Double]`>().`[`first`][ColumnsSelectionDsl.first]`() }` * * @include [SetDefaultOperationArg] * @include [SetDefaultReceiverArg] diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt index 9cbc381db9..dbb0640356 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/SelectingRows.kt @@ -95,9 +95,9 @@ internal interface SelectingRows { * * For example: * - * `df.`{@get [FIRST_OPERATION]}` { `[index][index]`() % 2 == 0 }` + * `df.`{@get [FIRST_OPERATION]}` { `[`index`][index]`() % 2 == 0 }` * - * `df.`{@get [FIRST_OPERATION]}` { `[diff][diff]` { age } == 0 }` + * `df.`{@get [FIRST_OPERATION]}` { `[`diff`][diff]` { age } == 0 }` * @include [SetDefaultOperationArg] */ typealias WithExample = Nothing @@ -119,7 +119,7 @@ internal interface SelectingRows { * * `df.`{@get [FIRST_OPERATION]}` { length }.`{@get [SECOND_OPERATION]}` { it > 10.0 }` * - * `df.`{@get [FIRST_OPERATION]}` { `[cols][ColumnsSelectionDsl.cols]`(1..5) }.`{@get [SECOND_OPERATION]}` { `[index][index]`() > 4 && city != "Paris" }` + * `df.`{@get [FIRST_OPERATION]}` { `[`cols`][ColumnsSelectionDsl.cols]`(1..5) }.`{@get [SECOND_OPERATION]}` { `[`index`][index]`() > 4 && city != "Paris" }` * @include [SetDefaultOperationArg] */ typealias WithExample = Nothing diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/UnifyingNumbers.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/UnifyingNumbers.kt index 2617bd379e..0c03555b3a 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/UnifyingNumbers.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/UnifyingNumbers.kt @@ -27,7 +27,7 @@ import org.jetbrains.kotlinx.dataframe.impl.UnifiedNumberTypeOptions * * At the bottom of the graph is [Nothing]. * This can be interpreted as "no type" and can have no instance, - * while [Nothing?][Nothing] can only be `null`. + * while [`Nothing?`][Nothing] can only be `null`. */ public interface UnifyingNumbers { diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/snippets.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/snippets.kt index db71862f2f..1394490140 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/snippets.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/snippets.kt @@ -35,6 +35,6 @@ internal typealias ColumnPathCreationSnippet = Nothing * If you need to provide a custom [java.util.Locale], we recommend parsing * to a [java.time]-based class first by adjusting the parser options before converting it to [kotlinx.datetime]. * - * See also: [ParserOptions], [DataFrame.parser.dateTimeLibrary][GlobalParserOptions.dateTimeLibrary] + * See also: [ParserOptions], [`DataFrame.parser.dateTimeLibrary`][GlobalParserOptions.dateTimeLibrary] */ internal typealias KotlinxDateTimeLocaleSnippet = Nothing diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/topics.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/topics.kt index f6ce5994ce..a1f223dac7 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/topics.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/topics.kt @@ -34,7 +34,7 @@ import org.jetbrains.kotlinx.dataframe.DataFrame * |---------|---------|---------| * | `"a"` | `"b"` | `"c"` | * - * It is recommended to [rename][org.jetbrains.kotlinx.dataframe.api.rename] them + * It is recommended to [`rename`][org.jetbrains.kotlinx.dataframe.api.rename] them * to maintain clarity and improve code readability. */ internal typealias AutoRenamingColumnsInDataFrame = Nothing diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/TypeUtils.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/TypeUtils.kt index d4ae3dcf7e..1667384eb1 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/TypeUtils.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/TypeUtils.kt @@ -408,7 +408,7 @@ internal fun guessValueType( * For example: `[1, null, listOf(1, 2, 3)]` will become `List` instead of `Any?` * Note: this parameter is ignored if another [Collection] is present in the values. * @param allColsMakesRow if true, then, if all values are non-null columns, we assume - * that a column group should be created instead of a [DataColumn][DataColumn]`<`[AnyCol][AnyCol]`>`, + * that a column group should be created instead of a [`DataColumn`][DataColumn]`<`[`AnyCol`][AnyCol]`>`, * so the function will return [DataRow]. * @param unifyNumbers if true, then all number types encountered will be unified to the smallest possible * number-type that can hold all number values lossless in [values]. See [commonNumberClass]. @@ -669,7 +669,7 @@ internal fun Any.isBigNumber(): Boolean = this is BigInteger || this is BigDecim * * The [KClass] is determined by retrieving the runtime class of each element. * - * [Nothing::class][Nothing] is used for elements that are `null`. + * [`Nothing::class`][Nothing] is used for elements that are `null`. * * @return A set of [KClass] objects representing the runtime types of elements in the iterable. */ @@ -684,7 +684,7 @@ internal fun Iterable.classes(): Set> = * * This can be a heavy operation! * - * [typeOf()][nullableNothingType] is used for elements that are `null`. + * [`typeOf()`][nullableNothingType] is used for elements that are `null`. * * @return A set of [KType] objects corresponding to the star-projected runtime types of elements in the iterable. */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator.kt index 4746df815b..a4207dca8c 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator.kt @@ -159,7 +159,7 @@ internal fun Aggregator.aggregate(co /** * Gives the index of the aggregation result in the input [values], if it applies. * This is used for aggregators with an [AggregatorAggregationHandler] where - * [Value][Value]` == `[Return][Return], and where the result exists in the input. + * [`Value`][Value]` == `[`Return`][Return], and where the result exists in the input. * * Like for [SelectingAggregationHandler]. * @@ -176,7 +176,7 @@ internal fun Aggregator.ind /** * Gives the index of the aggregation result in the input [values], if it applies. * This is used for aggregators with an [AggregatorAggregationHandler] where - * [Value][Value]` == `[Return][Return], and where the result exists in the input. + * [`Value`][Value]` == `[`Return`][Return], and where the result exists in the input. * * Like for [SelectingAggregationHandler]. * @@ -214,7 +214,7 @@ internal typealias Reducer = Sequence.(valueType: KT /** * Type alias for a selector function where the type of the values is provided as [KType]. * - * It is expected that [Value][Value]` : `[Return][Return]` & `[Any][Any], and [Return][Return]` : `[Any?][Any]. + * It is expected that [`Value`][Value]` : `[`Return`][Return]` & `[`Any`][Any], and [`Return`][Return]` : `[`Any?`][Any]. * * Nulls have already been filtered out when this function is called. */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorAggregationHandler.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorAggregationHandler.kt index 87d149cd94..e7e13c9319 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorAggregationHandler.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorAggregationHandler.kt @@ -19,7 +19,7 @@ public interface AggregatorAggregationHandler * Base function of [Aggregator]. * * Aggregates the given values, taking [valueType] into account, - * filtering nulls (only if [valueType.type.isMarkedNullable][KType.isMarkedNullable]), + * filtering nulls (only if [`valueType.type.isMarkedNullable`][KType.isMarkedNullable]), * and computes a single resulting value. * * When the exact [valueType] is unknown, use [calculateValueType] or [aggregateCalculatingValueType]. @@ -68,7 +68,7 @@ public interface AggregatorAggregationHandler /** * Function that can give the index of the aggregation result in the input [values], if it applies. * This is used for [AggregatorAggregationHandlers][AggregatorAggregationHandler] where - * [Value][Value]` == `[Return][Return], and where the result exists in the input. + * [`Value`][Value]` == `[`Return`][Return], and where the result exists in the input. * * Like for [SelectingAggregationHandler]. * diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorInputHandler.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorInputHandler.kt index 73c0dcde4b..70cedc1436 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorInputHandler.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/AggregatorInputHandler.kt @@ -27,8 +27,8 @@ public interface AggregatorInputHandler : Agg /** * Preprocesses the input values before aggregation. - * It's expected that this function converts [values] to the right [valueType.kType][ValueType.kType] - * if [valueType.needsFullConversion][ValueType.needsFullConversion]. + * It's expected that this function converts [values] to the right [`valueType.kType`][ValueType.kType] + * if [`valueType.needsFullConversion`][ValueType.needsFullConversion]. * * @return A pair of the preprocessed values and the (potentially new) type of the values. */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/aggregationHandlers/HybridAggregationHandler.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/aggregationHandlers/HybridAggregationHandler.kt index 8bd8eebd2d..464628d5e6 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/aggregationHandlers/HybridAggregationHandler.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/aggregationHandlers/HybridAggregationHandler.kt @@ -49,7 +49,7 @@ internal class HybridAggregationHandler( * Base function of [Aggregator]. * * Aggregates the given values, taking [valueType] into account, - * filtering nulls (only if [valueType.type.isMarkedNullable][KType.isMarkedNullable]), + * filtering nulls (only if [`valueType.type.isMarkedNullable`][KType.isMarkedNullable]), * and computes a single resulting value. * * When the exact [valueType] is unknown, use [calculateValueType] or [aggregateCalculatingValueType]. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/aggregationHandlers/ReducingAggregationHandler.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/aggregationHandlers/ReducingAggregationHandler.kt index 1ec205fd05..918756af09 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/aggregationHandlers/ReducingAggregationHandler.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/aggregationHandlers/ReducingAggregationHandler.kt @@ -29,7 +29,7 @@ internal class ReducingAggregationHandler( * Base function of [Aggregator]. * * Aggregates the given values, taking [valueType] into account, - * filtering nulls (only if [valueType.type.isMarkedNullable][KType.isMarkedNullable]), + * filtering nulls (only if [`valueType.type.isMarkedNullable`][KType.isMarkedNullable]), * and computes a single resulting value. * * When the exact [valueType] is unknown, use [calculateValueType] or [aggregateCalculatingValueType]. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/aggregationHandlers/SelectingAggregationHandler.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/aggregationHandlers/SelectingAggregationHandler.kt index b845a79651..3c9ba5bb12 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/aggregationHandlers/SelectingAggregationHandler.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/aggregationHandlers/SelectingAggregationHandler.kt @@ -45,7 +45,7 @@ internal class SelectingAggregationHandler( /** * Aggregates the data in the multiple given columns and computes a single resulting value. * - * This function calls [aggregator][aggregator] [.aggregateSingleColumn()][Aggregator.aggregateSingleColumn] + * This function calls [`aggregator`][aggregator] [.aggregateSingleColumn()][Aggregator.aggregateSingleColumn] * on each column and then [stepTwo] [.aggregateSequence()][Aggregator.aggregateSequence] on the results. */ override fun aggregateMultipleColumns(columns: Sequence>): Return { diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt index 75a854e04c..4b467eba3a 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt @@ -89,7 +89,7 @@ internal interface StringParser { * to get the actual [string parser function][ParserFunction] that * can parse [String] to [T] (or `null` if unsucessful). * - * If the returned [ParserFunction][ParserFunction]` == `[SKIP_PARSER][SKIP_PARSER], the function + * If the returned [`ParserFunction`][ParserFunction]` == `[`SKIP_PARSER`][SKIP_PARSER], the function * will always return `null` for the current [global parser options][Parsers] and given arguments * and can thus be skipped. */ @@ -166,7 +166,7 @@ internal val SKIP_PARSER: ParserFunction = parseBy { null } /** * Central implementation for [GlobalParserOptions]. * - * Can be obtained by a user by calling [DataFrame.parser][DataFrame.Companion.parser]. + * Can be obtained by a user by calling [`DataFrame.parser`][DataFrame.Companion.parser]. * * Defaults are set by [resetToDefault]. */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt index 85ea021281..ef4f7018e1 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt @@ -13,8 +13,8 @@ import org.jetbrains.kotlinx.dataframe.columns.SingleColumn * This type of [ColumnsResolver] can be [transformed][transformResolve] before being resolved. * * This is especially useful for calls like - * [colsInternal { }][ColumnsResolver.colsInternal].[atAnyDepthImpl()][atAnyDepthImpl], - * where [atAnyDepthImpl][atAnyDepthImpl] modifies the [ColumnSet][ColumnsResolver] + * [colsInternal { }][ColumnsResolver.colsInternal].[`atAnyDepthImpl()`][atAnyDepthImpl], + * where [`atAnyDepthImpl`][atAnyDepthImpl] modifies the [`ColumnSet`][ColumnsResolver] * that [colsInternal { }][ColumnsResolver.colsInternal] operates on to include ALL columns, including those inside * column groups, before it's evaluated. * @@ -35,8 +35,8 @@ internal interface TransformableColumnSet : ColumnSet { * This type of [SingleColumn] can be [transformed][transformResolveSingle] before being resolved. * * This is especially useful for calls like - * [singleInternal { }][ColumnsResolver.singleInternal].[atAnyDepthImpl()][atAnyDepthImpl], - * where [atAnyDepthImpl][atAnyDepthImpl] modifies the [SingleColumn] + * [singleInternal { }][ColumnsResolver.singleInternal].[`atAnyDepthImpl()`][atAnyDepthImpl], + * where [`atAnyDepthImpl`][atAnyDepthImpl] modifies the [SingleColumn] * that [singleInternal { }][ColumnsResolver.singleInternal] operates on to include ALL columns, including those inside * column groups, before it's evaluated. * @@ -53,8 +53,8 @@ internal interface TransformableSingleColumn : SingleColumn { /** * ## Columns Resolver Transformer. - * This contains implementations for both [transform][ColumnSet.transform] and - * [transformSingle][SingleColumn.transformSingle] and can be passed around. + * This contains implementations for both [`transform`][ColumnSet.transform] and + * [`transformSingle`][SingleColumn.transformSingle] and can be passed around. */ @PublishedApi internal interface ColumnsResolverTransformer { diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt index d1bc8262d6..4228697f75 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt @@ -196,7 +196,7 @@ internal fun Array.toNumberColumns() = toColumnsSetOf() * For example: `[1, null, listOf(1, 2, 3)]` will become `[[1], [], [1, 2, 3]]`. * Note: this parameter is ignored if another [Collection] is present in the values. * @param allColsMakesColGroup if `true`, then, if all values are non-null same-sized columns, - * a column group will be created instead of a [DataColumn][DataColumn]`<`[AnyCol][AnyCol]`>`. + * a column group will be created instead of a [`DataColumn`][DataColumn]`<`[`AnyCol`][AnyCol]`>`. * @param unifyNumbers if `true`, then all numbers encountered in [values] will be converted to the smallest possible * number-type that can hold all the values lossless. Unsigned numbers are not supported. See [UnifyingNumbers]. * For example, if the values are `[1, 2f, 3.0]`, then all values will be converted to [Double]. diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/FastDoubleParser.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/FastDoubleParser.kt index d9dd0c52a4..14e839c3b2 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/FastDoubleParser.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/FastDoubleParser.kt @@ -22,9 +22,9 @@ private val logger = KotlinLogging.logger {} * fast double parser library, [FastDoubleParser](https://github.com/wrandelshofer/FastDoubleParser). * If not, or if it fails, it will use [NumberFormat] to parse the input. * - * The [locale][locale] used by the double parser is defined like: + * The [`locale`][locale] used by the double parser is defined like: * - * [parserOptions][parserOptions]`?.`[locale][ParserOptions.locale]` ?: `[Parsers.locale][Parsers.locale]` :? `[Locale.getDefault()][Locale.getDefault] + * [`parserOptions`][parserOptions]`?.`[`locale`][ParserOptions.locale]` ?: `[`Parsers.locale`][Parsers.locale]` :? `[`Locale.getDefault()`][Locale.getDefault] * * [FastDoubleParser] has a fallback mechanism; In practice, this means it can recognize symbols and notations * of any locale recognized by Java as long as that symbol does not conflict with the given locale. @@ -36,7 +36,7 @@ private val logger = KotlinLogging.logger {} * Public, so it can be used in other modules. * * @param parserOptions can be supplied to configure the parser. - * If `null`, the global parser options ([DataFrame.parser][DataFrame.Companion.parser]) will be used. + * If `null`, the global parser options ([`DataFrame.parser`][DataFrame.Companion.parser]) will be used. * We'll only use [ParserOptions.locale] and [ParserOptions.useFastDoubleParser]. */ @Suppress("ktlint:standard:comment-wrapping") diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/DataFrameSchemaImpl.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/DataFrameSchemaImpl.kt index b300a1b62d..bb3118bf75 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/DataFrameSchemaImpl.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/DataFrameSchemaImpl.kt @@ -58,7 +58,7 @@ public class DataFrameSchemaImpl(override val columns: Map * [this schema][this] has the same columns **in the same order** as the [other schema][other]. * The types must also match exactly. * - * Use [compare][DataFrameSchema.compare] it the order does not matter and + * Use [`compare`][DataFrameSchema.compare] it the order does not matter and * for other comparison options. * * @see [DataFrameSchema.compare] diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/basicStats.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/basicStats.kt index 3d5374faf5..06e470963a 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/basicStats.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/math/basicStats.kt @@ -9,7 +9,7 @@ internal data class BasicStats(val count: Int, val mean: Double, val variance: D /** * Creates [BasicStats] instance for [this] sequence. * - * This contains the [count][BasicStats.count], [mean][BasicStats.mean], and [variance][BasicStats.variance] and + * This contains the [`count`][BasicStats.count], [`mean`][BasicStats.mean], and [`variance`][BasicStats.variance] and * can be used to efficiently calculate the [standard deviation][std]. */ internal fun Sequence.calculateBasicStatsOrNull(skipNaN: Boolean = skipNaNDefault): BasicStats? { From 118bdccf07d5ca4ddbd818cffbcfcf189c6e3267 Mon Sep 17 00:00:00 2001 From: Jolan Rensen Date: Tue, 11 Aug 2026 17:19:36 +0200 Subject: [PATCH 3/6] Used claude to update code spans in kdocs in all modules except :core --- .../buildExampleProjects/generateTestCase.kt | 2 +- .../TestBuildingExampleProjects.kt | 2 +- .../documentationCsv/CommonReadDelimDocs.kt | 12 ++--- .../documentationCsv/CommonWriteDelimDocs.kt | 6 +-- .../dataframe/documentationCsv/DelimParams.kt | 18 +++---- .../kotlinx/dataframe/impl/io/readDelim.kt | 4 +- .../kotlinx/dataframe/io/db/DbType.kt | 14 ++--- .../kotlinx/dataframe/io/db/DuckDb.kt | 8 +-- .../io/db/JdbcToDataFrameConverter.kt | 2 +- .../kotlinx/dataframe/io/db/Sqlite.kt | 8 +-- .../kotlinx/dataframe/io/readJdbc.kt | 52 +++++++++---------- .../jetbrains/kotlinx/dataframe/io/json.kt | 2 +- .../examples/exposed/compatibilityLayer.kt | 8 +-- .../dataframe/examples/exposed/tables.kt | 2 +- .../dataframe/examples/spark/typedDataset.kt | 4 +- .../examples/exposed/compatibilityLayer.kt | 8 +-- .../dataframe/examples/exposed/tables.kt | 2 +- .../dataframe/examples/spark/typedDataset.kt | 4 +- .../dataframe/samples/guides/HsqldbGuide.kt | 4 +- 19 files changed, 81 insertions(+), 81 deletions(-) diff --git a/build-logic/src/main/kotlin/dfbuild/buildExampleProjects/generateTestCase.kt b/build-logic/src/main/kotlin/dfbuild/buildExampleProjects/generateTestCase.kt index 5c7893e53b..1fd70a393f 100644 --- a/build-logic/src/main/kotlin/dfbuild/buildExampleProjects/generateTestCase.kt +++ b/build-logic/src/main/kotlin/dfbuild/buildExampleProjects/generateTestCase.kt @@ -14,7 +14,7 @@ typealias Code = String * * This implementation of [dfbuild.buildExampleProjects.TestBuildingExampleProjects] * should be written into 'build/generated/testBuildingExamples' and included in the - * 'testBuildingExamples' [SourceSet][org.gradle.api.tasks.SourceSet]. + * 'testBuildingExamples' [`SourceSet`][org.gradle.api.tasks.SourceSet]. */ @Language("kt") fun generateTestCase( diff --git a/build-logic/src/testBuildingExamples/kotlin/dfbuild/buildExampleProjects/TestBuildingExampleProjects.kt b/build-logic/src/testBuildingExamples/kotlin/dfbuild/buildExampleProjects/TestBuildingExampleProjects.kt index b922e2c76a..4a163f2377 100644 --- a/build-logic/src/testBuildingExamples/kotlin/dfbuild/buildExampleProjects/TestBuildingExampleProjects.kt +++ b/build-logic/src/testBuildingExamples/kotlin/dfbuild/buildExampleProjects/TestBuildingExampleProjects.kt @@ -17,7 +17,7 @@ import java.io.File * Each folder needs to have its own test class so the tests can run in parallel. * * This class, as well as the generated tests, are automatically registered as - * the 'testBuildingExamples' [SourceSet][org.gradle.api.tasks.SourceSet] by the + * the 'testBuildingExamples' [`SourceSet`][org.gradle.api.tasks.SourceSet] by the * `dfbuild.buildExampleProjects` convention plugin. */ @Suppress("unused") diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentationCsv/CommonReadDelimDocs.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentationCsv/CommonReadDelimDocs.kt index e7abd90ccc..d134694f7f 100644 --- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentationCsv/CommonReadDelimDocs.kt +++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentationCsv/CommonReadDelimDocs.kt @@ -15,7 +15,7 @@ import java.net.URL /** * ### Read $[FILE_TYPE_TITLE] $[DATA_TITLE] to [DataFrame] * - * Reads any $[FILE_TYPE] $[DATA] to a [DataFrame][DataFrame]. + * Reads any $[FILE_TYPE] $[DATA] to a [`DataFrame`][DataFrame]. * * @include [org.jetbrains.kotlinx.dataframe.documentation.AutoRenameInputSnippet] * @@ -26,19 +26,19 @@ import java.net.URL * The integration is built upon {@include [DocumentationUrls.Deephaven]}. * * ##### Similar Functions - * With the overloads of $[FUNCTION_LINK]`()`, you can read any $[FILE_TYPE] by [File][File], - * [Path][java.nio.file.Path], [URL][URL], or [InputStream][InputStream]. + * With the overloads of $[FUNCTION_LINK]`()`, you can read any $[FILE_TYPE] by [`File`][File], + * [`Path`][java.nio.file.Path], [`URL`][URL], or [`InputStream`][InputStream]. * Reading by file path or URL can also be done by passing a [String]. * * For example, $[FUNCTION_LINK]`("input.$[CommonReadDelimDocs.FILE_EXTENSION]")` or with some options: * * $[FUNCTION_LINK]`(` * - * {@include [Indent]}`file = `[File][File]`("input.$[CommonReadDelimDocs.FILE_EXTENSION]"),` + * {@include [Indent]}`file = `[`File`][File]`("input.$[CommonReadDelimDocs.FILE_EXTENSION]"),` * - * {@include [Indent]}`parserOptions = `[ParserOptions][org.jetbrains.kotlinx.dataframe.api.ParserOptions]`(locale = `[Locale][java.util.Locale]`.`[US][java.util.Locale.US]`),` + * {@include [Indent]}`parserOptions = `[`ParserOptions`][org.jetbrains.kotlinx.dataframe.api.ParserOptions]`(locale = `[`Locale`][java.util.Locale]`.`[`US`][java.util.Locale.US]`),` * - * {@include [Indent]}`colTypes = `[mapOf][mapOf]`("a" `[to][to]` `[ColType][ColType]`.`[Int][ColType.Int]`, `[ColType][ColType]`.`[DEFAULT][ColType.DEFAULT]` `[to][to]` `[ColType][ColType]`.`[String][ColType.String]`),` + * {@include [Indent]}`colTypes = `[`mapOf`][mapOf]`("a" `[`to`][to]` `[`ColType`][ColType]`.`[`Int`][ColType.Int]`, `[`ColType`][ColType]`.`[`DEFAULT`][ColType.DEFAULT]` `[`to`][to]` `[`ColType`][ColType]`.`[`String`][ColType.String]`),` * * {@include [Indent]}`readLines = 1000L,` * diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentationCsv/CommonWriteDelimDocs.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentationCsv/CommonWriteDelimDocs.kt index 548b0368df..89405dc650 100644 --- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentationCsv/CommonWriteDelimDocs.kt +++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentationCsv/CommonWriteDelimDocs.kt @@ -11,7 +11,7 @@ import java.io.File /** * ### $[WRITE_OR_CONVERT] [DataFrame] to $[FILE_TYPE_TITLE] $[DATA_TITLE] * - * ${[WRITE_OR_CONVERT]}s \[this\]\[this\] [DataFrame][DataFrame] to a $[FILE_TYPE] $[DATA]. + * ${[WRITE_OR_CONVERT]}s \[this\]\[this\] [`DataFrame`][DataFrame] to a $[FILE_TYPE] $[DATA]. * * Parameters you can use to customize the process include, for instance, \[delimiter\], * \[includeHeader\], \[quoteMode\], and \[headerComments\]. @@ -20,12 +20,12 @@ import java.io.File * The integration is built upon {@include [DocumentationUrls.ApacheCsv]}. * * ##### Similar Functions - * With overloads of $[FUNCTION_LINK]`()`, you can write $[FILE_TYPE] to [File][File], [Path][java.nio.file.Path], + * With overloads of $[FUNCTION_LINK]`()`, you can write $[FILE_TYPE] to [`File`][File], [`Path`][java.nio.file.Path], * [Appendable], or [String]. * * For example, $[FUNCTION_LINK]`("output.$[CommonWriteDelimDocs.FILE_EXTENSION]")` * - * or $[FUNCTION_LINK]`(`[File][File]`("output.$[CommonWriteDelimDocs.FILE_EXTENSION]"), quoteMode = `[QuoteMode.ALL][ALL]`)` + * or $[FUNCTION_LINK]`(`[`File`][File]`("output.$[CommonWriteDelimDocs.FILE_EXTENSION]"), quoteMode = `[`QuoteMode.ALL`][ALL]`)` * * Converting to a [String] can be done like this: * diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentationCsv/DelimParams.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentationCsv/DelimParams.kt index acd73bbccc..2a70afd879 100644 --- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentationCsv/DelimParams.kt +++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentationCsv/DelimParams.kt @@ -22,28 +22,28 @@ internal object DelimParams { /** * @param path The file path to read. * Use [charset\] to specify the encoding. - * Can also be compressed as `.gz` or `.zip`, see [Compression][Compression]. + * Can also be compressed as `.gz` or `.zip`, see [`Compression`][Compression]. */ typealias PATH_READ = Nothing /** * @param file The file to read. * Use [charset\] to specify the encoding. - * Can also be compressed as `.gz` or `.zip`, see [Compression][Compression]. + * Can also be compressed as `.gz` or `.zip`, see [`Compression`][Compression]. */ typealias FILE_READ = Nothing /** * @param url The URL from which to fetch the data. * Use [charset\] to specify the encoding. - * Can also be compressed as `.gz` or `.zip`, see [Compression][Compression]. + * Can also be compressed as `.gz` or `.zip`, see [`Compression`][Compression]. */ typealias URL_READ = Nothing /** * @param fileOrUrl The file path or URL to read the data from. * Use [charset\] to specify the encoding. - * Can also be compressed as `.gz` or `.zip`, see [Compression][Compression]. + * Can also be compressed as `.gz` or `.zip`, see [`Compression`][Compression]. */ typealias FILE_OR_URL_READ = Nothing @@ -136,8 +136,8 @@ internal object DelimParams { * If supplied for a certain column name (inferred from data or given by \[header\]), * the parser will parse the column with the specified name as the specified type, else it will infer the type. * - * e.g. `colTypes = `[mapOf][mapOf]`("colName" `[to][to]` `[ColType][ColType]`.`[Int][ColType.Int]`)`. - * You can also set [ColType][ColType]`.`[DEFAULT][ColType.DEFAULT]` `[to][to]` `[ColType][ColType]`.X` + * e.g. `colTypes = `[`mapOf`][mapOf]`("colName" `[`to`][to]` `[`ColType`][ColType]`.`[`Int`][ColType.Int]`)`. + * You can also set [`ColType`][ColType]`.`[`DEFAULT`][ColType.DEFAULT]` `[`to`][to]` `[`ColType`][ColType]`.X` * to set a _default_ column type, like [ColType.String]. */ val COL_TYPES: Map = emptyMap() @@ -163,12 +163,12 @@ internal object DelimParams { * Can configure locale, date format, double parsing, skipping types, etc. * * If [parserOptions\] or any of the arguments are `null`, the global parser configuration - * ([DataFrame.parser][DataFrame.Companion.parser]) will be queried. + * ([`DataFrame.parser`][DataFrame.Companion.parser]) will be queried. * * The only exceptions are: - * - [nullStrings][ParserOptions.nullStrings], which, if `null`, + * - [`nullStrings`][ParserOptions.nullStrings], which, if `null`, * will take the global setting + {@include [DefaultNullStringsContentLink]}. - * - [skipTypes][ParserOptions.skipTypes], which will always add [typesDeephavenAlreadyParses] to + * - [`skipTypes`][ParserOptions.skipTypes], which will always add [typesDeephavenAlreadyParses] to * the given types or the global setting. */ val PARSER_OPTIONS: ParserOptions? = null diff --git a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readDelim.kt b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readDelim.kt index 34bf7aab0d..7756626c58 100644 --- a/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readDelim.kt +++ b/dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/readDelim.kt @@ -292,7 +292,7 @@ private fun CsvSpecs.Builder.skipLines(takeHeaderFromCsv: Boolean, skipLines: Lo * * - if no [colTypes] are given * - let deephaven use all its [default parsers][Parsers.DEFAULT] minus [Parsers.DATETIME] - * - subtract parsers of [skipTypes][ParserOptions.skipTypes] if those are supplied + * - subtract parsers of [`skipTypes`][ParserOptions.skipTypes] if those are supplied * - if [colTypes] are supplied * - if [ColType.DEFAULT] is among the values * - set the parser for each supplied column+colType @@ -300,7 +300,7 @@ private fun CsvSpecs.Builder.skipLines(takeHeaderFromCsv: Boolean, skipLines: Lo * - if [ColType.DEFAULT] is not among the values * - set the parser for each supplied column+coltype * - let deephaven use all its [default parsers][Parsers.DEFAULT] minus [Parsers.DATETIME] - * - subtract parsers of [skipTypes][ParserOptions.skipTypes] if those are supplied + * - subtract parsers of [`skipTypes`][ParserOptions.skipTypes] if those are supplied * * We will not use [Deephaven's DateTime parser][Parsers.DATETIME]. * This is done to avoid different behavior compared to [DataFrame.parse]; diff --git a/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/DbType.kt b/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/DbType.kt index 8b8c84295d..04f337363d 100644 --- a/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/DbType.kt +++ b/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/DbType.kt @@ -453,11 +453,11 @@ public abstract class DbType(public val dbTypeInJdbcUrl: String) { * adhering to [targetColumnSchema]. * * @param [D] the type of the values after preprocessing - * @param [P] the type of the resulting [DataColumn][DataColumn]`<`[P][P]`>`, [targetColumnSchema] + * @param [P] the type of the resulting [`DataColumn`][DataColumn]`<`[`P`][P]`>`, [targetColumnSchema] * @param [name] the name of the column * @param [values] the ([preprocessed][preprocessValue]) values to put in the column * @param [tableColumnMetadata] all information we have about the column - * @param [targetColumnSchema] the schema of the column [DataColumn][DataColumn]`<`[P][P]`>`, + * @param [targetColumnSchema] the schema of the column [`DataColumn`][DataColumn]`<`[`P`][P]`>`, * as determined by [getTargetColumnSchema] * @param [inferNullability] whether to infer nullability from the runtime values (this is more expensive), * as opposed to using the nullability information from the [targetColumnSchema] @@ -484,16 +484,16 @@ public abstract class DbType(public val dbTypeInJdbcUrl: String) { } /** - * Helper function to convert [this] list of values to a [DataColumn][DataColumn]`<`[P][P]`>`. + * Helper function to convert [this] list of values to a [`DataColumn`][DataColumn]`<`[`P`][P]`>`. * * **NOTE:** While this function can handle - * [targetColumnSchema][targetColumnSchema]` = `[ColumnSchema.Group][ColumnSchema.Group], - * and [this] being a [List][List]`<`[`DataRow<*>`][DataRow]`>`, + * [`targetColumnSchema`][targetColumnSchema]` = `[`ColumnSchema.Group`][ColumnSchema.Group], + * and [this] being a [`List`][List]`<`[`DataRow<*>`][DataRow]`>`, * this should generally be avoided to circumvent creating `n` [data rows][DataRow], * (which essentially are `n` single-row [dataframes][DataFrame]). * - * Instead, use [preprocessValue][preprocessValue] to convert to [Map][Map]`<`[String][String]`, `[Any?][Any]`>` - * and then use the more efficient [Iterable>.toDataFrame()][Iterable.toDataFrame] in [buildDataColumn]: + * Instead, use [`preprocessValue`][preprocessValue] to convert to [`Map`][Map]`<`[`String`][String]`, `[`Any?`][Any]`>` + * and then use the more efficient [`Iterable>.toDataFrame()`][Iterable.toDataFrame] in [buildDataColumn]: * ```kt * (values as List>) * .toDataFrame() diff --git a/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/DuckDb.kt b/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/DuckDb.kt index 702ee13ed1..62f81e8dab 100644 --- a/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/DuckDb.kt +++ b/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/DuckDb.kt @@ -402,8 +402,8 @@ public object DuckDb : AdvancedDbType("duckdb") { /** * How to filter out system tables from user-created ones when using - * [DataFrame.readAllSqlTables][DataFrame.Companion.readAllSqlTables] and - * [DataFrameSchema.readAllSqlTables][org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema.Companion.readAllSqlTables]. + * [`DataFrame.readAllSqlTables`][DataFrame.Companion.readAllSqlTables] and + * [`DataFrameSchema.readAllSqlTables`][org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema.Companion.readAllSqlTables]. * * The names of these can sometimes be found in the specific JDBC integration. */ @@ -414,8 +414,8 @@ public object DuckDb : AdvancedDbType("duckdb") { /** * How to retrieve the correct table metadata when using - * [DataFrame.readAllSqlTables][DataFrame.Companion.readAllSqlTables] and - * [DataFrameSchema.readAllSqlTables][org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema.Companion.readAllSqlTables]. + * [`DataFrame.readAllSqlTables`][DataFrame.Companion.readAllSqlTables] and + * [`DataFrameSchema.readAllSqlTables`][org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema.Companion.readAllSqlTables]. * The names of these can be found in the [DatabaseMetaData] implementation of the DuckDB JDBC integration. */ override fun buildTableMetadata(tables: ResultSet): TableMetadata = diff --git a/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/JdbcToDataFrameConverter.kt b/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/JdbcToDataFrameConverter.kt index 8443d7ed2e..8c21f53bca 100644 --- a/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/JdbcToDataFrameConverter.kt +++ b/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/JdbcToDataFrameConverter.kt @@ -21,7 +21,7 @@ public typealias AnyJdbcToDataFrameConverter = JdbcToDataFrameConverter<*, *, *> * * @param J the type of the value coming from the JDBC driver, [expectedJdbcType]. * @param D the type of the column values after preprocessing, [preprocessedValueType]. Will be equal to [J] if [valuePreprocessor] is `null`. - * @param P the type of the column values after postprocessing, comparable to [DataColumn][DataColumn]`<`[P][P]`>` of [targetSchema]. + * @param P the type of the column values after postprocessing, comparable to [`DataColumn`][DataColumn]`<`[`P`][P]`>` of [targetSchema]. * Will be equal to [D] if [columnBuilder] is `null`. * * @property targetSchema the target schema of the column after running the optional diff --git a/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/Sqlite.kt b/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/Sqlite.kt index 778bd02539..38e6555ced 100644 --- a/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/Sqlite.kt +++ b/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/db/Sqlite.kt @@ -29,7 +29,7 @@ import java.time.LocalTime as JavaLocalTime * * The type parameter [T] (and [expectedType] — this type as [KType]) is the **storage-class type** of the column * — the actual class of - * values returned by [java.sql.ResultSet.getObject][ResultSet.getObject] for that column. + * values returned by [`java.sql.ResultSet.getObject`][ResultSet.getObject] for that column. * Used as a result of [DbType.getExpectedJdbcType]. * The Xerial SQLite JDBC driver's `getObject(int)` returns exactly one of the following, chosen * from the runtime storage class of the value (not the declared column type): @@ -585,10 +585,10 @@ public class Sqlite( /** * Builds a [Sqlite] with custom type converters registered via a [SqliteCustomConvertersBuilder] DSL block. * - * * use [forType][SqliteCustomConvertersBuilder.forType] to register a converter + * * use [`forType`][SqliteCustomConvertersBuilder.forType] to register a converter * keyed by the declared SQL type name (as written in `CREATE TABLE`); - * * use [forColumn][SqliteCustomConvertersBuilder.forColumn] to register a converter keyed by column name - * (takes precedence over [forType][SqliteCustomConvertersBuilder.forType] for the named column). + * * use [`forColumn`][SqliteCustomConvertersBuilder.forColumn] to register a converter keyed by column name + * (takes precedence over [`forType`][SqliteCustomConvertersBuilder.forType] for the named column). * * Both DSL functions accept two generic type parameters: * - `T` — the storage class of the raw stored value [String], [Int], [Long], [Double], diff --git a/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readJdbc.kt b/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readJdbc.kt index 1efc51526a..0b921040d4 100644 --- a/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readJdbc.kt +++ b/dataframe-jdbc/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/readJdbc.kt @@ -534,26 +534,26 @@ public fun DataSource.readDataFrame( } /** - * Reads the data from a [ResultSet][java.sql.ResultSet] and converts it into a [DataFrame]. + * Reads the data from a [`ResultSet`][java.sql.ResultSet] and converts it into a [DataFrame]. * * @include [org.jetbrains.kotlinx.dataframe.documentation.AutoRenameInputSnippet] * - * A [ResultSet][java.sql.ResultSet] object maintains a cursor pointing to its current row of data. + * A [`ResultSet`][java.sql.ResultSet] object maintains a cursor pointing to its current row of data. * By default, a ResultSet object is not updatable and has a cursor that can only move forward. * Therefore, you can iterate through it only once, from the first row to the last row. * - * For more details, refer to the official Java documentation on [ResultSet][java.sql.ResultSet]. + * For more details, refer to the official Java documentation on [`ResultSet`][java.sql.ResultSet]. * - * NOTE: Reading from the [ResultSet][java.sql.ResultSet] could potentially change its state. + * NOTE: Reading from the [`ResultSet`][java.sql.ResultSet] could potentially change its state. * - * @param [resultSet] the [ResultSet][java.sql.ResultSet] containing the data to read. + * @param [resultSet] the [`ResultSet`][java.sql.ResultSet] containing the data to read. * Its state may be altered after the read operation. * @param [dbType] the type of database that the [ResultSet] belongs to. - * @param [limit] the maximum number of rows to read from the [ResultSet][java.sql.ResultSet]. + * @param [limit] the maximum number of rows to read from the [`ResultSet`][java.sql.ResultSet]. * `null` (default) means no limit - all available rows will be fetched * or positive integer (e.g., `100`) - fetch at most that many rows * @param [inferNullability] indicates how the column nullability should be inferred. - * @return the DataFrame generated from the [ResultSet][java.sql.ResultSet] data. + * @return the DataFrame generated from the [`ResultSet`][java.sql.ResultSet] data. * * @see [java.sql.ResultSet] */ @@ -569,24 +569,24 @@ public fun DataFrame.Companion.readResultSet( } /** - * Reads the data from a [ResultSet][java.sql.ResultSet] and converts it into a [DataFrame]. + * Reads the data from a [`ResultSet`][java.sql.ResultSet] and converts it into a [DataFrame]. * * @include [org.jetbrains.kotlinx.dataframe.documentation.AutoRenameInputSnippet] * - * A [ResultSet][java.sql.ResultSet] object maintains a cursor pointing to its current row of data. + * A [`ResultSet`][java.sql.ResultSet] object maintains a cursor pointing to its current row of data. * By default, a ResultSet object is not updatable and has a cursor that can only move forward. * Therefore, you can iterate through it only once, from the first row to the last row. * - * For more details, refer to the official Java documentation on [ResultSet][java.sql.ResultSet]. + * For more details, refer to the official Java documentation on [`ResultSet`][java.sql.ResultSet]. * - * NOTE: Reading from the [ResultSet][java.sql.ResultSet] could potentially change its state. + * NOTE: Reading from the [`ResultSet`][java.sql.ResultSet] could potentially change its state. * * @param [dbType] the type of database that the [ResultSet] belongs to. - * @param [limit] the maximum number of rows to read from the [ResultSet][java.sql.ResultSet]. + * @param [limit] the maximum number of rows to read from the [`ResultSet`][java.sql.ResultSet]. * `null` (default) means no limit - all available rows will be fetched * or positive integer (e.g., `100`) - fetch at most that many rows * @param [inferNullability] indicates how the column nullability should be inferred. - * @return the DataFrame generated from the [ResultSet][java.sql.ResultSet] data. + * @return the DataFrame generated from the [`ResultSet`][java.sql.ResultSet] data. * * @see [java.sql.ResultSet] */ @@ -596,29 +596,29 @@ public fun ResultSet.readDataFrame(dbType: DbType, limit: Int? = null, inferNull } /** - * Reads the data from a [ResultSet][java.sql.ResultSet] and converts it into a [DataFrame]. + * Reads the data from a [`ResultSet`][java.sql.ResultSet] and converts it into a [DataFrame]. * * @include [org.jetbrains.kotlinx.dataframe.documentation.AutoRenameInputSnippet] * - * A [ResultSet][java.sql.ResultSet] object maintains a cursor pointing to its current row of data. + * A [`ResultSet`][java.sql.ResultSet] object maintains a cursor pointing to its current row of data. * By default, a ResultSet object is not updatable and has a cursor that can only move forward. * Therefore, you can iterate through it only once, from the first row to the last row. * - * For more details, refer to the official Java documentation on [ResultSet][java.sql.ResultSet]. + * For more details, refer to the official Java documentation on [`ResultSet`][java.sql.ResultSet]. * - * __NOTE:__ Reading from the [ResultSet][java.sql.ResultSet] could potentially change its state. + * __NOTE:__ Reading from the [`ResultSet`][java.sql.ResultSet] could potentially change its state. * - * @param [resultSet] the [ResultSet][java.sql.ResultSet] containing the data to read. + * @param [resultSet] the [`ResultSet`][java.sql.ResultSet] containing the data to read. * Its state may be altered after the read operation. * @param [connection] the connection to the database (it's required to extract the database type) * that the [ResultSet] belongs to. - * @param [limit] the maximum number of rows to read from the [ResultSet][java.sql.ResultSet]. + * @param [limit] the maximum number of rows to read from the [`ResultSet`][java.sql.ResultSet]. * `null` (default) means no limit - all available rows will be fetched * or positive integer (e.g., `100`) - fetch at most that many rows * @param [inferNullability] indicates how the column nullability should be inferred. * @param [dbType] the type of database, could be a custom object, provided by user, optional, default is `null`, * in that case the [dbType] will be recognized from the [resultSet]. - * @return the DataFrame generated from the [ResultSet][java.sql.ResultSet] data. + * @return the DataFrame generated from the [`ResultSet`][java.sql.ResultSet] data. * * @see [java.sql.ResultSet] */ @@ -636,27 +636,27 @@ public fun DataFrame.Companion.readResultSet( } /** - * Reads the data from a [ResultSet][java.sql.ResultSet] and converts it into a [DataFrame]. + * Reads the data from a [`ResultSet`][java.sql.ResultSet] and converts it into a [DataFrame]. * * @include [org.jetbrains.kotlinx.dataframe.documentation.AutoRenameInputSnippet] * - * A [ResultSet][java.sql.ResultSet] object maintains a cursor pointing to its current row of data. + * A [`ResultSet`][java.sql.ResultSet] object maintains a cursor pointing to its current row of data. * By default, a ResultSet object is not updatable and has a cursor that can only move forward. * Therefore, you can iterate through it only once, from the first row to the last row. * - * For more details, refer to the official Java documentation on [ResultSet][java.sql.ResultSet]. + * For more details, refer to the official Java documentation on [`ResultSet`][java.sql.ResultSet]. * - * __NOTE:__ Reading from the [ResultSet][java.sql.ResultSet] could potentially change its state. + * __NOTE:__ Reading from the [`ResultSet`][java.sql.ResultSet] could potentially change its state. * * @param [connection] the connection to the database (it's required to extract the database type) * that the [ResultSet] belongs to. - * @param [limit] the maximum number of rows to read from the [ResultSet][java.sql.ResultSet]. + * @param [limit] the maximum number of rows to read from the [`ResultSet`][java.sql.ResultSet]. * `null` (default) means no limit - all available rows will be fetched * or positive integer (e.g., `100`) - fetch at most that many rows * @param [inferNullability] indicates how the column nullability should be inferred. * @param [dbType] the type of database, could be a custom object, provided by user, optional, default is `null`, * in that case the [dbType] will be recognized from the [ResultSet]. - * @return the DataFrame generated from the [ResultSet][java.sql.ResultSet] data. + * @return the DataFrame generated from the [`ResultSet`][java.sql.ResultSet] data. * * @see [java.sql.ResultSet] */ diff --git a/dataframe-json/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt b/dataframe-json/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt index bfa885eb8b..648f5ce238 100644 --- a/dataframe-json/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt +++ b/dataframe-json/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/json.kt @@ -495,7 +495,7 @@ public fun AnyFrame.toJson(prettyPrint: Boolean = false): String { * The default is empty list, which indicates that the image is not encoded as Base64. * @param isFormatted Specifies whether the DataFrame should be formatted, * a.k.a. it comes from [FormattedFrame.df] or it contains a - * [DataColumn][DataColumn]`<`[FormattedFrame][FormattedFrame]`<*>>` at any depth. + * [`DataColumn`][DataColumn]`<`[`FormattedFrame`][FormattedFrame]`<*>>` at any depth. * This is just a marker; formatting is applied by the renderer. Defaults to `false`. * * @return The DataFrame converted to a JSON string with metadata. diff --git a/examples/projects/dev/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/compatibilityLayer.kt b/examples/projects/dev/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/compatibilityLayer.kt index 231a791f6d..0a5377eca0 100644 --- a/examples/projects/dev/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/compatibilityLayer.kt +++ b/examples/projects/dev/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/compatibilityLayer.kt @@ -22,7 +22,7 @@ import kotlin.reflect.full.memberProperties import kotlin.reflect.typeOf /** - * Retrieves all columns of any [Iterable][Iterable]`<`[ResultRow][ResultRow]`>`, like [Query][Query], + * Retrieves all columns of any [`Iterable`][Iterable]`<`[`ResultRow`][ResultRow]`>`, like [`Query`][Query], * from Exposed row by row and converts the resulting [Map] into a [DataFrame], cast to type [T]. * * In notebooks, the untyped version works just as well due to runtime inference :) @@ -31,7 +31,7 @@ inline fun Iterable.convertToDataFrame(): DataFrame convertToDataFrame().convertTo() /** - * Retrieves all columns of an [Iterable][Iterable]`<`[ResultRow][ResultRow]`>` from Exposed, like [Query][Query], + * Retrieves all columns of an [`Iterable`][Iterable]`<`[`ResultRow`][ResultRow]`>` from Exposed, like [`Query`][Query], * row by row and converts the resulting [Map] of lists into a [DataFrame] by calling * [Map.toDataFrame]. */ @@ -62,7 +62,7 @@ val Expression<*>.readableName: String /** * Creates a [DataFrameSchema] from the declared [Table] instance. * - * This is not needed for conversion, but it can be useful to create a DataFrame [@DataSchema][DataSchema] instance. + * This is not needed for conversion, but it can be useful to create a DataFrame [`@DataSchema`][DataSchema] instance. * * @param columnNameToAccessor Optional [MutableMap] which will be filled with entries mapping * the SQL column name to the accessor name from the [Table]. @@ -95,7 +95,7 @@ fun Table.toDataFrameSchema(columnNameToAccessor: MutableMap = m * Creates a [DataFrameSchema] from the declared [Table] instance with a [NameNormalizer] to * convert the SQL column names to the corresponding Kotlin property names. * - * This is not needed for conversion, but it can be useful to create a DataFrame [@DataSchema][DataSchema] instance. + * This is not needed for conversion, but it can be useful to create a DataFrame [`@DataSchema`][DataSchema] instance. * * @see toDataFrameSchema */ diff --git a/examples/projects/dev/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/tables.kt b/examples/projects/dev/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/tables.kt index ee623c99ea..c0c6d1b909 100644 --- a/examples/projects/dev/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/tables.kt +++ b/examples/projects/dev/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/tables.kt @@ -45,7 +45,7 @@ object Customers : Table() { * provide type-safe access to your columns and data. * * While DataFrame can infer types at runtime, which is enough for Kotlin Notebook, - * to get type safe access at compile time, we need to define a [@DataSchema][DataSchema]. + * to get type safe access at compile time, we need to define a [`@DataSchema`][DataSchema]. * * This is what we created the [toDataFrameSchema] function for! */ diff --git a/examples/projects/dev/kotlin-spark/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/spark/typedDataset.kt b/examples/projects/dev/kotlin-spark/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/spark/typedDataset.kt index cc82df8d1b..a1b7aaade9 100644 --- a/examples/projects/dev/kotlin-spark/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/spark/typedDataset.kt +++ b/examples/projects/dev/kotlin-spark/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/spark/typedDataset.kt @@ -23,11 +23,11 @@ import java.io.Serializable /** * For Spark, Kotlin data classes are supported if we: - * - Add [@JvmOverloads][JvmOverloads] to the constructor + * - Add [`@JvmOverloads`][JvmOverloads] to the constructor * - Make all parameter arguments mutable and with defaults * - Make them [Serializable] * - * But by adding [@DataSchema][DataSchema] we can reuse the same class for Spark and DataFrame! + * But by adding [`@DataSchema`][DataSchema] we can reuse the same class for Spark and DataFrame! * * See [Person] and [Name] for an example. * diff --git a/examples/projects/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/compatibilityLayer.kt b/examples/projects/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/compatibilityLayer.kt index 231a791f6d..0a5377eca0 100644 --- a/examples/projects/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/compatibilityLayer.kt +++ b/examples/projects/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/compatibilityLayer.kt @@ -22,7 +22,7 @@ import kotlin.reflect.full.memberProperties import kotlin.reflect.typeOf /** - * Retrieves all columns of any [Iterable][Iterable]`<`[ResultRow][ResultRow]`>`, like [Query][Query], + * Retrieves all columns of any [`Iterable`][Iterable]`<`[`ResultRow`][ResultRow]`>`, like [`Query`][Query], * from Exposed row by row and converts the resulting [Map] into a [DataFrame], cast to type [T]. * * In notebooks, the untyped version works just as well due to runtime inference :) @@ -31,7 +31,7 @@ inline fun Iterable.convertToDataFrame(): DataFrame convertToDataFrame().convertTo() /** - * Retrieves all columns of an [Iterable][Iterable]`<`[ResultRow][ResultRow]`>` from Exposed, like [Query][Query], + * Retrieves all columns of an [`Iterable`][Iterable]`<`[`ResultRow`][ResultRow]`>` from Exposed, like [`Query`][Query], * row by row and converts the resulting [Map] of lists into a [DataFrame] by calling * [Map.toDataFrame]. */ @@ -62,7 +62,7 @@ val Expression<*>.readableName: String /** * Creates a [DataFrameSchema] from the declared [Table] instance. * - * This is not needed for conversion, but it can be useful to create a DataFrame [@DataSchema][DataSchema] instance. + * This is not needed for conversion, but it can be useful to create a DataFrame [`@DataSchema`][DataSchema] instance. * * @param columnNameToAccessor Optional [MutableMap] which will be filled with entries mapping * the SQL column name to the accessor name from the [Table]. @@ -95,7 +95,7 @@ fun Table.toDataFrameSchema(columnNameToAccessor: MutableMap = m * Creates a [DataFrameSchema] from the declared [Table] instance with a [NameNormalizer] to * convert the SQL column names to the corresponding Kotlin property names. * - * This is not needed for conversion, but it can be useful to create a DataFrame [@DataSchema][DataSchema] instance. + * This is not needed for conversion, but it can be useful to create a DataFrame [`@DataSchema`][DataSchema] instance. * * @see toDataFrameSchema */ diff --git a/examples/projects/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/tables.kt b/examples/projects/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/tables.kt index ee623c99ea..c0c6d1b909 100644 --- a/examples/projects/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/tables.kt +++ b/examples/projects/exposed/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed/tables.kt @@ -45,7 +45,7 @@ object Customers : Table() { * provide type-safe access to your columns and data. * * While DataFrame can infer types at runtime, which is enough for Kotlin Notebook, - * to get type safe access at compile time, we need to define a [@DataSchema][DataSchema]. + * to get type safe access at compile time, we need to define a [`@DataSchema`][DataSchema]. * * This is what we created the [toDataFrameSchema] function for! */ diff --git a/examples/projects/kotlin-spark/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/spark/typedDataset.kt b/examples/projects/kotlin-spark/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/spark/typedDataset.kt index cc82df8d1b..a1b7aaade9 100644 --- a/examples/projects/kotlin-spark/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/spark/typedDataset.kt +++ b/examples/projects/kotlin-spark/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/spark/typedDataset.kt @@ -23,11 +23,11 @@ import java.io.Serializable /** * For Spark, Kotlin data classes are supported if we: - * - Add [@JvmOverloads][JvmOverloads] to the constructor + * - Add [`@JvmOverloads`][JvmOverloads] to the constructor * - Make all parameter arguments mutable and with defaults * - Make them [Serializable] * - * But by adding [@DataSchema][DataSchema] we can reuse the same class for Spark and DataFrame! + * But by adding [`@DataSchema`][DataSchema] we can reuse the same class for Spark and DataFrame! * * See [Person] and [Name] for an example. * diff --git a/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/guides/HsqldbGuide.kt b/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/guides/HsqldbGuide.kt index 5c963c08da..8bb9b1341a 100644 --- a/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/guides/HsqldbGuide.kt +++ b/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/guides/HsqldbGuide.kt @@ -385,11 +385,11 @@ class HsqldbGuide : DataFrameSampleHelper("readSqlFromCustomDatabase", "guides") * adhering to [targetColumnSchema]. * * @param [D] the type of the values after preprocessing - * @param [P] the type of the resulting [DataColumn][DataColumn]`<`[P][P]`>`, [targetColumnSchema] + * @param [P] the type of the resulting [`DataColumn`][DataColumn]`<`[`P`][P]`>`, [targetColumnSchema] * @param [name] the name of the column * @param [values] the ([preprocessed][preprocessValue]) values to put in the column * @param [tableColumnMetadata] all information we have about the column - * @param [targetColumnSchema] the schema of the column [DataColumn][DataColumn]`<`[P][P]`>`, + * @param [targetColumnSchema] the schema of the column [`DataColumn`][DataColumn]`<`[`P`][P]`>`, * as determined by [getTargetColumnSchema] * @param [inferNullability] whether to infer nullability from the runtime values (this is more expensive), * as opposed to using the nullability information from the [targetColumnSchema] From 2f5cbe7e9977d1d4a4223921efbfc5780ed0c690 Mon Sep 17 00:00:00 2001 From: Jolan Rensen Date: Tue, 11 Aug 2026 17:40:40 +0200 Subject: [PATCH 4/6] Used claude to further update missing code spans in KDocs --- .../kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt | 2 +- .../kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt | 4 ++-- .../kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt | 6 +++--- .../kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt | 6 +++--- .../kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt | 8 ++++---- .../TwoStepMultipleColumnsHandler.kt | 4 ++-- .../dataframe/impl/columns/TransformableColumnSet.kt | 8 ++++---- 7 files changed, 19 insertions(+), 19 deletions(-) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt index 81927d1d60..c02d4ddb84 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/convert.kt @@ -435,7 +435,7 @@ public class Convert( * The target type is provided as reified argument. * For the full list of supported types, see [SupportedTypes][ConvertDocs.SupportedTypes]. * - * Converting from [String(?)][String] columns is considered "parsing". + * Converting from [`String(?)`][String] columns is considered "parsing". * You can also provide [parserOptions\] to customize the [Locale], date-time options, etc. * See [ParserOptions]. This argument is ignored for non-`String` columns. * diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt index ee93460aad..08bcc32e69 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/group.kt @@ -136,8 +136,8 @@ public fun DataFrame.group(vararg columns: KProperty<*>): GroupClause][AggregationStatistics] + * `| `__`.`__[``][AggregationStatistics] * * ### Pivot [GroupBy] into [PivotGroupBy] and reduce / aggregate it * @@ -173,10 +173,10 @@ internal interface GroupByDocs { * ` \[ `__`.`__[**`default`**][PivotGroupBy.default]**`(`**`defaultValue`**`) `**`]` * * {@include [Indent]} - * __`.`__[][PivotGroupByDocs.Reducing] + * __`.`__[``][PivotGroupByDocs.Reducing] * * {@include [Indent]} - * `| `__`.`__[][PivotGroupByDocs.Aggregation] + * `| `__`.`__[``][PivotGroupByDocs.Aggregation] * * Check out [PivotGroupBy Grammar][PivotGroupByDocs.Grammar] for more information. */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt index 2a3cdebd50..0ea1b9a77f 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/pivot.kt @@ -115,7 +115,7 @@ internal interface PivotDocs { * `| `__`.`__[**`aggregate`**][Pivot.aggregate]**` { `**`aggregations: `[`AggregateDsl`][AggregateDsl]**` }`** * * {@include [Indent]} - * `| `__`.`__[][PivotDocs.AggregationStatistics] + * `| `__`.`__[``][PivotDocs.AggregationStatistics] * * ### Group [Pivot] into [PivotGroupBy] and reduce / aggregate it * @@ -128,10 +128,10 @@ internal interface PivotDocs { * `\[ `__`.`__[**`default`**][PivotGroupBy.default]**`(`**`defaultValue`**`) `**`]` * * {@include [Indent]} - * `| `__`.`__[][PivotGroupByDocs.Reducing] + * `| `__`.`__[``][PivotGroupByDocs.Reducing] * * {@include [Indent]} - * `| `__`.`__[][PivotGroupByDocs.Aggregation] + * `| `__`.`__[``][PivotGroupByDocs.Aggregation] * * Check out [PivotGroupBy Grammar][PivotGroupByDocs.Grammar] for more information. */ diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt index 02de412e21..ffdd21c150 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt @@ -39,8 +39,8 @@ import kotlin.reflect.KProperty * returns a [RenameClause], * which serves as an intermediate step. * The [RenameClause] object provides methods to rename selected columns using: - * - [to(name)][RenameClause.to] - renames selected columns to the specified names. - * - [to { nameExpression }][RenameClause.to] - renames selected columns using a provided + * - [`to(name)`][RenameClause.to] - renames selected columns to the specified names. + * - [`to { nameExpression }`][RenameClause.to] - renames selected columns using a provided * expression assuming column with its path and returning a new name. * - [`toCamelCase()`][RenameClause.toCamelCase] - renames all selected columns to "camelCase". * @@ -173,8 +173,8 @@ public fun DataFrame.rename(vararg cols: String): RenameClause = * in the [DataFrame], but their names will be changed. * * Use the following methods to perform the conversion: - * - [to(name)][RenameClause.to] — renames selected columns to the specified names. - * - [to { nameExpression }][RenameClause.to] — renames selected columns using a custom expression, + * - [`to(name)`][RenameClause.to] — renames selected columns to the specified names. + * - [`to { nameExpression }`][RenameClause.to] — renames selected columns using a custom expression, * which takes the column and its path and returns a new name. * - [`toCamelCase()`][RenameClause.toCamelCase] — renames all selected columns to `camelCase`. * diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/multipleColumnsHandlers/TwoStepMultipleColumnsHandler.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/multipleColumnsHandlers/TwoStepMultipleColumnsHandler.kt index d13ffcf380..eea4a50244 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/multipleColumnsHandlers/TwoStepMultipleColumnsHandler.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/multipleColumnsHandlers/TwoStepMultipleColumnsHandler.kt @@ -54,8 +54,8 @@ internal class TwoStepMultipleColumnsHandler( /** * Aggregates the data in the multiple given columns and computes a single resulting value. * - * This function calls [`aggregator`][aggregator] [.aggregateSingleColumn()][Aggregator.aggregateSingleColumn] - * on each column and then [stepTwo] [.aggregateSequence()][Aggregator.aggregateSequence] on the results. + * This function calls [`aggregator`][aggregator] [`.aggregateSingleColumn()`][Aggregator.aggregateSingleColumn] + * on each column and then [stepTwo] [`.aggregateSequence()`][Aggregator.aggregateSequence] on the results. */ override fun aggregateMultipleColumns(columns: Sequence>): Return { val (values, types) = columns.map { col -> diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt index ef4f7018e1..953f8c6396 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/TransformableColumnSet.kt @@ -13,9 +13,9 @@ import org.jetbrains.kotlinx.dataframe.columns.SingleColumn * This type of [ColumnsResolver] can be [transformed][transformResolve] before being resolved. * * This is especially useful for calls like - * [colsInternal { }][ColumnsResolver.colsInternal].[`atAnyDepthImpl()`][atAnyDepthImpl], + * [`colsInternal { }`][ColumnsResolver.colsInternal].[`atAnyDepthImpl()`][atAnyDepthImpl], * where [`atAnyDepthImpl`][atAnyDepthImpl] modifies the [`ColumnSet`][ColumnsResolver] - * that [colsInternal { }][ColumnsResolver.colsInternal] operates on to include ALL columns, including those inside + * that [`colsInternal { }`][ColumnsResolver.colsInternal] operates on to include ALL columns, including those inside * column groups, before it's evaluated. * * @see [ColumnsResolver] @@ -35,9 +35,9 @@ internal interface TransformableColumnSet : ColumnSet { * This type of [SingleColumn] can be [transformed][transformResolveSingle] before being resolved. * * This is especially useful for calls like - * [singleInternal { }][ColumnsResolver.singleInternal].[`atAnyDepthImpl()`][atAnyDepthImpl], + * [`singleInternal { }`][ColumnsResolver.singleInternal].[`atAnyDepthImpl()`][atAnyDepthImpl], * where [`atAnyDepthImpl`][atAnyDepthImpl] modifies the [SingleColumn] - * that [singleInternal { }][ColumnsResolver.singleInternal] operates on to include ALL columns, including those inside + * that [`singleInternal { }`][ColumnsResolver.singleInternal] operates on to include ALL columns, including those inside * column groups, before it's evaluated. * * @see [SingleColumn] From 82808e2997cc24bdfbca2a9a0525c27c705715e4 Mon Sep 17 00:00:00 2001 From: Jolan Rensen Date: Tue, 11 Aug 2026 18:34:27 +0200 Subject: [PATCH 5/6] Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- .../main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt index 2cc5f9614b..3759625509 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/gather.kt @@ -427,7 +427,7 @@ public class Gather( * without modifying the values themselves. * * This is useful when the type cannot be automatically inferred and needs to be explicitly specified - * for further [Gather] operations such as [filter][Gather.where], [`notNull`][Gather.notNull], + * for further [Gather] operations such as [`filter`][Gather.where], [`notNull`][Gather.notNull], * or [`mapValues`][Gather.mapValues]. * It does not affect the actual content of the values — * only the type used for compile-time safety and transformation configuration. From 162d2a76d704b329174144ed08c7fa7b114ad14e Mon Sep 17 00:00:00 2001 From: Jolan Rensen Date: Tue, 11 Aug 2026 18:34:38 +0200 Subject: [PATCH 6/6] Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- .../org/jetbrains/kotlinx/dataframe/api/typeConversions.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/typeConversions.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/typeConversions.kt index 90775a18b2..f449257ed6 100644 --- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/typeConversions.kt +++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/typeConversions.kt @@ -163,7 +163,7 @@ public fun ColumnGroup.asDataFrame(): DataFrame = this /** * ## As ColumnGroup * - * Creates a [`ColumnAccessor`][ColumnAccessor]`<`[`DataRow`][DataRow]`<`[`C`][C\]`>>` from [this][this\]. + * Creates a [`ColumnAccessor`][ColumnAccessor]`<`[`DataRow`][DataRow]`<`[`C`][C\]`>>` from [`this`][this\]. * This is especially useful when you want to use [ColumnGroup] functions in the [ColumnsSelectionDsl] but your column * type is not recognized as a [ColumnGroup]. * If you're not sure whether a column is recognized as [ColumnGroup] or not, you can always call [`asColumnGroup`][asColumnGroup\]